@pagopa/io-react-native-wallet 3.6.2 → 3.6.4

package/src/utils/dpop.ts

@@ -1,7 +1,6 @@
+import { type CryptoContext, SignJWT } from "@pagopa/io-react-native-jwt";
 import * as z from "zod";
 
-import { SignJWT, type CryptoContext } from "@pagopa/io-react-native-jwt";
-
 /**
  * Create a signed DPoP token
  *
@@ -12,14 +11,14 @@ import { SignJWT, type CryptoContext } from "@pagopa/io-react-native-jwt";
  */
 export const createDPopToken = async (
   payload: DPoPPayload,
-  crypto: CryptoContext
+  crypto: CryptoContext,
 ): Promise<string> => {
   const jwk = await crypto.getPublicKey();
   return new SignJWT(crypto)
     .setPayload(payload)
     .setProtectedHeader({
-      typ: "dpop+jwt",
       jwk,
+      typ: "dpop+jwt",
     })
     .setIssuedAt()
     .setExpirationTime("1h")
@@ -28,8 +27,8 @@ export const createDPopToken = async (
 
 export type DPoPPayload = z.infer<typeof DPoPPayload>;
 export const DPoPPayload = z.object({
-  jti: z.string(),
+  ath: z.string().optional(),
   htm: z.enum(["POST", "GET"]),
   htu: z.string(),
-  ath: z.string().optional(),
+  jti: z.string(),
 });

package/src/utils/error-codes.ts

@@ -1,5 +1,8 @@
 export const IssuerResponseErrorCodes = {
-  IssuerGenericError: "ERR_ISSUER_GENERIC_ERROR",
+  /**
+   * Error code thrown when a credential status is invalid, either during issuance or when requesting a status attestation.
+   */
+  CredentialInvalidStatus: "ERR_CREDENTIAL_INVALID_STATUS",
   /**
    * Error code thrown when a credential cannot be issued immediately because it follows the async flow.
    */
@@ -8,58 +11,55 @@ export const IssuerResponseErrorCodes = {
    * Error code thrown when an error occurs while requesting a credential.
    */
   CredentialRequestFailed: "ERR_CREDENTIAL_REQUEST_FAILED",
+  IssuerGenericError: "ERR_ISSUER_GENERIC_ERROR",
   /**
-   * Error code thrown when a credential status is invalid, either during issuance or when requesting a status attestation.
+   * Error code thrown when an error occurs while initializing the MRTD challenge.
    */
-  CredentialInvalidStatus: "ERR_CREDENTIAL_INVALID_STATUS",
+  MrtdChallengeInitRequestFailed: "ERR_MRTD_CHALLENGE_INIT_REQUEST_FAILED",
   /**
    * Error code thrown when an error occurs while obtaining a status attestation for a credential.
    */
   StatusAttestationRequestFailed: "ERR_STATUS_ATTESTATION_REQUEST_FAILED",
-  /**
-   * Error code thrown when an error occurs while initializing the MRTD challenge.
-   */
-  MrtdChallengeInitRequestFailed: "ERR_MRTD_CHALLENGE_INIT_REQUEST_FAILED",
 } as const;
 
 export const WalletProviderResponseErrorCodes = {
-  WalletProviderGenericError: "ERR_IO_WALLET_PROVIDER_GENERIC_ERROR",
-  /**
-   * An error code thrown when an error occurs during the wallet instance creation process.
-   */
-  WalletInstanceCreationFailed: "ERR_IO_WALLET_INSTANCE_CREATION_FAILED",
   /**
    * An error code thrown when validation fail
    */
   WalletInstanceAttestationIssuingFailed:
     "ERR_IO_WALLET_INSTANCE_ATTESTATION_ISSUING_FAILED",
   /**
-   * An error code thrown when the requester does not pass the integrity checks when interacting with the Wallet Provider.
+   * An error code thrown when an error occurs during the wallet instance creation process.
    */
-  WalletInstanceIntegrityFailed: "ERR_IO_WALLET_INSTANCE_INTEGRITY_FAILED",
+  WalletInstanceCreationFailed: "ERR_IO_WALLET_INSTANCE_CREATION_FAILED",
   /**
-   * An error code thrown when obtaining a wallet instance attestation but the wallet instance is revoked.
+   * An error code thrown when the requester does not pass the integrity checks when interacting with the Wallet Provider.
    */
-  WalletInstanceRevoked: "ERR_IO_WALLET_INSTANCE_REVOKED",
+  WalletInstanceIntegrityFailed: "ERR_IO_WALLET_INSTANCE_INTEGRITY_FAILED",
   /**
    * An error code thrown when obtaining a wallet instance attestation but the wallet instance is not found.
    */
   WalletInstanceNotFound: "ERR_IO_WALLET_INSTANCE_NOT_FOUND",
+  /**
+   * An error code thrown when obtaining a wallet instance attestation but the wallet instance is revoked.
+   */
+  WalletInstanceRevoked: "ERR_IO_WALLET_INSTANCE_REVOKED",
+  WalletProviderGenericError: "ERR_IO_WALLET_PROVIDER_GENERIC_ERROR",
 } as const;
 
 export const RelyingPartyResponseErrorCodes = {
-  RelyingPartyGenericError: "ERR_RP_GENERIC_ERROR",
   /**
    * An error code thrown then the Relying Party rejects the Wallet's Authorization Response.
    */
   InvalidAuthorizationResponse: "ERR_RP_INVALID_AUTHORIZATION_RESPONSE",
+  RelyingPartyGenericError: "ERR_RP_GENERIC_ERROR",
 } as const;
 
 export type IssuerResponseErrorCode =
   (typeof IssuerResponseErrorCodes)[keyof typeof IssuerResponseErrorCodes];
 
-export type WalletProviderResponseErrorCode =
-  (typeof WalletProviderResponseErrorCodes)[keyof typeof WalletProviderResponseErrorCodes];
-
 export type RelyingPartyResponseErrorCode =
   (typeof RelyingPartyResponseErrorCodes)[keyof typeof RelyingPartyResponseErrorCodes];
+
+export type WalletProviderResponseErrorCode =
+  (typeof WalletProviderResponseErrorCodes)[keyof typeof WalletProviderResponseErrorCodes];

package/src/utils/errors.ts

@@ -1,6 +1,8 @@
 import { UnexpectedStatusCodeError as SdkUnexpectedStatusCodeError } from "@pagopa/io-wallet-utils";
+
 import type { ProblemJson } from "../client/generated/wallet-provider";
 import type { IssuerConfig } from "../credential/issuance/api";
+
 import {
   type IssuerResponseErrorCode,
   IssuerResponseErrorCodes,
@@ -12,12 +14,12 @@ import {
 
 export {
   IssuerResponseErrorCodes,
-  WalletProviderResponseErrorCodes,
   RelyingPartyResponseErrorCodes,
+  WalletProviderResponseErrorCodes,
 };
 
 // An error reason that supports both a string and a generic JSON object
-type GenericErrorReason = string | Record<string, unknown>;
+type GenericErrorReason = Record<string, unknown> | string;
 
 /**
  * utility to format a set of attributes into an error message string
@@ -30,7 +32,7 @@ type GenericErrorReason = string | Record<string, unknown>;
  * @returns a human-readable serialization of the set
  */
 export const serializeAttrs = (
-  attrs: Record<string, GenericErrorReason | number | Array<string> | undefined>
+  attrs: Record<string, GenericErrorReason | number | string[] | undefined>,
 ): string =>
   Object.entries(attrs)
     .filter(([, v]) => v !== undefined)
@@ -58,10 +60,10 @@ export const serializeAttrs = (
  *   (e) => new InvalidCredentialOfferError(e.message)
  * );
  */
-export const withMappedErrors = <T, E extends Error>(
+export const withMappedErrors = <T, E extends Error, Args extends unknown[]>(
   fn: () => T,
-  sourceError: new (...args: any[]) => E,
-  mapError: (error: E) => Error
+  sourceError: new (...args: Args) => E,
+  mapError: (error: E) => Error,
 ): T => {
   try {
     return fn();
@@ -73,6 +75,14 @@ export const withMappedErrors = <T, E extends Error>(
   }
 };
 
+type LocalizedIssuanceError = Record<
+  string,
+  {
+    description: string;
+    title: string;
+  }
+>;
+
 /**
  * A generic Error that all other io-wallet specific Error subclasses extend.
  *
@@ -86,7 +96,7 @@ export const withMappedErrors = <T, E extends Error>(
  */
 export class IoWalletError extends Error {
   /** A unique error code for the particular error subclass. */
-  code: string = "ERR_IO_WALLET_GENERIC";
+  code = "ERR_IO_WALLET_GENERIC";
 
   constructor(message?: string) {
     super(message);
@@ -94,41 +104,13 @@ export class IoWalletError extends Error {
   }
 }
 
-/**
- * An error subclass thrown when validation fail
- *
- */
-export class ValidationFailed extends IoWalletError {
-  code = "ERR_IO_WALLET_VALIDATION_FAILED";
-
-  /** The Claim for which the validation failed. */
-  claim: string;
-
-  /** Reason code for the validation failure. */
-  reason: string;
-
-  constructor({
-    message,
-    claim = "unspecified",
-    reason = "unspecified",
-  }: {
-    message: string;
-    claim?: string;
-    reason?: string;
-  }) {
-    super(serializeAttrs({ message, claim, reason }));
-    this.claim = claim;
-    this.reason = reason;
-  }
-}
-
 /**
  * An error subclass thrown when an HTTP request has a status code different from the one expected.
  */
 export class UnexpectedStatusCodeError extends IoWalletError {
-  code: string = "ERR_UNEXPECTED_STATUS_CODE";
-  statusCode: number;
+  code = "ERR_UNEXPECTED_STATUS_CODE";
   reason: GenericErrorReason;
+  statusCode: number;
 
   constructor({
     message,
@@ -164,53 +146,74 @@ export class IssuerResponseError extends UnexpectedStatusCodeError {
 }
 
 /**
- * An error subclass thrown when a Wallet Provider HTTP request fails.
+ * An error subclass thrown when a Relying Party HTTP request fails.
  * The specific error can be found in the `code` property.
  */
-export class WalletProviderResponseError extends UnexpectedStatusCodeError {
-  code: WalletProviderResponseErrorCode;
-  reason: ProblemJson;
+export class RelyingPartyResponseError extends UnexpectedStatusCodeError {
+  code: RelyingPartyResponseErrorCode;
 
   constructor(params: {
-    code?: WalletProviderResponseErrorCode;
+    code?: RelyingPartyResponseErrorCode;
     message: string;
-    reason: ProblemJson;
+    reason: GenericErrorReason;
     statusCode: number;
   }) {
     super(params);
-    this.reason = params.reason;
     this.code =
-      params.code ??
-      WalletProviderResponseErrorCodes.WalletProviderGenericError;
+      params.code ?? RelyingPartyResponseErrorCodes.RelyingPartyGenericError;
   }
 }
 
 /**
- * An error subclass thrown when a Relying Party HTTP request fails.
+ * An error subclass thrown when validation fail
+ *
+ */
+export class ValidationFailed extends IoWalletError {
+  /** The Claim for which the validation failed. */
+  claim: string;
+
+  code = "ERR_IO_WALLET_VALIDATION_FAILED";
+
+  /** Reason code for the validation failure. */
+  reason: string;
+
+  constructor({
+    claim = "unspecified",
+    message,
+    reason = "unspecified",
+  }: {
+    claim?: string;
+    message: string;
+    reason?: string;
+  }) {
+    super(serializeAttrs({ claim, message, reason }));
+    this.claim = claim;
+    this.reason = reason;
+  }
+}
+
+/**
+ * An error subclass thrown when a Wallet Provider HTTP request fails.
  * The specific error can be found in the `code` property.
  */
-export class RelyingPartyResponseError extends UnexpectedStatusCodeError {
-  code: RelyingPartyResponseErrorCode;
+export class WalletProviderResponseError extends UnexpectedStatusCodeError {
+  code: WalletProviderResponseErrorCode;
+  reason: ProblemJson;
 
   constructor(params: {
-    code?: RelyingPartyResponseErrorCode;
+    code?: WalletProviderResponseErrorCode;
     message: string;
-    reason: GenericErrorReason;
+    reason: ProblemJson;
     statusCode: number;
   }) {
     super(params);
+    this.reason = params.reason;
     this.code =
-      params.code ?? RelyingPartyResponseErrorCodes.RelyingPartyGenericError;
+      params.code ??
+      WalletProviderResponseErrorCodes.WalletProviderGenericError;
   }
 }
 
-type LocalizedIssuanceError = {
-  [locale: string]: {
-    title: string;
-    description: string;
-  };
-};
-
 /**
  * Function to extract the error message from the Entity Configuration's supported error codes.
  * @param errorCode The error code to map to a meaningful message
@@ -222,33 +225,34 @@ type LocalizedIssuanceError = {
 export function extractErrorMessageFromIssuerConf(
   errorCode: string,
   {
-    issuerConf,
     credentialType,
+    issuerConf,
   }: {
-    issuerConf: IssuerConfig;
     credentialType: string;
-  }
+    issuerConf: IssuerConfig;
+  },
 ): LocalizedIssuanceError | undefined {
   const credentialConfiguration =
     issuerConf.credential_configurations_supported[credentialType];
 
   if (!credentialConfiguration) {
     throw new IoWalletError(
-      `No configuration found for ${credentialType} in the provided EC`
+      `No configuration found for ${credentialType} in the provided EC`,
     );
   }
 
   const { issuance_errors_supported } = credentialConfiguration;
 
-  if (!issuance_errors_supported?.[errorCode]) {
+  const errorConfig = issuance_errors_supported?.[errorCode];
+  if (!errorConfig) {
     return undefined;
   }
 
-  const localesList = issuance_errors_supported[errorCode]!.display;
+  const localesList = errorConfig.display;
 
   return localesList.reduce(
     (acc, { locale, ...rest }) => ({ ...acc, [locale]: rest }),
-    {} as LocalizedIssuanceError
+    {} as LocalizedIssuanceError,
   );
 }
 
@@ -265,35 +269,35 @@ const makeErrorTypeGuard =
 
 export const isIssuerResponseError = makeErrorTypeGuard(IssuerResponseError);
 export const isWalletProviderResponseError = makeErrorTypeGuard(
-  WalletProviderResponseError
+  WalletProviderResponseError,
 );
 export const isRelyingPartyResponseError = makeErrorTypeGuard(
-  RelyingPartyResponseError
+  RelyingPartyResponseError,
 );
 
+interface ErrorCase<T> {
+  code: ExtractErrorCode<T>;
+  message: string;
+  reason?: GenericErrorReason;
+}
+
 // Mapping type between error classes and their allowed codes
 type ErrorCodeMap =
   | {
-      type: typeof IssuerResponseError;
       code: IssuerResponseErrorCode;
+      type: typeof IssuerResponseError;
     }
   | {
-      type: typeof WalletProviderResponseError;
-      code: WalletProviderResponseErrorCode;
+      code: RelyingPartyResponseErrorCode;
+      type: typeof RelyingPartyResponseError;
     }
   | {
-      type: typeof RelyingPartyResponseError;
-      code: RelyingPartyResponseErrorCode;
+      code: WalletProviderResponseErrorCode;
+      type: typeof WalletProviderResponseError;
     };
 
 type ExtractErrorCode<T> = Extract<ErrorCodeMap, { type: T }>["code"];
 
-type ErrorCase<T> = {
-  code: ExtractErrorCode<T>;
-  message: string;
-  reason?: GenericErrorReason;
-};
-
 /**
  * Builder class used to create specialized errors from type {@link UnexpectedStatusCodeError} that handles multiple status codes.
  *
@@ -309,17 +313,10 @@ type ErrorCase<T> = {
  * ```
  */
 export class ResponseErrorBuilder<T extends typeof UnexpectedStatusCodeError> {
-  private errorCases: {
-    [K in number | "*"]?: ErrorCase<T>;
-  } = {};
+  private errorCases: Partial<Record<"*" | number, ErrorCase<T>>> = {};
 
   constructor(private ErrorClass: T) {}
 
-  handle(status: number | "*", params: ErrorCase<T>) {
-    this.errorCases[status] = params;
-    return this;
-  }
-
   buildFrom(originalError: UnexpectedStatusCodeError) {
     const params =
       this.errorCases[originalError.statusCode] ?? this.errorCases["*"];
@@ -330,6 +327,11 @@ export class ResponseErrorBuilder<T extends typeof UnexpectedStatusCodeError> {
 
     return originalError;
   }
+
+  handle(status: "*" | number, params: ErrorCase<T>) {
+    this.errorCases[status] = params;
+    return this;
+  }
 }
 
 /**

package/src/utils/integrity.ts

@@ -1,3 +1,12 @@
+/**
+ * Type returned by the getHardwareSignatureWithAuthData function of {@link IntegrityContext}.
+ * It contains the signature and the authenticator data.
+ */
+export interface HardwareSignatureWithAuthData {
+  authenticatorData: string;
+  signature: string;
+}
+
 /**
  * Interface for the integrity context which provides the necessary functions to interact with the integrity service.
  * The functions are platform specific and must be implemented in the platform specific code.
@@ -6,18 +15,9 @@
  * getHardwareSignatureWithAuthData: signs the clientData and returns the signature with the authenticator data.
  */
 export interface IntegrityContext {
-  getHardwareKeyTag: () => string;
   getAttestation: (nonce: string) => Promise<string>;
+  getHardwareKeyTag: () => string;
   getHardwareSignatureWithAuthData: (
-    clientData: string
+    clientData: string,
   ) => Promise<HardwareSignatureWithAuthData>;
 }
-
-/**
- * Type returned by the getHardwareSignatureWithAuthData function of {@link IntegrityContext}.
- * It contains the signature and the authenticator data.
- */
-export type HardwareSignatureWithAuthData = {
-  signature: string;
-  authenticatorData: string;
-};

package/src/utils/jwk.ts

@@ -28,7 +28,6 @@ export const JWK = z.object({
   /** JWK "use" (Public Key Use) Parameter. */
   use: z.string().optional(),
   x: z.string().optional(),
-  y: z.string().optional(),
   /** JWK "x5c" (X.509 Certificate Chain) Parameter. */
   x5c: z.array(z.string()).optional(),
   /** JWK "x5t" (X.509 Certificate SHA-1 Thumbprint) Parameter. */
@@ -37,8 +36,11 @@ export const JWK = z.object({
   "x5t#S256": z.string().optional(),
   /** JWK "x5u" (X.509 URL) Parameter. */
   x5u: z.string().optional(),
+  y: z.string().optional(),
 });
 
+export type JWKS = z.infer<typeof JWKS>;
+
 /**
  * Ensure key values are encoded using base64url and not just base64, as defined in https://datatracker.ietf.org/doc/html/rfc7517
  *
@@ -48,7 +50,7 @@ export const JWK = z.object({
  * @returns THe same input key with fixed values
  */
 export function fixBase64EncodingOnKey(key: JWK): JWK {
-  const { x, y, e, n, ...pk } = key;
+  const { e, n, x, y, ...pk } = key;
 
   return {
     ...pk,
@@ -58,8 +60,6 @@ export function fixBase64EncodingOnKey(key: JWK): JWK {
     ...(n ? { n: removePadding(n) } : {}),
   };
 }
-
-export type JWKS = z.infer<typeof JWKS>;
 export const JWKS = z.object({
   keys: z.array(JWK),
 });

package/src/utils/logging.ts

@@ -1,13 +1,3 @@
-/**
- * Logger interface which can be provided to the Logger class as a custom implementation.
- */
-export interface LoggingContext {
-  logDebug: (msg: string) => void;
-  logInfo: (msg: string) => void;
-  logWarn: (msg: string) => void;
-  logError: (msg: string) => void;
-}
-
 /**
  * Supported debug levels.
  */
@@ -18,6 +8,16 @@ export enum LogLevel {
   ERROR,
 }
 
+/**
+ * Logger interface which can be provided to the Logger class as a custom implementation.
+ */
+export interface LoggingContext {
+  logDebug: (msg: string) => void;
+  logError: (msg: string) => void;
+  logInfo: (msg: string) => void;
+  logWarn: (msg: string) => void;
+}
+
 /**
  * Logger singleton class which provides a simple logging interface with an init function to set the logging context and
  * a static log function to log messages based on the debug level.
@@ -30,8 +30,9 @@ export class Logger {
   private static instance: Logger | null = null;
   private static loggingContext?: LoggingContext;
 
-  // Private constructor to prevent direct instantiation
-  private constructor() {}
+  private constructor() {
+    /* Private constructor to prevent direct instantiation */
+  }
 
   // Public static method to get the Logger instance
   public static getInstance(): Logger {
@@ -41,11 +42,6 @@ export class Logger {
     return Logger.instance;
   }
 
-  // Method to initialize the logging context
-  public initLogging(loggingCtx: LoggingContext): void {
-    Logger.loggingContext = loggingCtx;
-  }
-
   // Method to log based on the level which wraps the null check for the logging context
   public static log(level: LogLevel, msg: string): void {
     if (Logger.loggingContext) {
@@ -53,16 +49,21 @@ export class Logger {
         case LogLevel.DEBUG:
           Logger.loggingContext.logDebug(msg);
           break;
+        case LogLevel.ERROR:
+          Logger.loggingContext.logError(msg);
+          break;
         case LogLevel.INFO:
           Logger.loggingContext.logInfo(msg);
           break;
         case LogLevel.WARN:
           Logger.loggingContext.logWarn(msg);
           break;
-        case LogLevel.ERROR:
-          Logger.loggingContext.logError(msg);
-          break;
       }
     }
   }
+
+  // Method to initialize the logging context
+  public initLogging(loggingCtx: LoggingContext): void {
+    Logger.loggingContext = loggingCtx;
+  }
 }

package/src/utils/mappers.ts

@@ -24,18 +24,21 @@ import * as z from "zod";
 export function createMapper<I, O>(mapper: (input: I) => O): (input: I) => O;
 export function createMapper<I, O>(
   mapper: (input: I) => O,
-  config: { inputSchema: z.ZodType<I>; outputSchema: z.ZodType<O> }
+  config: { inputSchema: z.ZodType<I>; outputSchema: z.ZodType<O> },
 ): (input: unknown) => O;
 export function createMapper<I, O>(
   mapper: (input: I) => O,
-  config: { outputSchema: z.ZodType<O> }
+  // eslint-disable-next-line @typescript-eslint/unified-signatures
+  config: { outputSchema: z.ZodType<O> },
 ): (input: I) => O;
 export function createMapper<I, O>(
   mapper: (input: I) => O,
   config?: {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     inputSchema?: z.ZodType<I, any>;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     outputSchema: z.ZodType<O, any>;
-  }
+  },
 ) {
   if (!config) {
     return mapper;
@@ -58,14 +61,14 @@ export function createMapper<I, O>(
  * @fn The function to wrap
  * @return The original function with the mapper applied to its return value
  */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const withMapper = <A extends any[], I, O>(
   mapper: (input: I) => O,
-  fn: (...args: A) => I
-) => {
-  return function wrappedFunction(...args: A) {
+  fn: (...args: A) => I,
+) =>
+  function wrappedFunction(...args: A) {
     return mapper(fn(...args));
   };
-};
 
 /**
  * Higher order function to pipe an async function return value to the provided mapper.
@@ -74,11 +77,11 @@ export const withMapper = <A extends any[], I, O>(
  * @fn The function to wrap
  * @return The original function with the mapper applied to its return value
  */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const withMapperAsync = <A extends any[], I, O>(
   mapper: (input: I) => O,
-  fn: (...args: A) => Promise<I>
-) => {
-  return async function wrappedAsyncFunction(...args: A) {
+  fn: (...args: A) => Promise<I>,
+) =>
+  async function wrappedAsyncFunction(...args: A) {
     return mapper(await fn(...args));
   };
-};