@pagopa/io-react-native-wallet 3.7.4 → 3.8.2

package/lib/typescript/module/trust/v1.4.6/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/trust/v1.4.6/types.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAMzB,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,mCAAmC,CAC3C,CAAC;AACF,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAY/C,CAAC;AAGF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CACnD,OAAO,+BAA+B,CACvC,CAAC;AACF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAQ3C,CAAC;AAGF,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,iCAAiC,CACzC,CAAC;AACF,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAQ7C,CAAC;AAGF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACtE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAMwC,CAAC"}

package/lib/typescript/module/utils/auth.d.ts

@@ -0,0 +1,41 @@
+import * as z from "zod";
+/**
+ * Context for authorization during the {@link 03-start-user-authorization.ts} phase.
+ * It consists of a single method to identify the user which takes a URL and a redirect schema as input.
+ * Once the authorization is completed and the URL calls the redirect schema, the method should return the redirect URL.
+ */
+export interface AuthorizationContext {
+    authorize: (url: string, redirectSchema: string) => Promise<string>;
+}
+/**
+ * The result of the identification process.
+ */
+export declare const AuthorizationResultShape: z.ZodObject<{
+    code: z.ZodString;
+    iss: z.ZodOptional<z.ZodString>;
+    state: z.ZodString;
+}, z.core.$strip>;
+/**
+ * The error of the identification process.
+ * It follows the OAuth/OIDC error response format.
+ * @see https://openid.net/specs/openid-connect-core-1_0.html#AuthError
+ * @see https://datatracker.ietf.org/doc/html/rfc6749#section-4.1.2.1
+ */
+export declare const AuthorizationErrorShape: z.ZodObject<{
+    error: z.ZodString;
+    error_description: z.ZodOptional<z.ZodString>;
+    error_uri: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Type of the identification result.
+ */
+export type AuthorizationResult = z.infer<typeof AuthorizationResultShape>;
+/**
+ * MRTD PoP Challenge Info response structure
+ */
+export declare const AuthorizationChallengeResultShape: z.ZodObject<{
+    challenge_info: z.ZodString;
+}, z.core.$strip>;
+export type AuthorizationChallengeResult = z.infer<typeof AuthorizationChallengeResultShape>;
+//# sourceMappingURL=auth.d.ts.map

package/lib/typescript/module/utils/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../../../src/utils/auth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CACrE;AAED;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;iBAInC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;;;;;iBAKlC,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE3E;;GAEG;AAEH,eAAO,MAAM,iCAAiC;;iBAE5C,CAAC;AAEH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAChD,OAAO,iCAAiC,CACzC,CAAC"}

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

@@ -0,0 +1,28 @@
+import { type CryptoContext } from "@pagopa/io-react-native-jwt";
+import { type CallbackContext } from "@pagopa/io-wallet-oauth2";
+import type { JWK } from "./jwk.js";
+type PartialCallbackContext = Omit<CallbackContext, "clientAuthentication" | "signJwt">;
+/**
+ * Shared callbacks with React Native implementations for use
+ * in IO Wallet SDK. Callbacks not found here must be provided by the caller,
+ * as they require parameters that depends on the use case.
+ */
+export declare const partialCallbacks: PartialCallbackContext;
+/**
+ * Create a verifyJwt implementation that extracts the JWK for signature verification
+ * from a list of keys, matching the `kid` in the JWT header.
+ *
+ * This function does not support other `JwtSigner` methods.
+ *
+ * @param jwks The list of available keys
+ * @returns Function that implements `verifyJwt` callback
+ */
+export declare const createVerifyJwtFromJwks: (jwks: JWK[]) => CallbackContext["verifyJwt"];
+/**
+ * Create a signJwt implementation that signs a JWT using the provided CryptoContext.
+ * @param cryptoContext The CryptoContext to use for signing the JWT
+ * @returns Function that implements `signJwt` callback
+ */
+export declare const createSignJwtFromCryptoContext: (cryptoContext: CryptoContext) => CallbackContext["signJwt"];
+export {};
+//# sourceMappingURL=callbacks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"callbacks.d.ts","sourceRoot":"","sources":["../../../../src/utils/callbacks.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAInB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,KAAK,eAAe,EAAkB,MAAM,0BAA0B,CAAC;AAIhF,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAO,CAAC;AAYjC,KAAK,sBAAsB,GAAG,IAAI,CAChC,eAAe,EACf,sBAAsB,GAAG,SAAS,CACnC,CAAC;AAyBF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,EAAE,sBAoC9B,CAAC;AAIF;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,GAClC,MAAM,GAAG,EAAE,KACV,eAAe,CAAC,WAAW,CAS3B,CAAC;AAEJ;;;;GAIG;AACH,eAAO,MAAM,8BAA8B,GACzC,eAAe,aAAa,KAC3B,eAAe,CAAC,SAAS,CAYzB,CAAC"}

package/lib/typescript/module/utils/config.d.ts

@@ -0,0 +1,10 @@
+import { IoWalletSdkConfig, ItWalletSpecsVersion } from "@pagopa/io-wallet-utils";
+/**
+ * IO Wallet SDK configuration object for v1.0 specs.
+ */
+export declare const sdkConfigV1_0: IoWalletSdkConfig<ItWalletSpecsVersion.V1_0>;
+/**
+ * IO Wallet SDK configuration object for v1.4 specs.
+ */
+export declare const sdkConfigV1_4: IoWalletSdkConfig<ItWalletSpecsVersion.V1_4>;
+//# sourceMappingURL=config.d.ts.map

package/lib/typescript/module/utils/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../src/utils/config.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,oBAAoB,EACrB,MAAM,yBAAyB,CAAC;AAEjC;;GAEG;AACH,eAAO,MAAM,aAAa,8CAExB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa,8CAExB,CAAC"}

package/lib/typescript/module/utils/credentials.d.ts

@@ -0,0 +1,16 @@
+import type { CredentialFormat } from "../credential/issuance/index.js";
+import type { JWK } from "./jwk.js";
+import { type SupportedSdJwtLegacyFormat } from "../sd-jwt/types.js";
+/**
+ * Extracts a JWK from a credential.
+ * @param credential - The credential string, which can be in SD-JWT or CBOR format.
+ * @param format - The format of the credential
+ * @return A Promise that resolves to a JWK object if the credential is in SD-JWT format and contains a JWK, or undefined otherwise.
+ */
+export declare const extractJwkFromCredential: (credential: string, format: CredentialFormat | SupportedSdJwtLegacyFormat) => Promise<JWK>;
+/**
+ * Legacy credentials do not end with `~`. This function adds `~` when needed
+ * to avoid decoding errors in the @sd-jwt libraries.
+ */
+export declare const fixLegacyCredentialSdJwt: (token: string) => string;
+//# sourceMappingURL=credentials.d.ts.map

package/lib/typescript/module/utils/credentials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credentials.d.ts","sourceRoot":"","sources":["../../../../src/utils/credentials.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAO,CAAC;AAEjC,OAAO,EAGL,KAAK,0BAA0B,EAChC,MAAM,oBAAiB,CAAC;AAKzB;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,GACnC,YAAY,MAAM,EAClB,QAAQ,gBAAgB,GAAG,0BAA0B,KACpD,OAAO,CAAC,GAAG,CAab,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,wBAAwB,GAAI,OAAO,MAAM,WAOrD,CAAC"}

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

@@ -0,0 +1,70 @@
+import { type CryptoContext } from "@pagopa/io-react-native-jwt";
+import { JWK } from "./jwk.js";
+/**
+ * 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<{
+        attestation?: string;
+        success: boolean;
+    }>;
+};
+/**
+ * Create a CryptoContext bound to a key pair.
+ * Key pair is supposed to exist already in the device's keychain.
+ * It's identified by its unique keytag.
+ *
+ * @returns the crypto context
+ */
+export declare const createCryptoContextFor: (keytag: string) => CryptoContext;
+/**
+ * Executes the input function injecting an ephemeral crypto context.
+ * An ephemeral crypto context is a context which is bound to a key
+ * that is just created and is deleted after use.
+ *
+ * @param fn The procedure to be executed
+ * @returns The returned value of the input procedure.
+ */
+export declare const withEphemeralKey: <R>(fn: (ephemeralContext: CryptoContext) => Promise<R>) => Promise<R>;
+/**
+ * Converts a base64-encoded DER certificate to PEM format.
+ *
+ * @param certificate - The base64-encoded DER certificate.
+ * @returns The PEM-formatted certificate.
+ */
+export declare const convertBase64DerToPem: (certificate: string) => string;
+/**
+ * Retrieves the signing JWK from a PEM-formatted certificate.
+ *
+ * @param pemCert - The PEM-formatted certificate.
+ * @returns The signing JWK.
+ * @throws Will throw an error if the public key is unsupported.
+ */
+export declare const getSigninJwkFromCert: (pemCert: string) => JWK;
+/**
+ * Retrieves the signing JWK from a x509 certificate chain.
+ *
+ * @param certChain - The x509 certificate chain.
+ * @returns The signing JWK.
+ * @throws Will throw an error if no suitable keys are found.
+ */
+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/module/utils/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../../../src/utils/crypto.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,KAAK,aAAa,EAGnB,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAAE,GAAG,EAAQ,MAAM,UAAO,CAAC;AAElC;;;;;;GAMG;AACH,MAAM,MAAM,2BAA2B,GAAG,aAAa,GAAG;IACxD;;;;OAIG;IACH,0BAA0B,CACxB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CACxD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,GAAI,QAAQ,MAAM,KAAG,aAoBtD,CAAC;AAEH;;;;;;;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/lib/typescript/module/utils/decoder.d.ts

@@ -0,0 +1,6 @@
+import type { JWTDecodeResult } from "./jwk.js";
+export declare const getJwtFromFormPost: (formData: string) => Promise<{
+    decodedJwt: JWTDecodeResult;
+    jwt: string;
+}>;
+//# sourceMappingURL=decoder.d.ts.map

package/lib/typescript/module/utils/decoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decoder.d.ts","sourceRoot":"","sources":["../../../../src/utils/decoder.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAO,CAAC;AAiC7C,eAAO,MAAM,kBAAkB,GAC7B,UAAU,MAAM,KACf,OAAO,CAAC;IAAE,UAAU,EAAE,eAAe,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAsBtD,CAAC"}

package/lib/typescript/module/utils/dpop.d.ts

@@ -0,0 +1,22 @@
+import { type CryptoContext } from "@pagopa/io-react-native-jwt";
+import * as z from "zod";
+/**
+ * Create a signed DPoP token
+ *
+ * @param payload The payload to be included in the token.
+ * @param crypto The crypto context that handles the key bound to the DPoP.
+ *
+ * @returns The signed crypto token.
+ */
+export declare const createDPopToken: (payload: DPoPPayload, crypto: CryptoContext) => Promise<string>;
+export type DPoPPayload = z.infer<typeof DPoPPayload>;
+export declare const DPoPPayload: z.ZodObject<{
+    ath: z.ZodOptional<z.ZodString>;
+    htm: z.ZodEnum<{
+        GET: "GET";
+        POST: "POST";
+    }>;
+    htu: z.ZodString;
+    jti: z.ZodString;
+}, z.core.$strip>;
+//# sourceMappingURL=dpop.d.ts.map

package/lib/typescript/module/utils/dpop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dpop.d.ts","sourceRoot":"","sources":["../../../../src/utils/dpop.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAW,MAAM,6BAA6B,CAAC;AAC1E,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAC1B,SAAS,WAAW,EACpB,QAAQ,aAAa,KACpB,OAAO,CAAC,MAAM,CAWhB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AACtD,eAAO,MAAM,WAAW;;;;;;;;iBAKtB,CAAC"}

package/lib/typescript/module/utils/error-codes.d.ts

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

package/lib/typescript/module/utils/error-codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-codes.d.ts","sourceRoot":"","sources":["../../../../src/utils/error-codes.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,wBAAwB;IACnC;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;;IAGH;;OAEG;;IAEH;;OAEG;;CAEK,CAAC;AAEX,eAAO,MAAM,gCAAgC;IAC3C;;OAEG;;IAGH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;;CAGK,CAAC;AAEX,eAAO,MAAM,8BAA8B;IACzC;;OAEG;;;CAGK,CAAC;AAEX,MAAM,MAAM,uBAAuB,GACjC,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,OAAO,wBAAwB,CAAC,CAAC;AAE3E,MAAM,MAAM,6BAA6B,GACvC,CAAC,OAAO,8BAA8B,CAAC,CAAC,MAAM,OAAO,8BAA8B,CAAC,CAAC;AAEvF,MAAM,MAAM,+BAA+B,GACzC,CAAC,OAAO,gCAAgC,CAAC,CAAC,MAAM,OAAO,gCAAgC,CAAC,CAAC"}

package/lib/typescript/module/utils/errors.d.ts

@@ -0,0 +1,196 @@
+import type { ProblemJson } from "../client/generated/wallet-provider.js";
+import type { IssuerConfig } from "../credential/issuance/api/index.js";
+import { type IssuerResponseErrorCode, IssuerResponseErrorCodes, type RelyingPartyResponseErrorCode, RelyingPartyResponseErrorCodes, type WalletProviderResponseErrorCode, WalletProviderResponseErrorCodes } from "./error-codes.js";
+export { IssuerResponseErrorCodes, RelyingPartyResponseErrorCodes, WalletProviderResponseErrorCodes, };
+type GenericErrorReason = Record<string, unknown> | string;
+/**
+ * utility to format a set of attributes into an error message string
+ *
+ * @example
+ * // returns "foo=value bar=(list, item)"
+ * serializeAttrs({ foo: "value", bar: ["list", "item"] })
+ *
+ * @param attrs A key value record set
+ * @returns a human-readable serialization of the set
+ */
+export declare const serializeAttrs: (attrs: Record<string, GenericErrorReason | number | string[] | undefined>) => string;
+/**
+ * Wraps a synchronous function and maps a specific error type to a library error.
+ *
+ * @param fn - The function to execute
+ * @param sourceError - The error class constructor to catch
+ * @param mapError - Function to map the caught error to a library error
+ * @returns The result of the function if it succeeds
+ * @throws The mapped error if sourceError is caught, or the original error otherwise
+ *
+ * @example
+ * const result = withMappedErrors(
+ *   () => sdkExtractGrantDetails(offer),
+ *   CredentialOfferError,
+ *   (e) => new InvalidCredentialOfferError(e.message)
+ * );
+ */
+export declare const withMappedErrors: <T, E extends Error, Args extends unknown[]>(fn: () => T, sourceError: new (...args: Args) => E, mapError: (error: E) => Error) => T;
+type LocalizedIssuanceError = Record<string, {
+    description: string;
+    title: string;
+}>;
+/**
+ * A generic Error that all other io-wallet specific Error subclasses extend.
+ *
+ * @example Checking thrown error is a io-wallet one
+ *
+ * ```js
+ * if (err instanceof errors.IoWalletError) {
+ *   // ...
+ * }
+ * ```
+ */
+export declare class IoWalletError extends Error {
+    /** A unique error code for the particular error subclass. */
+    code: string;
+    constructor(message?: string);
+}
+/**
+ * An error subclass thrown when an HTTP request has a status code different from the one expected.
+ */
+export declare class UnexpectedStatusCodeError extends IoWalletError {
+    code: string;
+    reason: GenericErrorReason;
+    statusCode: number;
+    constructor({ message, reason, statusCode, }: {
+        message: string;
+        reason: GenericErrorReason;
+        statusCode: number;
+    });
+}
+/**
+ * An error subclass thrown when an Issuer HTTP request fails.
+ * The specific error can be found in the `code` property.
+ * `reason` values are returned with Italian fiscal codes anonymized.
+ */
+export declare class IssuerResponseError extends UnexpectedStatusCodeError {
+    code: IssuerResponseErrorCode;
+    constructor(params: {
+        code?: IssuerResponseErrorCode;
+        message: string;
+        reason: GenericErrorReason;
+        statusCode: number;
+    });
+}
+/**
+ * An error subclass thrown when a Relying Party HTTP request fails.
+ * The specific error can be found in the `code` property.
+ */
+export declare class RelyingPartyResponseError extends UnexpectedStatusCodeError {
+    code: RelyingPartyResponseErrorCode;
+    constructor(params: {
+        code?: RelyingPartyResponseErrorCode;
+        message: string;
+        reason: GenericErrorReason;
+        statusCode: number;
+    });
+}
+/**
+ * An error subclass thrown when validation fail
+ *
+ */
+export declare class ValidationFailed extends IoWalletError {
+    /** The Claim for which the validation failed. */
+    claim: string;
+    code: string;
+    /** Reason code for the validation failure. */
+    reason: string;
+    constructor({ claim, message, reason, }: {
+        claim?: string;
+        message: string;
+        reason?: string;
+    });
+}
+/**
+ * An error subclass thrown when a Wallet Provider HTTP request fails.
+ * The specific error can be found in the `code` property.
+ */
+export declare class WalletProviderResponseError extends UnexpectedStatusCodeError {
+    code: WalletProviderResponseErrorCode;
+    reason: ProblemJson;
+    constructor(params: {
+        code?: WalletProviderResponseErrorCode;
+        message: string;
+        reason: ProblemJson;
+        statusCode: number;
+    });
+}
+/**
+ * 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
+ * @param issuerConf The entity configuration for credentials
+ * @param credentialType The type of credential the error belongs to
+ * @returns A localized error {@link LocalizedIssuanceError} or undefined
+ * @throws {IoWalletError} When no credential config is found
+ */
+export declare function extractErrorMessageFromIssuerConf(errorCode: string, { credentialType, issuerConf, }: {
+    credentialType: string;
+    issuerConf: IssuerConfig;
+}): LocalizedIssuanceError | undefined;
+export declare const isIssuerResponseError: (error: unknown, code?: IssuerResponseErrorCode | undefined) => error is IssuerResponseError;
+export declare const isWalletProviderResponseError: (error: unknown, code?: WalletProviderResponseErrorCode | undefined) => error is WalletProviderResponseError;
+export declare const isRelyingPartyResponseError: (error: unknown, code?: RelyingPartyResponseErrorCode | undefined) => error is RelyingPartyResponseError;
+interface ErrorCase<T> {
+    code: ExtractErrorCode<T>;
+    message: string;
+    reason?: GenericErrorReason;
+}
+type ErrorCodeMap = {
+    code: IssuerResponseErrorCode;
+    type: typeof IssuerResponseError;
+} | {
+    code: RelyingPartyResponseErrorCode;
+    type: typeof RelyingPartyResponseError;
+} | {
+    code: WalletProviderResponseErrorCode;
+    type: typeof WalletProviderResponseError;
+};
+type ExtractErrorCode<T> = Extract<ErrorCodeMap, {
+    type: T;
+}>["code"];
+/**
+ * Builder class used to create specialized errors from type {@link UnexpectedStatusCodeError} that handles multiple status codes.
+ *
+ * Chain multiple `handle` to add cases that depend on the status code, then call `buildFrom` when done.
+ *
+ * @example
+ * ```
+ * new ResponseErrorBuilder(IssuerResponseError)
+ *   .handle(403, { code: "ERROR_CODE_1", message: "Forbidden" })
+ *   .handle(500, { code: "ERROR_CODE_2", message: "Unexpected error" })
+ *   .handle("*", { code: "ERROR_CODE_3", message: "Fallback" })
+ *   .buildFrom(baseError)
+ * ```
+ */
+export declare class ResponseErrorBuilder<T extends typeof UnexpectedStatusCodeError> {
+    private ErrorClass;
+    private errorCases;
+    constructor(ErrorClass: T);
+    buildFrom(originalError: UnexpectedStatusCodeError): UnexpectedStatusCodeError;
+    handle(status: "*" | number, params: ErrorCase<T>): this;
+}
+/**
+ * Error thrown when the library does not implement
+ * a feature aligned with the specified version.
+ */
+export declare class UnimplementedFeatureError extends IoWalletError {
+    code: string;
+    constructor(feature: string, version: string);
+}
+/**
+ * Map `UnexpectedStatusCodeError` thrown from IO Wallet SDK to `IssuerResponseError`.
+ * Use this function in catch blocks.
+ * @param err The original error
+ * @throws Generic {@link IssuerResponseError}
+ * @throws The original error if it doesn't match
+ * @example
+ * await fetchAuthorizationRequest().catch(sdkUnexpectedStatusCodeToIssuerError)
+ */
+export declare const sdkUnexpectedStatusCodeToIssuerError: (err: unknown) => never;
+//# sourceMappingURL=errors.d.ts.map

package/lib/typescript/module/utils/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../src/utils/errors.ts"],"names":[],"mappings":"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"}

package/lib/typescript/module/utils/integrity.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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.
+ * getHardwareKeyTag: returns the hardware key tag in a url safe format (e.g. base64url).
+ * getAttestation: requests the attestation from the integrity service.
+ * getHardwareSignatureWithAuthData: signs the clientData and returns the signature with the authenticator data.
+ */
+export interface IntegrityContext {
+    getAttestation: (nonce: string) => Promise<string>;
+    getHardwareKeyTag: () => string;
+    getHardwareSignatureWithAuthData: (clientData: string) => Promise<HardwareSignatureWithAuthData>;
+}
+//# sourceMappingURL=integrity.d.ts.map

package/lib/typescript/module/utils/integrity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integrity.d.ts","sourceRoot":"","sources":["../../../../src/utils/integrity.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,6BAA6B;IAC5C,iBAAiB,EAAE,MAAM,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,cAAc,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACnD,iBAAiB,EAAE,MAAM,MAAM,CAAC;IAChC,gCAAgC,EAAE,CAChC,UAAU,EAAE,MAAM,KACf,OAAO,CAAC,6BAA6B,CAAC,CAAC;CAC7C"}

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

@@ -0,0 +1,78 @@
+import { decode } from "@pagopa/io-react-native-jwt";
+import { z } from "zod";
+export type JWK = z.infer<typeof JWK>;
+export declare const JWK: z.ZodObject<{
+    alg: z.ZodOptional<z.ZodString>;
+    crv: z.ZodOptional<z.ZodString>;
+    d: z.ZodOptional<z.ZodString>;
+    dp: z.ZodOptional<z.ZodString>;
+    dq: z.ZodOptional<z.ZodString>;
+    e: z.ZodOptional<z.ZodString>;
+    ext: z.ZodOptional<z.ZodBoolean>;
+    k: z.ZodOptional<z.ZodString>;
+    key_ops: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    kid: z.ZodOptional<z.ZodString>;
+    kty: z.ZodEnum<{
+        RSA: "RSA";
+        EC: "EC";
+    }>;
+    n: z.ZodOptional<z.ZodString>;
+    p: z.ZodOptional<z.ZodString>;
+    q: z.ZodOptional<z.ZodString>;
+    qi: z.ZodOptional<z.ZodString>;
+    use: z.ZodOptional<z.ZodString>;
+    x: z.ZodOptional<z.ZodString>;
+    x5c: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    x5t: z.ZodOptional<z.ZodString>;
+    "x5t#S256": z.ZodOptional<z.ZodString>;
+    x5u: z.ZodOptional<z.ZodString>;
+    y: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+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
+ *
+ * @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;
+export declare const JWKS: z.ZodObject<{
+    keys: z.ZodArray<z.ZodObject<{
+        alg: z.ZodOptional<z.ZodString>;
+        crv: z.ZodOptional<z.ZodString>;
+        d: z.ZodOptional<z.ZodString>;
+        dp: z.ZodOptional<z.ZodString>;
+        dq: z.ZodOptional<z.ZodString>;
+        e: z.ZodOptional<z.ZodString>;
+        ext: z.ZodOptional<z.ZodBoolean>;
+        k: z.ZodOptional<z.ZodString>;
+        key_ops: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        kid: z.ZodOptional<z.ZodString>;
+        kty: z.ZodEnum<{
+            RSA: "RSA";
+            EC: "EC";
+        }>;
+        n: z.ZodOptional<z.ZodString>;
+        p: z.ZodOptional<z.ZodString>;
+        q: z.ZodOptional<z.ZodString>;
+        qi: z.ZodOptional<z.ZodString>;
+        use: z.ZodOptional<z.ZodString>;
+        x: z.ZodOptional<z.ZodString>;
+        x5c: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        x5t: z.ZodOptional<z.ZodString>;
+        "x5t#S256": z.ZodOptional<z.ZodString>;
+        x5u: z.ZodOptional<z.ZodString>;
+        y: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type JWTDecodeResult = ReturnType<typeof decode>;
+/**
+ * Utility function that checks if two JWKs have the same thumbprint.
+ * @param jwkA The first JWK
+ * @param jwkB The second JWK
+ * @returns Whether the thumbprints match
+ */
+export declare const isSameThumbprint: (jwkA: JWK, jwkB: JWK) => Promise<boolean>;
+//# sourceMappingURL=jwk.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"jwk.d.ts","sourceRoot":"","sources":["../../../../src/utils/jwk.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAA6B,MAAM,6BAA6B,CAAC;AAChF,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,GAAG,CAAC,CAAC;AACtC,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmCd,CAAC;AAEH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,CAUpD;AACD,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAEf,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,MAAM,CAAC,CAAC;AAExD;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAU,MAAM,GAAG,EAAE,MAAM,GAAG,qBAM1D,CAAC"}

package/lib/typescript/module/utils/logging.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Supported debug levels.
+ */
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3
+}
+/**
+ * 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.
+ * This can be used as follows:
+ * const logger = Logger.getInstance();
+ * logger.initLogging(yourLoggingContext);
+ * logger.log(LogLevel.DEBUG, "Debug message");
+ */
+export declare class Logger {
+    private static instance;
+    private static loggingContext?;
+    private constructor();
+    static getInstance(): Logger;
+    static log(level: LogLevel, msg: string): void;
+    initLogging(loggingCtx: LoggingContext): void;
+}
+//# sourceMappingURL=logging.d.ts.map

package/lib/typescript/module/utils/logging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../../../../src/utils/logging.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,QAAQ;IAClB,KAAK,IAAA;IACL,IAAI,IAAA;IACJ,IAAI,IAAA;IACJ,KAAK,IAAA;CACN;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CAChC;AAED;;;;;;;GAOG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAuB;IAC9C,OAAO,CAAC,MAAM,CAAC,cAAc,CAAC,CAAiB;IAE/C,OAAO;WAKO,WAAW,IAAI,MAAM;WAQrB,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IAoB9C,WAAW,CAAC,UAAU,EAAE,cAAc,GAAG,IAAI;CAGrD"}