@pagopa/io-react-native-wallet 1.7.0 → 2.0.0-next.0

package/lib/typescript/entity/openid-connect/issuer/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/entity/openid-connect/issuer/types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAIzB,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAClE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW5B,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;EAGjC,CAAC;AAEH,eAAO,MAAM,gBAAgB,mEAG3B,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAC9D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;EAG1B,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAC1E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;GAA4B,CAAC;AAE/D,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CACpD,OAAO,gCAAgC,CACxC,CAAC;AACF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAe5C,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACxE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE/B,CAAC;AAEH,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CACjD,OAAO,6BAA6B,CACrC,CAAC;AACF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASxC,CAAC"}

package/lib/typescript/entity/trust/chain.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chain.d.ts","sourceRoot":"","sources":["../../../../src/entity/trust/chain.ts"],"names":[],"mappings":"AAIA,OAAO,EAGL,8BAA8B,EAC/B,MAAM,SAAS,CAAC;AACjB,OAAO,EAAO,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAK5D,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,eAAe,CAAC,iBAAiB,CAAC,CAAC;IAC3C,OAAO,EAAE,eAAe,CAAC,SAAS,CAAC,CAAC;CACrC,CAAC;AAiCF;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CACtC,iBAAiB,EAAE,8BAA8B,EACjD,KAAK,EAAE,MAAM,EAAE,GACd,OAAO,CAAC,WAAW,EAAE,CAAC,CA+CxB;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EAAE,EACf,QAAQ,GAAE,WAAW,CAAC,OAAO,CAAS,qBAiCvC"}

package/lib/typescript/entity/trust/index.d.ts.map

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

package/lib/typescript/mdoc/converters.d.ts

@@ -1,8 +0,0 @@
-/**
- * Extracts the date value of a given elementIdentifier from an MDOC object.
- * Searches through the issuerSigned namespaces and attempts to parse the value as a Date.
- * The expected date format is "DD-MM-YYYY".
- * Returns the Date object if found, otherwise returns null.
- */
-export declare function extractElementValueAsDate(elementValue: string): Date | null;
-//# sourceMappingURL=converters.d.ts.map

package/lib/typescript/mdoc/converters.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"converters.d.ts","sourceRoot":"","sources":["../../../src/mdoc/converters.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAmB3E"}

package/lib/typescript/mdoc/index.d.ts

@@ -1,10 +0,0 @@
-import { CBOR } from "@pagopa/io-react-native-cbor";
-import type { JWK } from "../utils/jwk";
-import { type Presentation } from "../credential/presentation/types";
-export declare const verify: (token: string, _: JWK | JWK[]) => Promise<{
-    issuerSigned: CBOR.IssuerSigned;
-}>;
-export declare const prepareVpTokenMdoc: (requestNonce: string, generatedNonce: string, clientId: string, responseUri: string, docType: string, keyTag: string, [verifiableCredential, requestedClaims, _]: Presentation) => Promise<{
-    vp_token: string;
-}>;
-//# sourceMappingURL=index.d.ts.map

package/lib/typescript/mdoc/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mdoc/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAkB,MAAM,8BAA8B,CAAC;AACpE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAQxC,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAGrE,eAAO,MAAM,MAAM,UACV,MAAM,KACV,GAAG,GAAG,GAAG,EAAE;kBACW,KAAK,YAAY;EA0B3C,CAAC;AAEF,eAAO,MAAM,kBAAkB,iBACf,MAAM,kBACJ,MAAM,YACZ,MAAM,eACH,MAAM,WACV,MAAM,UACP,MAAM;cAGJ,MAAM;EA0CjB,CAAC"}

package/lib/typescript/utils/credential/issuance/07-verify-and-parse-credentials-inputs.d.ts

@@ -1,3 +0,0 @@
-import { type TestScenario, type ParseCredentialArg, type ParseCredentialReturn } from "./07-verify-and-parse-credentials-utils";
-export declare const inputs: TestScenario<ParseCredentialArg, ParseCredentialReturn, Error>[];
-//# sourceMappingURL=07-verify-and-parse-credentials-inputs.d.ts.map

package/lib/typescript/utils/credential/issuance/07-verify-and-parse-credentials-inputs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"07-verify-and-parse-credentials-inputs.d.ts","sourceRoot":"","sources":["../../../../../src/utils/credential/issuance/07-verify-and-parse-credentials-inputs.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,EAG3B,MAAM,yCAAyC,CAAC;AAGjD,eAAO,MAAM,MAAM,EAAE,YAAY,CAC/B,kBAAkB,EAClB,qBAAqB,EACrB,KAAK,CACN,EAylBA,CAAC"}

package/lib/typescript/utils/credential/issuance/07-verify-and-parse-credentials-utils.d.ts

@@ -1,42 +0,0 @@
-import type { parseCredentialMDoc, parseCredentialSdJwt } from "src/credential/issuance/07-verify-and-parse-credential";
-export type TestScenario<T extends object, R extends object, E extends Error> = {
-    name: string;
-    input: T;
-    expected?: R;
-    throws?: E;
-};
-export type ParseCredentialArg = {
-    format: "vc+sd-jwt";
-    parameters: Parameters<typeof parseCredentialSdJwt>;
-} | {
-    format: "mso_mdoc";
-    parameters: Parameters<typeof parseCredentialMDoc>;
-};
-export type ClaimsSdJwt = Record<string, {
-    display: {
-        name: string;
-        locale: string;
-    }[];
-    mandatory: boolean;
-}> | Record<string, Record<string, {
-    display: {
-        name: string;
-        locale: string;
-    }[];
-    mandatory: boolean;
-}>>;
-export type ClaimsMDOC = Record<string, {
-    display: {
-        name: string;
-        locale: string;
-    }[];
-    mandatory: boolean;
-}>;
-export type ParseCredentialReturn = Record<string, {
-    name?: string | Record<string, string>;
-    value: unknown;
-    mandatory?: boolean;
-}>;
-export declare function buildMockMDOCTestScenario(claims: ClaimsMDOC, nameSpaces: [string, any][]): Parameters<typeof parseCredentialMDoc>;
-export declare function buildMockSDJWTTestScenario(claims: ClaimsSdJwt, disclosures: [string, string, unknown][]): Parameters<typeof parseCredentialSdJwt>;
-//# sourceMappingURL=07-verify-and-parse-credentials-utils.d.ts.map

package/lib/typescript/utils/credential/issuance/07-verify-and-parse-credentials-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"07-verify-and-parse-credentials-utils.d.ts","sourceRoot":"","sources":["../../../../../src/utils/credential/issuance/07-verify-and-parse-credentials-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,wDAAwD,CAAC;AAEhE,MAAM,MAAM,YAAY,CACtB,CAAC,SAAS,MAAM,EAChB,CAAC,SAAS,MAAM,EAChB,CAAC,SAAS,KAAK,IACb;IACF,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,CAAC,CAAC;IACT,QAAQ,CAAC,EAAE,CAAC,CAAC;IACb,MAAM,CAAC,EAAE,CAAC,CAAC;CACZ,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAC1B;IACE,MAAM,EAAE,WAAW,CAAC;IACpB,UAAU,EAAE,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC;CACrD,GACD;IACE,MAAM,EAAE,UAAU,CAAC;IACnB,UAAU,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC;CACpD,CAAC;AAEN,MAAM,MAAM,WAAW,GACnB,MAAM,CACJ,MAAM,EACN;IACE,OAAO,EAAE;QACP,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;KAChB,EAAE,CAAC;IACJ,SAAS,EAAE,OAAO,CAAC;CACpB,CACF,GACD,MAAM,CACJ,MAAM,EACN,MAAM,CACJ,MAAM,EACN;IACE,OAAO,EAAE;QACP,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;KAChB,EAAE,CAAC;IACJ,SAAS,EAAE,OAAO,CAAC;CACpB,CACF,CACF,CAAC;AAEN,MAAM,MAAM,UAAU,GAAG,MAAM,CAC7B,MAAM,EACN;IACE,OAAO,EAAE;QACP,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;KAChB,EAAE,CAAC;IACJ,SAAS,EAAE,OAAO,CAAC;CACpB,CACF,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,MAAM,CACxC,MAAM,EACN;IACE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CACF,CAAC;AAEF,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,UAAU,EAClB,UAAU,EAAE,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,GAC1B,UAAU,CAAC,OAAO,mBAAmB,CAAC,CA+CxC;AAED,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,WAAW,EACnB,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,GACvC,UAAU,CAAC,OAAO,oBAAoB,CAAC,CA4CzC"}

package/src/credential/issuance/02-get-issuer-config.ts

@@ -1,67 +0,0 @@
-import type { StartFlow } from "./01-start-flow";
-import type { Out } from "../../utils/misc";
-import type { JWK } from "src/utils/jwk";
-import { getCredentialIssuerMetadata } from "../../entity/openid-connect/issuer";
-import type { CredentialConfigurationSupported } from "../../entity/openid-connect/issuer/types";
-
-export type GetIssuerConfig = (
-  issuerUrl: Out<StartFlow>["issuerUrl"],
-  context?: {
-    appFetch?: GlobalFetch["fetch"];
-  }
-) => Promise<{ issuerConf: IssuerConfig }>;
-
-/**
- * Common configuration for the issuer.
- * This is needed to have a common configuration for the issuer to be used in our flows.
- * It allows to support multiple issuers with different configurations, defining a common interface to interact with them.
- */
-export type IssuerConfig = {
-  credential_configurations_supported: CredentialConfigurationSupported;
-  pushed_authorization_request_endpoint: string;
-  authorization_endpoint: string;
-  token_endpoint: string;
-  credential_endpoint: string;
-  keys: Array<JWK>;
-};
-
-/**
- * WARNING: This function must be called after {@link startFlow}. The next function to be called is {@link startUserAuthorization}.
- * Get the Issuer's configuration from the Issuer's metadata.
- * Currently it only supports a mixed configuration based on OpenID Connect partial implementation.
- * @param issuerUrl The base url of the Issuer returned by {@link startFlow}
- * @param context.appFetch (optional) fetch api implementation. Default: built-in fetch
- * @returns The Issuer's configuration
- */
-export const getIssuerConfig: GetIssuerConfig = async (
-  issuerUrl,
-  context = {}
-): ReturnType<GetIssuerConfig> => {
-  const res = await getCredentialIssuerMetadata(issuerUrl, {
-    appFetch: context.appFetch,
-  });
-
-  return credentialIssuerRationalization(res);
-};
-
-/**
- * Rationalize the issuer's metadata to the issuer's configuration which is then used in our flows to interact with the issuer.
- * @param issuerMetadata - The issuer's metadata
- * @returns the isssuer configuration to be used later in our flows
- */
-const credentialIssuerRationalization = (
-  issuerMetadata: Awaited<ReturnType<typeof getCredentialIssuerMetadata>>
-): Awaited<ReturnType<GetIssuerConfig>> => {
-  return {
-    issuerConf: {
-      credential_configurations_supported:
-        issuerMetadata.credential_configurations_supported,
-      pushed_authorization_request_endpoint:
-        issuerMetadata.pushed_authorization_request_endpoint,
-      authorization_endpoint: issuerMetadata.authorization_endpoint,
-      token_endpoint: issuerMetadata.token_endpoint,
-      credential_endpoint: issuerMetadata.credential_endpoint,
-      keys: issuerMetadata.jwks.keys,
-    },
-  };
-};

package/src/entity/openid-connect/issuer/index.ts

@@ -1,27 +0,0 @@
-import { hasStatusOrThrow } from "../../../utils/misc";
-import { CredentialIssuerConfiguration } from "./types";
-
-/**
- * Fetch the signed entity configuration token for an entity
- *
- * @param entityBaseUrl The url of the entity to fetch
- * @param param.appFetch (optional) fetch api implemention
- * @returns The signed Entity Configuration token
- */
-export async function getCredentialIssuerMetadata(
-  entityBaseUrl: string,
-  {
-    appFetch = fetch,
-  }: {
-    appFetch?: GlobalFetch["fetch"];
-  } = {}
-): Promise<CredentialIssuerConfiguration> {
-  const wellKnownUrl = `${entityBaseUrl}/.well-known/openid-credential-issuer`;
-
-  return await appFetch(wellKnownUrl, {
-    method: "GET",
-  })
-    .then(hasStatusOrThrow(200))
-    .then((res) => res.json())
-    .then(CredentialIssuerConfiguration.parse);
-}

package/src/entity/openid-connect/issuer/types.ts

@@ -1,76 +0,0 @@
-import { JWK } from "../../../utils/jwk";
-import * as z from "zod";
-
-// Display metadata for a credential, used by the issuer to
-// instruct the Wallet Solution on how to render the credential correctly
-export type CredentialDisplay = z.infer<typeof CredentialDisplay>;
-export const CredentialDisplay = z.object({
-  name: z.string(),
-  locale: z.string(),
-  logo: z
-    .object({
-      url: z.string(),
-      alt_text: z.string(),
-    })
-    .optional(),
-  background_color: z.string().optional(),
-  text_color: z.string().optional(),
-});
-
-export const CredentialClaimDisplay = z.object({
-  name: z.string(),
-  locale: z.string(),
-});
-
-export const CredentialFormat = z.union([
-  z.literal("vc+sd-jwt"),
-  z.literal("mso_mdoc"),
-]);
-
-export type CredentialClaim = z.infer<typeof CredentialClaim>;
-export const CredentialClaim = z.object({
-  mandatory: z.boolean(),
-  display: z.array(CredentialClaimDisplay),
-});
-
-export type CredentialSdJwtClaims = z.infer<typeof CredentialSdJwtClaims>;
-export const CredentialSdJwtClaims = z.record(CredentialClaim);
-
-export type CredentialConfigurationSupported = z.infer<
-  typeof CredentialConfigurationSupported
->;
-export const CredentialConfigurationSupported = z.record(
-  z.object({
-    cryptographic_suites_supported: z.array(z.string()),
-    vct: z.string().optional(),
-    scope: z.string().optional(),
-    cryptographic_binding_methods_supported: z.array(z.string()),
-    display: z.array(CredentialDisplay),
-    format: CredentialFormat,
-    claims: z
-      .union([
-        CredentialSdJwtClaims,
-        z.record(z.string(), CredentialSdJwtClaims),
-      ])
-      .optional(),
-  })
-);
-
-export type CredentialIssuerKeys = z.infer<typeof CredentialIssuerKeys>;
-export const CredentialIssuerKeys = z.object({
-  keys: z.array(JWK),
-});
-
-export type CredentialIssuerConfiguration = z.infer<
-  typeof CredentialIssuerConfiguration
->;
-export const CredentialIssuerConfiguration = z.object({
-  credential_configurations_supported: CredentialConfigurationSupported,
-  pushed_authorization_request_endpoint: z.string(),
-  dpop_signing_alg_values_supported: z.array(z.string()),
-  jwks: CredentialIssuerKeys,
-  credential_issuer: z.string(),
-  authorization_endpoint: z.string(),
-  token_endpoint: z.string(),
-  credential_endpoint: z.string(),
-});

package/src/entity/trust/chain.ts

@@ -1,154 +0,0 @@
-import {
-  decode as decodeJwt,
-  verify as verifyJwt,
-} from "@pagopa/io-react-native-jwt";
-import {
-  EntityConfiguration,
-  EntityStatement,
-  TrustAnchorEntityConfiguration,
-} from "./types";
-import { JWK, type JWTDecodeResult } from "../../utils/jwk";
-import { IoWalletError } from "../../utils/errors";
-import * as z from "zod";
-import { getSignedEntityConfiguration, getSignedEntityStatement } from ".";
-
-type ParsedToken = {
-  header: JWTDecodeResult["protectedHeader"];
-  payload: JWTDecodeResult["payload"];
-};
-
-// Verify a token signature
-// The kid is extracted from the token header
-const verify = async (
-  token: string,
-  kid: string,
-  jwks: JWK[]
-): Promise<ParsedToken> => {
-  const jwk = jwks.find((k) => k.kid === kid);
-  if (!jwk) {
-    throw new Error(`Invalid kid: ${kid}, token: ${token}`);
-  }
-  const { protectedHeader: header, payload } = await verifyJwt(token, jwk);
-  return { header, payload };
-};
-
-const decode = (token: string) => {
-  const { protectedHeader: header, payload } = decodeJwt(token);
-  return { header, payload };
-};
-
-// The first element of the chain is supposed to be the Entity Configuration for the document issuer
-const FirstElementShape = EntityConfiguration;
-// Each element but the first is supposed to be an Entity Statement
-const MiddleElementShape = EntityStatement;
-// The last element of the chain can either be an Entity Statement
-//  or the Entity Configuration for the known Trust Anchor
-const LastElementShape = z.union([
-  EntityStatement,
-  TrustAnchorEntityConfiguration,
-]);
-
-/**
- * Validates a provided trust chain against a known trust
- *
- * @param trustAnchorEntity The entity configuration of the known trust anchor
- * @param chain The chain of statements to be validate
- * @returns The list of parsed token representing the chain
- * @throws {IoWalletError} If the chain is not valid
- */
-export async function validateTrustChain(
-  trustAnchorEntity: TrustAnchorEntityConfiguration,
-  chain: string[]
-): Promise<ParsedToken[]> {
-  // If the chain is empty, fail
-  if (chain.length === 0) {
-    throw new IoWalletError("Cannot verify empty trust chain");
-  }
-
-  // Select the expected token shape
-  const selectTokenShape = (elementIndex: number) =>
-    elementIndex === 0
-      ? FirstElementShape
-      : elementIndex === chain.length - 1
-        ? LastElementShape
-        : MiddleElementShape;
-
-  // select the kid from the current index
-  const selectKid = (currentIndex: number): string => {
-    const token = chain[currentIndex];
-    if (!token) {
-      throw new IoWalletError(`Cannot select kid: empty token`);
-    }
-    const shape = selectTokenShape(currentIndex);
-    return shape.parse(decode(token)).header.kid;
-  };
-
-  // select keys from the next token
-  // if the current token is the last, keys fro  trust anchor will be used
-  const selectKeys = (currentIndex: number): JWK[] => {
-    if (currentIndex === chain.length - 1) {
-      return trustAnchorEntity.payload.jwks.keys;
-    }
-
-    const nextIndex = currentIndex + 1;
-    const nextToken = chain[nextIndex];
-    if (!nextToken) {
-      throw new IoWalletError(`Cannot select keys: empty nextToken`);
-    }
-    const shape = selectTokenShape(nextIndex);
-    return shape.parse(decode(nextToken)).payload.jwks.keys;
-  };
-
-  // Iterate the chain and validate each element's signature against the public keys of its next
-  // If there is no next, hence it's the end of the chain and it must be verified by the Trust Anchor
-  return Promise.all(
-    chain
-      .map((token, i) => [token, selectKid(i), selectKeys(i)] as const)
-      .map((args) => verify(...args))
-  );
-}
-
-/**
- * Given a trust chain, obtain a new trust chain by fetching each element's fresh version
- *
- * @param chain The original chain
- * @param appFetch (optional) fetch api implementation
- * @returns A list of signed token that reprensent the trust chain, in the same order of the provided chain
- * @throws When an element of the chain fails to parse
- */
-export function renewTrustChain(
-  chain: string[],
-  appFetch: GlobalFetch["fetch"] = fetch
-) {
-  return Promise.all(
-    chain
-      // Decode each item to determine its shape
-      .map(decode)
-      .map(
-        (e) =>
-          [
-            EntityStatement.safeParse(e),
-            EntityConfiguration.safeParse(e),
-          ] as const
-      )
-      // fetch the element according to its shape
-      .map(([es, ec], i) =>
-        ec.success
-          ? getSignedEntityConfiguration(ec.data.payload.iss, { appFetch })
-          : es.success
-            ? getSignedEntityStatement(
-                es.data.payload.iss,
-                es.data.payload.sub,
-                {
-                  appFetch,
-                }
-              )
-            : // if the element fail to parse in both EntityStatement and EntityConfiguration, raise an error
-              Promise.reject(
-                new IoWalletError(
-                  `Cannot renew trust chain because the element #${i} failed to be parsed.`
-                )
-              )
-      )
-  );
-}

package/src/mdoc/converters.ts

@@ -1,26 +0,0 @@
-/**
- * Extracts the date value of a given elementIdentifier from an MDOC object.
- * Searches through the issuerSigned namespaces and attempts to parse the value as a Date.
- * The expected date format is "DD-MM-YYYY".
- * Returns the Date object if found, otherwise returns null.
- */
-export function extractElementValueAsDate(elementValue: string): Date | null {
-  if (typeof elementValue === "string") {
-    const dateParts = elementValue.split("-");
-    if (dateParts.length === 3) {
-      const [day, month, year] = dateParts.map((part) => Number(part));
-      if (
-        day !== undefined &&
-        month !== undefined &&
-        year !== undefined &&
-        !isNaN(day) &&
-        !isNaN(month) &&
-        !isNaN(year)
-      ) {
-        return new Date(year, month - 1, day); // Month is zero-based in JS Date
-      }
-    }
-  }
-
-  return null; // Return null if no matching element is found or it's not a valid date
-}

package/src/mdoc/index.ts

@@ -1,95 +0,0 @@
-import { CBOR, COSE, ISO18013 } from "@pagopa/io-react-native-cbor";
-import type { JWK } from "../utils/jwk";
-import type { PublicKey } from "@pagopa/io-react-native-crypto";
-import { b64utob64 } from "jsrsasign";
-import {
-  convertCertToPem,
-  getSigningJwk,
-  parsePublicKey,
-} from "../utils/crypto";
-import { type Presentation } from "../credential/presentation/types";
-import { base64ToBase64Url } from "../utils/string";
-
-export const verify = async (
-  token: string,
-  _: JWK | JWK[]
-): Promise<{ issuerSigned: CBOR.IssuerSigned }> => {
-  // get decoded data
-  const issuerSigned = await CBOR.decodeIssuerSigned(token);
-  if (!issuerSigned) {
-    throw new Error("Invalid mDoc");
-  }
-
-  const cert = issuerSigned.issuerAuth.unprotectedHeader[0]?.keyId;
-  if (!cert) throw new Error("Certificate not present in credential");
-
-  const pemcert = convertCertToPem(b64utob64(cert));
-  const publickey = parsePublicKey(pemcert);
-  if (!publickey) throw new Error("Certificate not present in credential");
-
-  const jwk = getSigningJwk(publickey);
-
-  jwk.x = b64utob64(jwk.x!);
-  jwk.y = b64utob64(jwk.y!);
-
-  const signatureCorrect = await COSE.verify(
-    b64utob64(issuerSigned.issuerAuth.rawValue!),
-    jwk as PublicKey
-  ).catch(() => false);
-  if (!signatureCorrect) throw new Error("Invalid mDoc signature");
-
-  return { issuerSigned };
-};
-
-export const prepareVpTokenMdoc = async (
-  requestNonce: string,
-  generatedNonce: string,
-  clientId: string,
-  responseUri: string,
-  docType: string,
-  keyTag: string,
-  [verifiableCredential, requestedClaims, _]: Presentation
-): Promise<{
-  vp_token: string;
-}> => {
-  /* verifiableCredential is a IssuerSigned structure */
-  const documents = [
-    {
-      issuerSignedContent: verifiableCredential,
-      alias: keyTag,
-      docType,
-    },
-  ];
-
-  /* we map each requested claim as for ex. { "org.iso.18013.5.1.mDL": { "org.iso.18013.5.1": { <claim-name>: true, ... }}} for selective disclosure */
-  const fieldRequestedAndAccepted = JSON.stringify({
-    [docType]: requestedClaims.reduce<Record<string, unknown>>(
-      (acc, { name, namespace }) => {
-        if (namespace) {
-          acc[namespace] ??= {};
-          const existingNamespace = acc[namespace] as Record<string, boolean>;
-          existingNamespace[name] = true;
-        } else {
-          acc[name] = true;
-        }
-        return acc;
-      },
-      {} as Record<string, unknown>
-    ),
-  });
-
-  /* clientId,responseUri,requestNonce are retrieved by Auth Request Object */
-  /* create DeviceResponse as { documents: { docType, issuerSigned, deviceSigned }, version, status } */
-  const vp_token = await ISO18013.generateOID4VPDeviceResponse(
-    clientId,
-    responseUri,
-    requestNonce,
-    generatedNonce,
-    documents,
-    fieldRequestedAndAccepted
-  );
-
-  return {
-    vp_token: base64ToBase64Url(vp_token),
-  };
-};