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

package/src/credential/presentation/v1.3.3/05-verify-request-object.ts

@@ -1,10 +1,17 @@
-import type { RemotePresentationApi } from "../api";
-import { parseAuthorizeRequest as sdkParseAuthorizeRequest } from "@pagopa/io-wallet-oid4vp";
+import type { RelyingPartyConfig, RemotePresentationApi } from "../api";
+import {
+  parseAuthorizeRequest as sdkParseAuthorizeRequest,
+  ClientIdPrefix,
+  extractClientIdPrefix,
+} from "@pagopa/io-wallet-oid4vp";
+import QuickCrypto from "react-native-quick-crypto";
 import { partialCallbacks } from "../../../utils/callbacks";
 import { sdkConfigV1_3 } from "../../../utils/config";
+import { IoWalletError } from "../../../utils/errors";
 import { InvalidRequestObjectError } from "../common/errors";
 import { mapSdkRequestObjectError } from "./sdkErrorMapper";
 import { mapToRequestObject } from "./mappers";
+import type { RawRequestObject } from "./types";
 
 export const verifyRequestObject: RemotePresentationApi["verifyRequestObject"] =
   async (requestObjectEncodedJwt, { clientId, rpConf }) => {
@@ -16,18 +23,64 @@ export const verifyRequestObject: RemotePresentationApi["verifyRequestObject"] =
       },
     }).catch(mapSdkRequestObjectError);
 
-    const payload = parsedRequestObject.payload;
+    const rawRequestObject = parsedRequestObject as RawRequestObject;
 
-    const isClientIdMatch =
-      clientId === payload.client_id && clientId === rpConf.subject;
+    const clientIdPrefix = extractClientIdPrefix(clientId);
 
-    if (!isClientIdMatch) {
-      throw new InvalidRequestObjectError(
-        "Client ID does not match Request Object or Entity Configuration"
-      );
+    if (clientIdPrefix === ClientIdPrefix.X509_HASH) {
+      validateX509HashClient(rawRequestObject.header.x5c, clientId);
+    }
+
+    if (
+      clientIdPrefix === ClientIdPrefix.OPENID_FEDERATION ||
+      clientIdPrefix === ClientIdPrefix.NONE
+    ) {
+      validateOpenIDFederationClient(rawRequestObject, clientId, rpConf);
     }
 
     return {
-      requestObject: mapToRequestObject(payload),
+      requestObject: mapToRequestObject(rawRequestObject),
     };
   };
+
+const validateOpenIDFederationClient = (
+  requestObject: RawRequestObject,
+  clientId: string,
+  rpConf: RelyingPartyConfig | undefined
+) => {
+  if (!rpConf) {
+    throw new IoWalletError(
+      "Relying Party Configuration is required for OpenID Federation clients"
+    );
+  }
+
+  const isClientIdMatch =
+    clientId === requestObject.payload.client_id &&
+    stripOpenIdFederationPrefix(clientId) === rpConf.subject;
+
+  if (!isClientIdMatch) {
+    throw new InvalidRequestObjectError(
+      "Client ID does not match Request Object or Entity Configuration"
+    );
+  }
+};
+
+const validateX509HashClient = (
+  certificateChain: string[],
+  clientId: string
+) => {
+  const [, x509Hash] = clientId.split(":");
+
+  const calculatedHash = QuickCrypto.createHash("sha-256")
+    .update(certificateChain[0]!, "base64")
+    .digest("base64url");
+
+  if (x509Hash !== calculatedHash) {
+    throw new InvalidRequestObjectError(
+      "x509_hash does not match the hash of the x5c leaf certificate"
+    );
+  }
+};
+
+const stripOpenIdFederationPrefix = (clientId: string) =>
+  clientId.replace("openid_federation:", "");

package/src/credential/presentation/v1.3.3/07-send-authorization-response.ts

@@ -101,14 +101,23 @@ export const sendAuthorizationResponse: RemotePresentationApi["sendAuthorization
     { appFetch = fetch } = {}
   ) => {
     try {
-      const { presentations } = remotePresentation;
+      if (!rpConf && !requestObject.client_metadata) {
+        throw new IoWalletError(
+          "At least one of rpConf or requestObject.client_metadata must be provided to send the authorization response"
+        );
+      }
+
+      // When the RP is not an OpenID Federation client, rpConf will be undefined
+      // so the keys are taken from the Request Object's client_metadata.
       const rpJwks = {
-        jwks: rpConf.jwks,
+        jwks: rpConf?.jwks ?? requestObject.client_metadata!.jwks,
         encrypted_response_enc_values_supported:
-          rpConf.encrypted_response_enc_values_supported,
+          rpConf?.encrypted_response_enc_values_supported ??
+          requestObject.client_metadata!
+            .encrypted_response_enc_values_supported,
       };
 
-      const vp_token = presentations.reduce(
+      const vp_token = remotePresentation.presentations.reduce(
         (acc, p) => {
           (acc[p.credentialId] ??= []).push(p.vpToken);
           return acc;

package/src/credential/presentation/v1.3.3/mappers.ts

@@ -2,16 +2,16 @@ import { RelyingPartyEntityConfiguration } from "../../../trust/v1.3.3/types";
 import { createMapper } from "../../../utils/mappers";
 import type { RelyingPartyConfig } from "../api/RelyingPartyConfig";
 import type { RequestObject } from "../api/types";
-import { RequestObjectPayload } from "./types";
+import { RawRequestObject } from "./types";
 
 export const mapToRelyingPartyConfig = createMapper<
   RelyingPartyEntityConfiguration,
   RelyingPartyConfig
->((x) => {
-  const { federation_entity, openid_credential_verifier } = x.payload.metadata;
+>(({ payload }) => {
+  const { federation_entity, openid_credential_verifier } = payload.metadata;
 
   return {
-    subject: x.payload.sub,
+    subject: payload.sub,
     jwks: openid_credential_verifier.jwks,
     federation_entity,
     encrypted_response_enc_values_supported:
@@ -19,16 +19,18 @@ export const mapToRelyingPartyConfig = createMapper<
   };
 });
 
-export const mapToRequestObject = createMapper<
-  RequestObjectPayload,
-  RequestObject
->((x) => ({
-  iss: x.iss,
-  client_id: x.client_id,
-  dcql_query: x.dcql_query,
-  nonce: x.nonce,
-  response_uri: x.response_uri,
-  state: x.state,
-  response_mode: x.response_mode,
-  response_type: x.response_type,
-}));
+export const mapToRequestObject = createMapper<RawRequestObject, RequestObject>(
+  ({ payload, header }) => ({
+    iss: payload.iss,
+    client_id: payload.client_id,
+    dcql_query: payload.dcql_query,
+    nonce: payload.nonce,
+    response_uri: payload.response_uri,
+    state: payload.state,
+    response_mode: payload.response_mode,
+    response_type: payload.response_type,
+    client_metadata: payload.client_metadata,
+    x5c: header.x5c,
+    trust_chain: header.trust_chain,
+  })
+);

package/src/credential/presentation/v1.3.3/types.ts

@@ -1,8 +1,14 @@
 import * as z from "zod";
-import { zOpenid4vpAuthorizationRequestPayload as sdkRequestObjectPayload } from "@pagopa/io-wallet-oid4vp";
+import {
+  zOpenid4vpAuthorizationRequestHeaderV1_3,
+  zOpenid4vpAuthorizationRequestPayload,
+} from "@pagopa/io-wallet-oid4vp";
 
-export type RequestObjectPayload = z.infer<typeof sdkRequestObjectPayload>;
-export const RequestObjectPayload = sdkRequestObjectPayload;
+export type RawRequestObject = z.infer<typeof RawRequestObject>;
+export const RawRequestObject = z.object({
+  header: zOpenid4vpAuthorizationRequestHeaderV1_3,
+  payload: zOpenid4vpAuthorizationRequestPayload,
+});
 
 export type AuthorizationResponse = z.infer<typeof AuthorizationResponse>;
 export const AuthorizationResponse = z.object({

package/src/credentials-catalogue/api/DigitalCredentialsCatalogue.ts

@@ -117,8 +117,40 @@ export const DigitalCredential = z.object({
   // claims: z.array(Claim), // TODO: [SIW-3978] Should we keep claims?
 });
 
+const TaxonomyPurpose = z.object({
+  id: z.string(),
+  name_l10n_id: z.string(),
+});
+export type TaxonomyPurpose = z.infer<typeof TaxonomyPurpose>;
+
+const TaxonomyClass = z.object({
+  id: z.string(),
+  name_l10n_id: z.string(),
+  supported_purposes: z.array(z.string()),
+});
+export type TaxonomyClass = z.infer<typeof TaxonomyClass>;
+
+const TaxonomyDomain = z.object({
+  id: z.string(),
+  name_l10n_id: z.string(),
+  description_l10n_id: z.string(),
+  classes: z.array(TaxonomyClass),
+});
+export type TaxonomyDomain = z.infer<typeof TaxonomyDomain>;
+
+export const Taxonomy = z.object({
+  id: z.string(),
+  name_l10n_id: z.string(),
+  description_l10n_id: z.string(),
+  domains: z.array(TaxonomyDomain),
+  purposes: z.array(TaxonomyPurpose),
+  localization: LocalizationInfo.optional(),
+});
+export type Taxonomy = z.infer<typeof Taxonomy>;
+
 export const DigitalCredentialsCatalogue = z.object({
   taxonomy_uri: z.string().url(),
+  taxonomy: Taxonomy.optional(),
   credentials: z.array(DigitalCredential),
   iat: UnixTime,
   exp: UnixTime,

package/src/credentials-catalogue/api/index.ts

@@ -2,6 +2,7 @@ import {
   type CatalogueTranslations,
   type DigitalCredentialsCatalogue,
   type LocalizationInfo,
+  type Taxonomy,
 } from "./DigitalCredentialsCatalogue";
 
 type FetchContext = { appFetch?: GlobalFetch["fetch"] };
@@ -9,6 +10,7 @@ type FetchContext = { appFetch?: GlobalFetch["fetch"] };
 type FetchTranslationsLocalizations = {
   catalogue?: LocalizationInfo;
   authenticSources?: LocalizationInfo;
+  taxonomy?: LocalizationInfo;
 };
 
 export interface CredentialsCatalogueApi {
@@ -27,11 +29,11 @@ export interface CredentialsCatalogueApi {
   ): Promise<DigitalCredentialsCatalogue>;
 
   /**
-   * Fetch locale bundle files for the credential catalogue and authentic sources.
-   * For each requested locale, fetches translations from both registries (if the locale
+   * Fetch locale bundle files for the credential catalogue, authentic sources, and taxonomy.
+   * For each requested locale, fetches translations from all registries (if the locale
    * is listed in their respective `available_locales`) and merges the keys.
    * Locales not present in a registry's `available_locales` are silently skipped for that source.
-   * On key conflicts, authentic-sources translations take precedence.
+   * On key conflicts, later sources (authenticSources, taxonomy) take precedence.
    *
    * Optional: not supported by all versions. Check for existence before calling.
    *
@@ -52,4 +54,5 @@ export {
   type CatalogueTranslations,
   type DigitalCredentialsCatalogue,
   type LocalizationInfo,
+  type Taxonomy,
 };

package/src/credentials-catalogue/v1.3.3/fetch-and-parse-catalogue.ts

@@ -5,6 +5,7 @@ import {
   DigitalCredentialsCatalogueJwt,
   RegistryDiscoveryJwt,
   SchemaRegistry,
+  TaxonomyRegistry,
 } from "./types";
 import { mapToCredentialsCatalogue } from "./mappers";
 import { fetchRegistry } from "./utils";
@@ -46,6 +47,11 @@ export const fetchAndParseCatalogue: Api["fetchAndParseCatalogue"] = async (
       asJson: true,
       appFetch,
     }),
+    fetchRegistry(endpoints.taxonomy, {
+      schema: TaxonomyRegistry,
+      asJson: true,
+      appFetch,
+    }),
   ]);
 
   return mapToCredentialsCatalogue([discovery, ...registries]);

package/src/credentials-catalogue/v1.3.3/fetch-translations.ts

@@ -2,7 +2,7 @@ import type { CredentialsCatalogueApi as Api } from "../api";
 import { fetchLocaleBundle } from "./utils";
 
 export const fetchTranslations: NonNullable<Api["fetchTranslations"]> = async (
-  { catalogue, authenticSources },
+  { catalogue, authenticSources, taxonomy },
   locales,
   { appFetch = fetch } = {}
 ) => {
@@ -10,16 +10,19 @@ export const fetchTranslations: NonNullable<Api["fetchTranslations"]> = async (
 
   await Promise.all(
     locales.map(async (locale) => {
-      const [catalogueBundle, asBundle] = await Promise.all([
+      const [catalogueBundle, asBundle, taxonomyBundle] = await Promise.all([
         catalogue?.available_locales.includes(locale)
           ? fetchLocaleBundle(catalogue.base_uri, locale, appFetch)
           : Promise.resolve({}),
         authenticSources?.available_locales.includes(locale)
           ? fetchLocaleBundle(authenticSources.base_uri, locale, appFetch)
           : Promise.resolve({}),
+        taxonomy?.available_locales.includes(locale)
+          ? fetchLocaleBundle(taxonomy.base_uri, locale, appFetch)
+          : Promise.resolve({}),
       ]);
 
-      const merged = { ...catalogueBundle, ...asBundle };
+      const merged = { ...catalogueBundle, ...asBundle, ...taxonomyBundle };
 
       // Only include the locale in the result if at least one source provided translations
       if (Object.keys(merged).length > 0) {

package/src/credentials-catalogue/v1.3.3/mappers.ts

@@ -11,6 +11,7 @@ import {
   DigitalCredentialsCatalogueJwt,
   RegistryDiscoveryJwt,
   SchemaRegistry,
+  TaxonomyRegistry,
 } from "./types";
 
 export const mapToCredentialsCatalogue = createMapper<
@@ -19,10 +20,17 @@ export const mapToCredentialsCatalogue = createMapper<
     DigitalCredentialsCatalogueJwt,
     AuthenticSourceRegistry,
     SchemaRegistry,
+    TaxonomyRegistry,
   ],
   DigitalCredentialsCatalogue
 >(
-  ([discoveryJwt, catalogueJwt, authSourceRegistry, schemaRegistry]) => {
+  ([
+    discoveryJwt,
+    catalogueJwt,
+    authSourceRegistry,
+    schemaRegistry,
+    taxonomyRegistry,
+  ]) => {
     const authSourcesById = keyBy(
       authSourceRegistry.authentic_sources,
       "entity_id"
@@ -65,6 +73,14 @@ export const mapToCredentialsCatalogue = createMapper<
     return {
       ...catalogueJwt.payload,
       taxonomy_uri: discoveryJwt.payload.endpoints.taxonomy,
+      taxonomy: {
+        id: taxonomyRegistry.id,
+        name_l10n_id: taxonomyRegistry.name_l10n_id,
+        description_l10n_id: taxonomyRegistry.description_l10n_id,
+        domains: taxonomyRegistry.domains,
+        purposes: taxonomyRegistry.purposes,
+        localization: taxonomyRegistry.localization,
+      },
       localization: catalogueJwt.payload.localization,
       as_localization: authSourceRegistry.localization,
       credentials: catalogueJwt.payload.credentials.map(

package/src/credentials-catalogue/v1.3.3/types.ts

@@ -233,3 +233,54 @@ export const RegistryDiscoveryJwt = z.object({
   }),
 });
 export type RegistryDiscoveryJwt = z.infer<typeof RegistryDiscoveryJwt>;
+
+/**
+ * Taxonomy purpose (top-level flat list).
+ */
+const TaxonomyPurpose = z.object({
+  id: z.string(),
+  name_l10n_id: z.string(),
+});
+
+/**
+ * Taxonomy class within a domain.
+ */
+const TaxonomyClass = z.object({
+  id: z.string(),
+  name_l10n_id: z.string(),
+  supported_purposes: z.array(z.string()),
+});
+
+/**
+ * Taxonomy domain containing classes.
+ */
+const TaxonomyDomain = z.object({
+  id: z.string(),
+  name_l10n_id: z.string(),
+  description_l10n_id: z.string(),
+  classes: z.array(TaxonomyClass),
+});
+
+/**
+ * Taxonomy registry, available at a dedicated endpoint.
+ * Provides a hierarchical classification of domains, classes, and purposes.
+ * @see https://italia.github.io/eid-wallet-it-docs/releases/1.3.3/en/registry.html#taxonomy
+ */
+export const TaxonomyRegistry = z.object({
+  version: z.string(),
+  last_modified: z.string(),
+  id: z.string(),
+  localization: z
+    .object({
+      available_locales: z.array(z.string()),
+      base_uri: z.string(),
+      default_locale: z.string(),
+      version: z.string(),
+    })
+    .optional(),
+  name_l10n_id: z.string(),
+  description_l10n_id: z.string(),
+  domains: z.array(TaxonomyDomain),
+  purposes: z.array(TaxonomyPurpose),
+});
+export type TaxonomyRegistry = z.infer<typeof TaxonomyRegistry>;

package/src/utils/callbacks.ts

@@ -1,11 +1,12 @@
 import { EncryptJwe, getJwkFromHeader } from "@pagopa/io-react-native-jwt";
 import { verify } from "@pagopa/io-react-native-jwt";
-import { type CallbackContext } from "@pagopa/io-wallet-oauth2";
+import { type CallbackContext, type JwtSigner } from "@pagopa/io-wallet-oauth2";
 import { digest } from "@sd-jwt/crypto-nodejs";
 import { X509 } from "jsrsasign";
 import { IoWalletError } from "./errors";
-import { generateRandomBytes } from "./misc";
+import { assert, generateRandomBytes } from "./misc";
 import type { JWK } from "./jwk";
+import { getJwkFromCertificateChain, getJwkFromTrustChain } from "./crypto";
 
 type PartialCallbackContext = Omit<
   CallbackContext,
@@ -18,6 +19,29 @@ type DigestFixed = (
   algorithm?: string
 ) => Uint8Array;
 
+/**
+ * Extract the signing JWK from one of the supported signer methods.
+ * @param signer - The JWT signer.
+ * @returns The JWK for signature verification.
+ */
+const getJwkFromSigner = async (signer: JwtSigner): Promise<JWK> => {
+  switch (signer.method) {
+    case "x5c":
+      return getJwkFromCertificateChain(signer.x5c);
+    case "federation": {
+      assert(
+        signer.trustChain && signer.trustChain.length > 0,
+        "Trust chain is required for federation signer"
+      );
+      return getJwkFromTrustChain(signer.trustChain, signer.kid);
+    }
+    case "jwk":
+      return signer.publicJwk as JWK;
+    default:
+      throw new IoWalletError(`Unsupported signer method: ${signer.method}`);
+  }
+};
+
 /**
  * Shared callbacks with React Native implementations for use
  * in IO Wallet SDK. Callbacks not found here must be provided by the caller,
@@ -32,13 +56,10 @@ export const partialCallbacks: PartialCallbackContext = {
     encryptionJwk: publicJwk,
   }),
   verifyJwt: async (jwtSigner, jwt) => {
-    // TODO: support other signing methods if needed
-    if (jwtSigner.method !== "jwk") {
-      throw new IoWalletError(`Unsupported signer method: ${jwtSigner.method}`);
-    }
     try {
-      await verify(jwt.compact, jwtSigner.publicJwk);
-      return { verified: true, signerJwk: jwtSigner.publicJwk };
+      const signerJwk = await getJwkFromSigner(jwtSigner);
+      await verify(jwt.compact, signerJwk);
+      return { verified: true, signerJwk };
     } catch {
       return { verified: false };
     }

package/src/utils/crypto.ts

@@ -5,11 +5,34 @@ import {
   sign,
 } from "@pagopa/io-react-native-crypto";
 import { v4 as uuidv4 } from "uuid";
-import { thumbprint, type CryptoContext } from "@pagopa/io-react-native-jwt";
-import { JWK } from "./jwk";
+import {
+  decode,
+  thumbprint,
+  type CryptoContext,
+} from "@pagopa/io-react-native-jwt";
+import type { BaseEntityConfiguration } from "../trust/common/types";
+import { JWK, JWKS } from "./jwk";
 import { KEYUTIL, KJUR, RSAKey, X509 } from "jsrsasign";
 import { IoWalletError } from "./errors";
 
+/**
+ * Extension of the {@link CryptoContext} that adds key generation with optional key attestation.
+ *
+ * This context requires the consumer to provide an additional method for **key generation**;
+ * on Android this method should also generate a key attestation as a certificate chain
+ * to ensure the key pair is hardware-backed.
+ */
+export type KeyAttestationCryptoContext = CryptoContext & {
+  /**
+   * Generate a key pair with an **optional key attestation** (Android).
+   * @param challenge The challenge for the key attestation.
+   * @returns An object with a success flag and a key attestation, if it was generated.
+   */
+  generateKeyWithAttestation(
+    challenge: string
+  ): Promise<{ success: boolean; attestation?: string }>;
+};
+
 /**
  * Create a CryptoContext bound to a key pair.
  * Key pair is supposed to exist already in the device's keychain.
@@ -92,19 +115,67 @@ export const getSigninJwkFromCert = (pemCert: string): JWK => {
 };
 
 /**
- * Extension of the {@link CryptoContext} that adds key generation with optional key attestation.
+ * Retrieves the signing JWK from a x509 certificate chain.
  *
- * This context requires the consumer to provide an additional method for **key generation**;
- * on Android this method should also generate a key attestation as a certificate chain
- * to ensure the key pair is hardware-backed.
+ * @param certChain - The x509 certificate chain.
+ * @returns The signing JWK.
+ * @throws Will throw an error if no suitable keys are found.
  */
-export type KeyAttestationCryptoContext = CryptoContext & {
-  /**
-   * Generate a key pair with an **optional key attestation** (Android).
-   * @param challenge The challenge for the key attestation.
-   * @returns An object with a success flag and a key attestation, if it was generated.
-   */
-  generateKeyWithAttestation(
-    challenge: string
-  ): Promise<{ success: boolean; attestation?: string }>;
+export const getJwkFromCertificateChain = async (
+  certChain: string[]
+): Promise<JWK> => {
+  const [leafCert] = certChain;
+  if (!leafCert) {
+    throw new IoWalletError(
+      "The provided certificate chain is invalid or malformed"
+    );
+  }
+  const pemCert = convertBase64DerToPem(leafCert);
+  return getSigninJwkFromCert(pemCert);
+};
+
+/**
+ * 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 const getJwkFromTrustChain = (
+  trustChain: string[],
+  signerKid: string
+): JWK => {
+  const [entityConfigurationJwt] = trustChain;
+  if (!entityConfigurationJwt) {
+    throw new IoWalletError("The provided trust chain is invalid or malformed");
+  }
+
+  const keys: JWK[] = [];
+  const decodedEntityConfigJwt = decode(entityConfigurationJwt);
+  const baseEntityConfig =
+    decodedEntityConfigJwt.payload as BaseEntityConfiguration["payload"];
+
+  // Get top-level JWKS
+  if (baseEntityConfig.jwks) {
+    keys.push(...JWKS.parse(baseEntityConfig.jwks).keys);
+  }
+
+  // Check metadata entries for additional JWKS like openid_credential_verifier
+  if (baseEntityConfig.metadata) {
+    for (const metadata of Object.values(
+      baseEntityConfig.metadata as Record<string, { jwks?: JWKS }>
+    )) {
+      if (metadata.jwks) {
+        keys.push(...JWKS.parse(metadata.jwks).keys);
+      }
+    }
+  }
+
+  const federationJwk = keys.find((key) => key.kid === signerKid);
+  if (!federationJwk)
+    throw new IoWalletError(
+      "No suitable key was found in the provided trust chain"
+    );
+  return federationJwk;
 };

package/lib/commonjs/credential/presentation/v1.0.0/04-verify-certificate-chain.js

@@ -1,12 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.verifyAuthRequestCertificateChain = void 0;
-var _errors = require("../../../utils/errors");
-const verifyAuthRequestCertificateChain = async () => {
-  throw new _errors.UnimplementedFeatureError("verifyAuthRequestCertificateChain", "1.0.0");
-};
-exports.verifyAuthRequestCertificateChain = verifyAuthRequestCertificateChain;
-//# sourceMappingURL=04-verify-certificate-chain.js.map

package/lib/commonjs/credential/presentation/v1.0.0/04-verify-certificate-chain.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_errors","require","verifyAuthRequestCertificateChain","UnimplementedFeatureError","exports"],"sourceRoot":"../../../../../src","sources":["credential/presentation/v1.0.0/04-verify-certificate-chain.ts"],"mappings":";;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AAGO,MAAMC,iCAA6F,GACxG,MAAAA,CAAA,KAAY;EACV,MAAM,IAAIC,iCAAyB,CACjC,mCAAmC,EACnC,OACF,CAAC;AACH,CAAC;AAACC,OAAA,CAAAF,iCAAA,GAAAA,iCAAA"}

package/lib/module/credential/presentation/v1.0.0/04-verify-certificate-chain.js

@@ -1,5 +0,0 @@
-import { UnimplementedFeatureError } from "../../../utils/errors";
-export const verifyAuthRequestCertificateChain = async () => {
-  throw new UnimplementedFeatureError("verifyAuthRequestCertificateChain", "1.0.0");
-};
-//# sourceMappingURL=04-verify-certificate-chain.js.map

package/lib/module/credential/presentation/v1.0.0/04-verify-certificate-chain.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["UnimplementedFeatureError","verifyAuthRequestCertificateChain"],"sourceRoot":"../../../../../src","sources":["credential/presentation/v1.0.0/04-verify-certificate-chain.ts"],"mappings":"AAAA,SAASA,yBAAyB,QAAQ,uBAAuB;AAGjE,OAAO,MAAMC,iCAA6F,GACxG,MAAAA,CAAA,KAAY;EACV,MAAM,IAAID,yBAAyB,CACjC,mCAAmC,EACnC,OACF,CAAC;AACH,CAAC"}

package/lib/typescript/credential/presentation/v1.0.0/04-verify-certificate-chain.d.ts

@@ -1,3 +0,0 @@
-import { type RemotePresentationApi } from "../api";
-export declare const verifyAuthRequestCertificateChain: RemotePresentationApi["verifyAuthRequestCertificateChain"];
-//# sourceMappingURL=04-verify-certificate-chain.d.ts.map

package/lib/typescript/credential/presentation/v1.0.0/04-verify-certificate-chain.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"04-verify-certificate-chain.d.ts","sourceRoot":"","sources":["../../../../../src/credential/presentation/v1.0.0/04-verify-certificate-chain.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,QAAQ,CAAC;AAEpD,eAAO,MAAM,iCAAiC,EAAE,qBAAqB,CAAC,mCAAmC,CAMtG,CAAC"}

package/src/credential/presentation/v1.0.0/04-verify-certificate-chain.ts

@@ -1,10 +0,0 @@
-import { UnimplementedFeatureError } from "../../../utils/errors";
-import { type RemotePresentationApi } from "../api";
-
-export const verifyAuthRequestCertificateChain: RemotePresentationApi["verifyAuthRequestCertificateChain"] =
-  async () => {
-    throw new UnimplementedFeatureError(
-      "verifyAuthRequestCertificateChain",
-      "1.0.0"
-    );
-  };