@pagopa/io-react-native-wallet 2.0.0 → 2.1.0

package/lib/typescript/sd-jwt/types.d.ts

@@ -450,7 +450,7 @@ export declare const Verification: z.ZodObject<{
     assurance_level: z.ZodString;
     evidence: z.ZodArray<z.ZodObject<{
         type: z.ZodLiteral<"vouch">;
-        time: z.ZodString;
+        time: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
         attestation: z.ZodObject<{
             type: z.ZodLiteral<"digital_attestation">;
             reference_number: z.ZodString;
@@ -479,7 +479,7 @@ export declare const Verification: z.ZodObject<{
         }>;
     }, "strip", z.ZodTypeAny, {
         type: "vouch";
-        time: string;
+        time: string | number;
         attestation: {
             type: "digital_attestation";
             reference_number: string;
@@ -490,7 +490,7 @@ export declare const Verification: z.ZodObject<{
         };
     }, {
         type: "vouch";
-        time: string;
+        time: string | number;
         attestation: {
             type: "digital_attestation";
             reference_number: string;
@@ -505,7 +505,7 @@ export declare const Verification: z.ZodObject<{
     assurance_level: string;
     evidence: {
         type: "vouch";
-        time: string;
+        time: string | number;
         attestation: {
             type: "digital_attestation";
             reference_number: string;
@@ -520,7 +520,7 @@ export declare const Verification: z.ZodObject<{
     assurance_level: string;
     evidence: {
         type: "vouch";
-        time: string;
+        time: string | number;
         attestation: {
             type: "digital_attestation";
             reference_number: string;

package/lib/typescript/sd-jwt/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/sd-jwt/types.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,QAAQ,aAAuC,CAAC;AAC7D,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAEhD,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAC1E,eAAO,MAAM,qBAAqB;;;;;;EAAyC,CAAC;AAE5E;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AACpD,eAAO,MAAM,UAAU,4DAIrB,CAAC;AAEH;;;GAGG;AACH,MAAM,MAAM,0BAA0B,GAAG,OAAO,aAAa,CAAC;AAC9D,eAAO,MAAM,aAAa,cAAc,CAAC;AAEzC;;;;;;;GAOG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,OAAO,EAAE,UAAU,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAMF;;;GAGG;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAChD,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCnB,CAAC;AAEH;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AACxD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAevB,CAAC;AAEH;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AACxD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcvB,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/sd-jwt/types.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,QAAQ,aAAuC,CAAC;AAC7D,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAEhD,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAC1E,eAAO,MAAM,qBAAqB;;;;;;EAAyC,CAAC;AAE5E;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AACpD,eAAO,MAAM,UAAU,4DAIrB,CAAC;AAEH;;;GAGG;AACH,MAAM,MAAM,0BAA0B,GAAG,OAAO,aAAa,CAAC;AAC9D,eAAO,MAAM,aAAa,cAAc,CAAC;AAEzC;;;;;;;GAOG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,OAAO,EAAE,UAAU,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAMF;;;GAGG;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAChD,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCnB,CAAC;AAEH;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AACxD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBvB,CAAC;AAEH;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AACxD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcvB,CAAC"}

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

@@ -0,0 +1,23 @@
+type DisplayData = {
+    locale: string;
+    name: string;
+}[];
+type LocalizedNames = Record<string, string>;
+type PropertyNode<T> = {
+    value: T;
+    name: LocalizedNames;
+};
+type Path = (string | number | null)[];
+type NodeOrStructure = Partial<PropertyNode<any>> | Record<string, any> | any[];
+/**
+ * Recursively constructs a nested object with descriptive properties from a path.
+ *
+ * @param currentObject - The object or array being built upon.
+ * @param path - The path segments to follow.
+ * @param sourceValue - The raw value to place at the end of the path.
+ * @param displayData - The data for generating localized names.
+ * @returns The new object or array structure.
+ */
+export declare const createNestedProperty: (currentObject: NodeOrStructure, path: Path, sourceValue: unknown, displayData: DisplayData) => NodeOrStructure;
+export {};
+//# sourceMappingURL=nestedProperty.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nestedProperty.d.ts","sourceRoot":"","sources":["../../../src/utils/nestedProperty.ts"],"names":[],"mappings":"AAGA,KAAK,WAAW,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,CAAC;AAGtD,KAAK,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAG7C,KAAK,YAAY,CAAC,CAAC,IAAI;IACrB,KAAK,EAAE,CAAC,CAAC;IACT,IAAI,EAAE,cAAc,CAAC;CACtB,CAAC;AAGF,KAAK,IAAI,GAAG,CAAC,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;AAGvC,KAAK,eAAe,GAAG,OAAO,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,EAAE,CAAC;AA6GhF;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,kBAChB,eAAe,2BAEjB,OAAO,+BAEnB,eA4BF,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pagopa/io-react-native-wallet",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Provide data structures, helpers and API for IO Wallet",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -57,7 +57,7 @@
     "@pagopa/io-react-native-iso18013": "^0.3.0",
     "@pagopa/io-react-native-jwt": "^2.1.0",
     "@react-native/babel-preset": "0.78.3",
-    "@react-native/eslint-config": "^0.75.5",
+    "@react-native/eslint-config": "0.78.3",
     "@rushstack/eslint-patch": "^1.3.2",
     "@types/jest": "^29.5.13",
     "@types/jsrsasign": "^10.5.15",

package/src/credential/issuance/07-verify-and-parse-credential.ts

@@ -1,5 +1,5 @@
 import type { CryptoContext } from "@pagopa/io-react-native-jwt";
-import { isObject, type Out } from "../../utils/misc";
+import { type Out } from "../../utils/misc";
 import type { EvaluateIssuerTrust } from "./02-evaluate-issuer-trust";
 import { IoWalletError } from "../../utils/errors";
 import { SdJwt4VC, verify as verifySdJwt } from "../../sd-jwt";
@@ -13,6 +13,7 @@ import { LogLevel, Logger } from "../../utils/logging";
 import { extractElementValueAsDate } from "../../mdoc/converter";
 import type { CBOR } from "@pagopa/io-react-native-iso18013";
 import type { PublicKey } from "@pagopa/io-react-native-crypto";
+import { createNestedProperty } from "../../utils/nestedProperty";
 
 type IssuerConf = Out<EvaluateIssuerTrust>["issuerConf"];
 type CredentialConf =
@@ -64,118 +65,6 @@ type DecodedSdJwtCredential = Out<typeof verifySdJwt> & {
   sdJwt: SdJwt4VC;
 };
 
-// The data used to create localized names
-type DisplayData = { locale: string; name: string }[];
-
-// The resulting object of localized names { en: "Name", it: "Nome" }
-type LocalizedNames = Record<string, string>;
-
-// The core structure being built: a node containing the actual value and its localized names
-type PropertyNode<T> = {
-  value: T;
-  name: LocalizedNames;
-};
-
-// A path can consist of object keys, array indices, or null for mapping
-type Path = (string | number | null)[];
-
-// A union of all possible shapes. It can be a custom PropertyNode or a standard object/array structure
-type NodeOrStructure = Partial<PropertyNode<any>> | Record<string, any> | any[];
-
-// Helper to build localized names from the display data.
-const buildName = (display: DisplayData): LocalizedNames =>
-  display.reduce(
-    (names, { locale, name }) => ({ ...names, [locale]: name }),
-    {}
-  );
-
-/**
- * Recursively constructs a nested object with descriptive properties from a path.
- *
- * @param currentObject - The object or array being built upon.
- * @param path - The path segments to follow.
- * @param sourceValue - The raw value to place at the end of the path.
- * @param displayData - The data for generating localized names.
- * @returns The new object or array structure.
- */
-const createNestedProperty = (
-  currentObject: NodeOrStructure,
-  path: Path,
-  sourceValue: unknown, // Use `unknown` for type-safe input
-  displayData: DisplayData
-): NodeOrStructure => {
-  const [key, ...rest] = path;
-
-  // Case 1: Map over an array (key is null)
-  if (key === null) {
-    if (!Array.isArray(sourceValue)) return currentObject;
-
-    // We assert the type here because we know this branch handles PropertyNodes
-    const node = currentObject as Partial<PropertyNode<unknown[]>>;
-    const existingValue = Array.isArray(node.value) ? node.value : [];
-
-    const mappedArray = sourceValue.map((item, idx) =>
-      createNestedProperty(existingValue[idx] || {}, rest, item, displayData)
-    );
-
-    return {
-      ...node,
-      value: mappedArray,
-      name: node.name ?? buildName(displayData),
-    };
-  }
-
-  // Case 2: Handle an object key (key is a string)
-  if (typeof key === "string") {
-    let nextSourceValue = sourceValue;
-
-    if (isObject(sourceValue)) {
-      // Skip processing when the key is not found within the claim object
-      if (!(key in sourceValue)) return currentObject;
-
-      nextSourceValue = sourceValue[key];
-    }
-
-    // base case
-    if (rest.length === 0) {
-      return {
-        ...currentObject,
-        [key]: { value: nextSourceValue, name: buildName(displayData) },
-      };
-    }
-
-    // recursive step
-    const nextObject =
-      (currentObject as Record<string, NodeOrStructure>)[key] || {};
-
-    return {
-      ...currentObject,
-      [key]: createNestedProperty(
-        nextObject,
-        rest,
-        nextSourceValue,
-        displayData
-      ),
-    };
-  }
-
-  // Case 3: Handle a specific array index (key is a number)
-  if (typeof key === "number") {
-    const newArray = Array.isArray(currentObject) ? [...currentObject] : [];
-    const nextValue = Array.isArray(sourceValue) ? sourceValue[key] : undefined;
-
-    newArray[key] = createNestedProperty(
-      newArray[key] || {},
-      rest,
-      nextValue,
-      displayData
-    );
-    return newArray;
-  }
-
-  return currentObject;
-};
-
 const parseCredentialSdJwt = (
   // The credential configuration to use to parse the provided credential
   credentialConfig: CredentialConf,

package/src/sd-jwt/__test__/types.test.ts

@@ -1,4 +1,4 @@
-import { Disclosure, SdJwt4VC } from "../types";
+import { Disclosure, SdJwt4VC, Verification } from "../types";
 
 describe("SdJwt4VC", () => {
   it("should accept a valid token", () => {
@@ -75,3 +75,51 @@ describe("Disclosure", () => {
     expect(success).toBe(true);
   });
 });
+
+describe("Verification.time", () => {
+  test.each([
+    ["ISO string", "2025-09-09T10:00:00Z"],
+    ["unix seconds", 1752122400],
+    ["unix milliseconds", 1752122400000],
+  ])("accepts %s", (_label, time) => {
+    const value = {
+      trust_framework: "eidas",
+      assurance_level: "high",
+      evidence: [
+        {
+          type: "vouch",
+          time,
+          attestation: {
+            type: "digital_attestation",
+            reference_number: "abc",
+            date_of_issuance: "2025-09-02",
+            voucher: { organization: "IPZS" },
+          },
+        },
+      ],
+    };
+
+    expect(Verification.safeParse(value).success).toBe(true);
+  });
+
+  it("rejects invalid type", () => {
+    const value = {
+      trust_framework: "eidas",
+      assurance_level: "high",
+      evidence: [
+        {
+          type: "vouch",
+          time: null,
+          attestation: {
+            type: "digital_attestation",
+            reference_number: "abc",
+            date_of_issuance: "2025-09-02",
+            voucher: { organization: "IPZS" },
+          },
+        },
+      ],
+    };
+
+    expect(Verification.safeParse(value).success).toBe(false);
+  });
+});

package/src/sd-jwt/types.ts

@@ -96,7 +96,8 @@ export const Verification = z.object({
   evidence: z.array(
     z.object({
       type: z.literal("vouch"),
-      time: z.string(),
+      // Support both string and UNIX timestamp for backward compatibility
+      time: z.union([z.string(), z.number()]),
       attestation: z.object({
         type: z.literal("digital_attestation"),
         reference_number: z.string(),

package/src/utils/nestedProperty.ts

@@ -0,0 +1,198 @@
+import { isObject } from "./misc";
+
+// The data used to create localized names
+type DisplayData = { locale: string; name: string }[];
+
+// The resulting object of localized names { en: "Name", it: "Nome" }
+type LocalizedNames = Record<string, string>;
+
+// The core structure being built: a node containing the actual value and its localized names
+type PropertyNode<T> = {
+  value: T;
+  name: LocalizedNames;
+};
+
+// A path can consist of object keys, array indices, or null for mapping
+type Path = (string | number | null)[];
+
+// A union of all possible shapes. It can be a custom PropertyNode or a standard object/array structure
+type NodeOrStructure = Partial<PropertyNode<any>> | Record<string, any> | any[];
+
+// Helper to build localized names from the display data.
+const buildName = (display: DisplayData): LocalizedNames =>
+  display.reduce(
+    (names, { locale, name }) => ({ ...names, [locale]: name }),
+    {}
+  );
+
+// Handles the case where the path key is `null`
+const handleNullKeyCase = (
+  currentObject: NodeOrStructure,
+  rest: Path,
+  sourceValue: unknown,
+  displayData: DisplayData
+): NodeOrStructure => {
+  if (!Array.isArray(sourceValue)) return currentObject;
+
+  // We assert the type here because we know this branch handles PropertyNodes
+  const node = currentObject as Partial<PropertyNode<unknown[]>>;
+  const existingValue = Array.isArray(node.value) ? node.value : [];
+
+  const mappedArray = sourceValue.map((item, idx) =>
+    createNestedProperty(existingValue[idx] || {}, rest, item, displayData)
+  );
+
+  return {
+    ...node,
+    value: mappedArray,
+    name: node.name ?? buildName(displayData),
+  };
+};
+
+// Handles the case where the path key is a string
+const handleStringKeyCase = (
+  currentObject: NodeOrStructure,
+  key: string,
+  rest: Path,
+  sourceValue: unknown,
+  displayData: DisplayData
+): NodeOrStructure => {
+  let nextSourceValue = sourceValue;
+  const isLeaf = rest.length === 0;
+
+  if (isObject(sourceValue)) {
+    // Check if any remaining string keys in the path exist in current sourceValue
+    // This handles nested object paths (unlike arrays which use null in the path)
+    const hasRestKey = rest.some(
+      (r) => typeof r === "string" && r in sourceValue
+    );
+
+    if (hasRestKey) {
+      return handleRestKey(currentObject, key, rest, sourceValue, displayData);
+    }
+
+    // Skip processing when the key is not found within the claim object
+    if (!(key in sourceValue)) {
+      // Leaf node: create a node with an empty value and display name
+      if (isLeaf) {
+        return {
+          ...currentObject,
+          [key]: { value: {}, name: buildName(displayData) },
+        };
+      }
+      // Skip processing when the key is not found within the claim object
+      return currentObject;
+    }
+
+    nextSourceValue = sourceValue[key];
+  }
+
+  // base case
+  if (isLeaf) {
+    return {
+      ...currentObject,
+      [key]: { value: nextSourceValue, name: buildName(displayData) },
+    };
+  }
+
+  // recursive step
+  const nextObject =
+    (currentObject as Record<string, NodeOrStructure>)[key] || {};
+
+  return {
+    ...currentObject,
+    [key]: createNestedProperty(nextObject, rest, nextSourceValue, displayData),
+  };
+};
+
+// Handles the case where the path key is a number
+const handleNumberKeyCase = (
+  currentObject: NodeOrStructure,
+  key: number,
+  rest: Path,
+  sourceValue: unknown,
+  displayData: DisplayData
+): NodeOrStructure => {
+  const newArray = Array.isArray(currentObject) ? [...currentObject] : [];
+  const nextValue = Array.isArray(sourceValue) ? sourceValue[key] : undefined;
+
+  newArray[key] = createNestedProperty(
+    newArray[key] || {},
+    rest,
+    nextValue,
+    displayData
+  );
+  return newArray;
+};
+
+/**
+ * Recursively constructs a nested object with descriptive properties from a path.
+ *
+ * @param currentObject - The object or array being built upon.
+ * @param path - The path segments to follow.
+ * @param sourceValue - The raw value to place at the end of the path.
+ * @param displayData - The data for generating localized names.
+ * @returns The new object or array structure.
+ */
+export const createNestedProperty = (
+  currentObject: NodeOrStructure,
+  path: Path,
+  sourceValue: unknown, // Use `unknown` for type-safe input
+  displayData: DisplayData
+): NodeOrStructure => {
+  const [key, ...rest] = path;
+
+  switch (true) {
+    case key === null:
+      return handleNullKeyCase(currentObject, rest, sourceValue, displayData);
+
+    case typeof key === "string":
+      return handleStringKeyCase(
+        currentObject,
+        key as string,
+        rest,
+        sourceValue,
+        displayData
+      );
+
+    case typeof key === "number":
+      return handleNumberKeyCase(
+        currentObject,
+        key as number,
+        rest,
+        sourceValue,
+        displayData
+      );
+
+    default:
+      return currentObject;
+  }
+};
+
+// Handles the case where the next key in the path exists in the source object
+const handleRestKey = (
+  currentObject: Record<string, any>,
+  key: string,
+  rest: Path,
+  sourceValue: Record<string, unknown>,
+  displayData: DisplayData
+): NodeOrStructure => {
+  const currentNode = currentObject[key] ?? {};
+  // Take the first key in the remaining path
+  const restKey = rest[0] as string;
+  const nextSourceValue = sourceValue[restKey];
+
+  // Merge the current node with the updated nested property for the remaining path.
+  return {
+    ...currentObject,
+    [key]: {
+      ...currentNode,
+      value: createNestedProperty(
+        currentNode.value ?? {},
+        rest,
+        nextSourceValue,
+        displayData
+      ),
+    },
+  };
+};