@pagopa/io-react-native-wallet 2.5.0 → 3.0.0

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

@@ -0,0 +1,82 @@
+import * as z from "zod";
+import { UnixTime } from "../../utils/zod";
+
+const CredentialPurpose = z.object({
+  id: z.string(),
+  description: z.string(),
+  claims_required: z.array(z.string()),
+  claim_recommended: z.array(z.string()),
+});
+
+const CredentialIssuer = z.object({
+  id: z.string(),
+  organization_name: z.string(),
+  organization_code: z.string(),
+  organization_country: z.string(),
+  contacts: z.array(z.string()).optional(),
+  homepage_uri: z.string().optional(),
+  logo_uri: z.string().optional(),
+  policy_uri: z.string().optional(),
+  tos_uri: z.string().optional(),
+});
+
+const AuthenticSource = z.object({
+  id: z.string(),
+  organization_name: z.string(),
+  organization_code: z.string().optional(),
+  organization_country: z.string(),
+  organization_type: z.string(),
+  contacts: z.array(z.string()).optional(),
+  homepage_uri: z.string().optional(),
+  logo_uri: z.string().optional(),
+  user_information: z.string().optional(),
+});
+export type AuthenticSource = z.infer<typeof AuthenticSource>;
+
+export const CredentialFormat = z.object({
+  configuration_id: z.string(),
+  format: z.enum(["dc+sd-jwt", "mso_mdoc"]),
+  vct: z.string().url().optional(),
+  docType: z.string().optional(),
+  schema_uri: z.string().url().optional(),
+  "schema_uri#integrity": z.string().optional(),
+});
+export type CredentialFormat = z.infer<typeof CredentialFormat>;
+
+export const Claim = z.object({
+  name: z.string(),
+  taxonomy_ref: z.string(),
+  display_name: z.string(),
+});
+
+/**
+ * Unified shape for a Digital Credential in the catalogue, regardless of IT-Wallet version.
+ * Please note that some of the version-specific properties might be missing in this representation.
+ */
+export const DigitalCredential = z.object({
+  version: z.string(),
+  credential_type: z.string(),
+  legal_type: z.string(),
+  name: z.string(),
+  description: z.string(),
+  validity_info: z.object({
+    max_validity_days: z.number(),
+    status_methods: z.array(z.string()),
+    allowed_states: z.array(z.string()),
+  }),
+  purposes: z.array(CredentialPurpose),
+  issuers: z.array(CredentialIssuer),
+  authentic_sources: z.array(AuthenticSource),
+  formats: z.array(CredentialFormat),
+  // claims: z.array(Claim), // TODO: [SIW-3978] Should we keep claims?
+});
+
+export const DigitalCredentialsCatalogue = z.object({
+  taxonomy_uri: z.string().url(),
+  credentials: z.array(DigitalCredential),
+  iat: UnixTime,
+  exp: UnixTime,
+});
+export type DigitalCredentialsCatalogue = z.infer<
+  typeof DigitalCredentialsCatalogue
+>;

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

@@ -0,0 +1,21 @@
+import { type DigitalCredentialsCatalogue } from "./DigitalCredentialsCatalogue";
+
+type FetchContext = { appFetch?: GlobalFetch["fetch"] };
+
+export interface CredentialsCatalogueApi {
+  /**
+   * Fetch and parse the Digital Credential Catalogue from the Trust Anchor.
+   * The catalogue's JWT signature is verified against the Trust Anchor's JWKs.
+   *
+   * @since 1.0.0
+   * @param trustAnchorBaseUrl Base URL of the Trust Anchor
+   * @param context.appFetch (optional) fetch API implementation. Default: built-in fetch
+   * @returns The Digital Credential Catalogue payload
+   */
+  fetchAndParseCatalogue(
+    trustAnchorBaseUrl: string,
+    ctx?: FetchContext
+  ): Promise<DigitalCredentialsCatalogue>;
+}
+
+export { type DigitalCredentialsCatalogue };

package/src/credentials-catalogue/index.ts

@@ -1,2 +1,3 @@
-export { fetchAndParseCatalogue } from "./fetch-and-parse-catalogue";
-export { type DigitalCredentialsCatalogue } from "./types";
+export type * from "./api";
+export { CredentialsCatalogue as V1_0_0 } from "./v1.0.0";
+export { CredentialsCatalogue as V1_3_3 } from "./v1.3.3";

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

@@ -0,0 +1,41 @@
+import { decode as decodeJwt, verify } from "@pagopa/io-react-native-jwt";
+import { hasStatusOrThrow } from "../../utils/misc";
+import { IoWalletError } from "../../utils/errors";
+import { getTrustAnchorEntityConfiguration } from "../../trust/v1.0.0/entities";
+import { type CredentialsCatalogueApi as Api } from "../api";
+import { mapToCredentialsCatalogue } from "./mappers";
+
+export const fetchAndParseCatalogue: Api["fetchAndParseCatalogue"] = async (
+  trustAnchorBaseUrl,
+  { appFetch = fetch } = {}
+) => {
+  const trustAnchorConfig =
+    await getTrustAnchorEntityConfiguration(trustAnchorBaseUrl);
+
+  const responseText = await appFetch(
+    `${trustAnchorConfig.payload.sub}/.well-known/credential-catalogue`,
+    { method: "GET" }
+  )
+    .then(hasStatusOrThrow(200))
+    .then((res) => res.text());
+
+  const responseJwt = decodeJwt(responseText);
+  const catalogueKid = responseJwt.protectedHeader.kid;
+
+  const trustAnchorJwk = trustAnchorConfig.payload.jwks.keys.find(
+    (jwk) => jwk.kid === catalogueKid
+  );
+
+  if (!trustAnchorJwk) {
+    throw new IoWalletError(
+      `Could not find JWK with kid ${catalogueKid} in Trust Anchor's Entity Configuration`
+    );
+  }
+
+  await verify(responseText, trustAnchorJwk);
+
+  return mapToCredentialsCatalogue({
+    header: responseJwt.protectedHeader,
+    payload: responseJwt.payload,
+  });
+};

package/src/credentials-catalogue/v1.0.0/index.ts

@@ -0,0 +1,6 @@
+import type { CredentialsCatalogueApi } from "../api";
+import { fetchAndParseCatalogue } from "./fetch-and-parse-catalogue";
+
+export const CredentialsCatalogue: CredentialsCatalogueApi = {
+  fetchAndParseCatalogue,
+};

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

@@ -0,0 +1,20 @@
+import { createMapper } from "../../utils/mappers";
+import { DigitalCredentialsCatalogue } from "../api/DigitalCredentialsCatalogue";
+import { DigitalCredentialsCatalogueJwt } from "./types";
+
+export const mapToCredentialsCatalogue = createMapper(
+  ({ payload }) => ({
+    ...payload,
+    credentials: payload.credentials.map((credential) => ({
+      ...credential,
+      authentic_sources: credential.authentic_sources.map((as) => ({
+        ...as,
+        organization_type: as.source_type,
+      })),
+    })),
+  }),
+  {
+    inputSchema: DigitalCredentialsCatalogueJwt,
+    outputSchema: DigitalCredentialsCatalogue,
+  }
+);

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

@@ -0,0 +1,97 @@
+import * as z from "zod";
+import { UnixTime } from "../../utils/zod";
+
+const CredentialPurpose = z.object({
+  id: z.string(),
+  description: z.string(),
+  category: z.string().optional(),
+  subcategory: z.string().optional(),
+  claims_required: z.array(z.string()),
+  claim_recommended: z.array(z.string()),
+});
+
+const CredentialIssuer = z.object({
+  id: z.string(),
+  organization_name: z.string(),
+  organization_code: z.string(),
+  organization_country: z.string(),
+  contacts: z.array(z.string()).optional(),
+  homepage_uri: z.string().optional(),
+  logo_uri: z.string().optional(),
+  policy_uri: z.string().optional(),
+  tos_uri: z.string().optional(),
+});
+
+const AuthenticSource = z.object({
+  id: z.string(),
+  organization_name: z.string(),
+  organization_code: z.string(),
+  organization_country: z.string(),
+  source_type: z.string(),
+  contacts: z.array(z.string()).optional(),
+  homepage_uri: z.string().optional(),
+  logo_uri: z.string().optional(),
+  user_information: z.string().optional(),
+});
+
+const CredentialFormat = z.object({
+  configuration_id: z.string(),
+  format: z.enum(["dc+sd-jwt", "mso_mdoc"]),
+  vct: z.string().url().optional(),
+  docType: z.string().optional(),
+  schema_uri: z.string().url().optional(),
+  "schema_uri#integrity": z.string().optional(),
+});
+
+const Claim = z.object({
+  name: z.string(),
+  taxonomy_ref: z.string(),
+  display_name: z.string(),
+});
+
+export const DigitalCredential = z.object({
+  version: z.string(),
+  credential_type: z.string(),
+  legal_type: z.string(),
+  name: z.string(),
+  description: z.string(),
+  validity_info: z.object({
+    max_validity_days: z.number(),
+    status_methods: z.array(z.string()),
+    allowed_states: z.array(z.string()),
+  }),
+  authentication: z.object({
+    user_auth_required: z.boolean(),
+    min_loa: z.string(),
+    supported_eid_schemes: z.array(z.string()),
+  }),
+  purposes: z.array(CredentialPurpose),
+  issuers: z.array(CredentialIssuer),
+  authentic_sources: z.array(AuthenticSource),
+  formats: z.array(CredentialFormat),
+  claims: z.array(Claim),
+});
+
+/**
+ * The Digital Credentials Catalogue published by the Trust Anchor
+ *
+ * @version 1.1.0
+ * @see https://italia.github.io/eid-wallet-it-docs/releases/1.1.0/en/registry-catalogue.html
+ */
+export const DigitalCredentialsCatalogueJwt = z.object({
+  header: z.object({
+    typ: z.string(),
+    alg: z.string(),
+    kid: z.string(),
+  }),
+  payload: z.object({
+    catalog_version: z.string(),
+    taxonomy_uri: z.string().url(),
+    credentials: z.array(DigitalCredential),
+    iat: UnixTime,
+    exp: UnixTime,
+  }),
+});
+export type DigitalCredentialsCatalogueJwt = z.infer<
+  typeof DigitalCredentialsCatalogueJwt
+>;

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

@@ -0,0 +1,52 @@
+import { getTrustAnchorEntityConfiguration } from "../../trust/v1.0.0/entities"; // TODO: use trust from v1.3.3
+import { type CredentialsCatalogueApi as Api } from "../api";
+import {
+  AuthenticSourceRegistry,
+  DigitalCredentialsCatalogueJwt,
+  RegistryDiscoveryJwt,
+  SchemaRegistry,
+} from "./types";
+import { mapToCredentialsCatalogue } from "./mappers";
+import { fetchRegistry } from "./utils";
+
+export const fetchAndParseCatalogue: Api["fetchAndParseCatalogue"] = async (
+  trustAnchorBaseUrl,
+  { appFetch = fetch } = {}
+) => {
+  const trustAnchorConfig = await getTrustAnchorEntityConfiguration(
+    trustAnchorBaseUrl,
+    { appFetch }
+  );
+  const trustAnchorJwks = trustAnchorConfig.payload.jwks.keys;
+
+  const discovery = await fetchRegistry(
+    `${trustAnchorConfig.payload.sub}/.well-known/it-wallet-registry`,
+    {
+      schema: RegistryDiscoveryJwt,
+      jwks: trustAnchorJwks,
+      appFetch,
+    }
+  );
+  const { endpoints } = discovery.payload;
+
+  // Fetch registries necessary to build the full catalogue
+  const registries = await Promise.all([
+    fetchRegistry(endpoints.credential_catalog, {
+      schema: DigitalCredentialsCatalogueJwt,
+      jwks: trustAnchorJwks,
+      appFetch,
+    }),
+    fetchRegistry(endpoints.authentic_sources, {
+      schema: AuthenticSourceRegistry,
+      asJson: true,
+      appFetch,
+    }),
+    fetchRegistry(endpoints.schema_registry, {
+      schema: SchemaRegistry,
+      asJson: true,
+      appFetch,
+    }),
+  ]);
+
+  return mapToCredentialsCatalogue([discovery, ...registries]);
+};

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

@@ -0,0 +1,6 @@
+import type { CredentialsCatalogueApi } from "../api";
+import { fetchAndParseCatalogue } from "./fetch-and-parse-catalogue";
+
+export const CredentialsCatalogue: CredentialsCatalogueApi = {
+  fetchAndParseCatalogue,
+};

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

@@ -0,0 +1,75 @@
+import { assert } from "../../utils/misc";
+import { keyBy, groupBy } from "../../utils/object";
+import { createMapper } from "../../utils/mappers";
+import {
+  DigitalCredentialsCatalogue,
+  type CredentialFormat as ApiCredentialFormat,
+  type AuthenticSource as ApiAuthenticSource,
+} from "../api/DigitalCredentialsCatalogue";
+import {
+  AuthenticSourceRegistry,
+  DigitalCredentialsCatalogueJwt,
+  RegistryDiscoveryJwt,
+  SchemaRegistry,
+} from "./types";
+
+export const mapToCredentialsCatalogue = createMapper<
+  [
+    RegistryDiscoveryJwt,
+    DigitalCredentialsCatalogueJwt,
+    AuthenticSourceRegistry,
+    SchemaRegistry,
+  ],
+  DigitalCredentialsCatalogue
+>(
+  ([discoveryJwt, catalogueJwt, authSourceRegistry, schemaRegistry]) => {
+    const authSourcesById = keyBy(
+      authSourceRegistry.authentic_sources,
+      "entity_id"
+    );
+    const schemasByCredentialType = groupBy(
+      schemaRegistry.schemas,
+      "credential_type"
+    );
+
+    const resolveAuthSource = ({
+      id,
+    }: {
+      id: string;
+      dataset_id: string;
+    }): ApiAuthenticSource => {
+      const as = authSourcesById.get(id);
+      assert(as, `AS ${id} must be present in the Authentic Source Registry`);
+      const { ipa_code, ...rest } = as.organization_info;
+      return { id, organization_code: ipa_code, ...rest };
+    };
+
+    const resolveFormats = (credentialType: string): ApiCredentialFormat[] => {
+      const schemas = schemasByCredentialType.get(credentialType);
+      assert(
+        schemas,
+        `Schemas for ${credentialType} must be present in the Schema Registry`
+      );
+      return schemas.map((schema) => ({
+        configuration_id: schema.id, // TODO: [SIW-3978] Does schema ID corresponds to configuration_id?
+        ...schema,
+      }));
+    };
+
+    return {
+      ...catalogueJwt.payload,
+      taxonomy_uri: discoveryJwt.payload.endpoints.taxonomy,
+      credentials: catalogueJwt.payload.credentials.map(
+        ({ authentic_sources, credential_name, ...credential }) => ({
+          name: credential_name,
+          formats: resolveFormats(credential.credential_type),
+          authentic_sources: authentic_sources.map(resolveAuthSource),
+          ...credential,
+        })
+      ),
+    };
+  },
+  {
+    outputSchema: DigitalCredentialsCatalogue,
+  }
+);

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

@@ -0,0 +1,162 @@
+import * as z from "zod";
+import { UnixTime } from "../../utils/zod";
+
+const ASDataCapability = z.object({
+  dataset_id: z.string(),
+  domains: z.array(z.string()),
+  intended_purposes: z.array(z.string()),
+  available_claims: z.array(
+    z.object({
+      claim_name: z.string(),
+      order: z.number(),
+      mandatory: z.boolean(),
+    })
+  ),
+  user_information: z.string().optional(),
+});
+
+export const AuthenticSource = z.object({
+  entity_id: z.string(),
+  organization_info: z.object({
+    organization_name: z.string(),
+    organization_type: z.string(),
+    organization_country: z.string(),
+    ipa_code: z.string().optional(),
+    contacts: z.array(z.string()).optional(),
+    homepage_uri: z.string().optional(),
+    logo_uri: z.string().optional(),
+    policy_uri: z.string().optional(),
+  }),
+  data_capabilities: z.array(ASDataCapability),
+});
+export type AuthenticSource = z.infer<typeof AuthenticSource>;
+
+export const Schema = z.object({
+  id: z.string(),
+  version: z.string(),
+  credential_type: z.string(),
+  format: z.enum(["dc+sd-jwt", "mso_mdoc"]),
+  docType: z.string().optional(),
+  vct: z.string().optional(),
+  schema_uri: z.string(),
+  "schema_uri#integrity": z.string(),
+  description: z.string().optional(),
+});
+export type Schema = z.infer<typeof Schema>;
+
+const CredentialPurpose = z.object({
+  id: z.string(),
+  description: z.string(),
+  claims_required: z.array(z.string()),
+  claim_recommended: z.array(z.string()),
+});
+
+const CredentialIssuer = z.object({
+  id: z.string(),
+  organization_name: z.string(),
+  organization_code: z.string(),
+  organization_country: z.string(),
+  contacts: z.array(z.string()).optional(),
+  homepage_uri: z.string().optional(),
+  logo_uri: z.string().optional(),
+  policy_uri: z.string().optional(),
+  tos_uri: z.string().optional(),
+});
+
+export const DigitalCredential = z.object({
+  version: z.string(),
+  credential_type: z.string(),
+  credential_name: z.string(),
+  legal_type: z.string(),
+  description: z.string(),
+  validity_info: z.object({
+    max_validity_days: z.number(),
+    status_methods: z.array(z.string()),
+    allowed_states: z.array(z.string()),
+  }),
+  authentication: z.object({
+    user_auth_required: z.boolean(),
+    min_loa: z.string(),
+    supported_eid_schemes: z.array(z.string()),
+  }),
+  purposes: z.array(CredentialPurpose),
+  issuers: z.array(CredentialIssuer),
+  authentic_sources: z.array(
+    z.object({
+      id: z.string(),
+      dataset_id: z.string(),
+    })
+  ),
+});
+
+const JwtHeader = z.object({
+  typ: z.string(),
+  alg: z.string(),
+  kid: z.string(),
+  x5c: z.array(z.string()).optional(),
+});
+
+/**
+ * Schema registry, available at a dedicated endpoint.
+ * @see https://italia.github.io/eid-wallet-it-docs/releases/1.3.3/en/registry.html#schema-registry
+ */
+export const SchemaRegistry = z.object({
+  version: z.string(),
+  last_modified: z.string(),
+  schemas: z.array(Schema),
+});
+export type SchemaRegistry = z.infer<typeof SchemaRegistry>;
+
+/**
+ * Authentic Source registry, available at a dedicated endpoint.
+ * @see https://italia.github.io/eid-wallet-it-docs/releases/1.3.3/en/registry.html#authentic-source-registry
+ */
+export const AuthenticSourceRegistry = z.object({
+  version: z.string(),
+  last_modified: z.string(),
+  authentic_sources: z.array(AuthenticSource),
+});
+export type AuthenticSourceRegistry = z.infer<typeof AuthenticSourceRegistry>;
+
+/**
+ * The Digital Credentials Catalogue published by the Trust Anchor.
+ * @see https://italia.github.io/eid-wallet-it-docs/releases/1.3.3/en/registry.html#digital-credentials-catalog
+ */
+export const DigitalCredentialsCatalogueJwt = z.object({
+  header: JwtHeader,
+  payload: z.object({
+    version: z.string(),
+    last_modified: z.string(),
+    credentials: z.array(DigitalCredential),
+    iat: UnixTime,
+    exp: UnixTime,
+  }),
+});
+export type DigitalCredentialsCatalogueJwt = z.infer<
+  typeof DigitalCredentialsCatalogueJwt
+>;
+
+/**
+ * Registry discovery info, used to discover all the Registry Infrastructure endpoints.
+ * This is the entrypoint to build the full catalogue.
+ * @see https://italia.github.io/eid-wallet-it-docs/releases/1.3.3/en/registry.html#registry-discovery-endpoint
+ */
+export const RegistryDiscoveryJwt = z.object({
+  header: JwtHeader,
+  payload: z.object({
+    registry_version: z.string(),
+    last_updated: z.string(),
+    endpoints: z.object({
+      claims_registry: z.string(),
+      authentic_sources: z.string(),
+      credential_catalog: z.string(),
+      taxonomy: z.string(),
+      schema_registry: z.string(),
+      federation_list: z.string(),
+      federation_fetch: z.string(),
+      federation_resolve: z.string(),
+      federation_trust_mark_status: z.string(),
+    }),
+  }),
+});
+export type RegistryDiscoveryJwt = z.infer<typeof RegistryDiscoveryJwt>;

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

@@ -0,0 +1,64 @@
+import * as z from "zod";
+import { decode as decodeJwt, verify } from "@pagopa/io-react-native-jwt";
+import { assert, hasStatusOrThrow } from "../../utils/misc";
+import { IoWalletError } from "../../utils/errors";
+import type { JWK } from "../../utils/jwk";
+
+type FetchRegistryParams<T> = {
+  schema: z.ZodType<T>;
+  appFetch?: GlobalFetch["fetch"];
+} & ({ asJson: true } | { asJson?: false; jwks: JWK[] });
+
+/**
+ * Utility to fetch an entity from the Registry Infrastructure.
+ * The function supports both `application/json` and `application/jwt` responses.
+ * @see https://italia.github.io/eid-wallet-it-docs/releases/1.3.3/en/registry.html
+ *
+ * @param url The url to fetch from
+ * @param params.schema The Zod schema to validate the response
+ * @param params.jwks JWKS to validate JWT signature
+ * @param params.appFetch Custom fetch implementation
+ * @param params.asJson Request a response in simple JSON format (no JWT)
+ * @returns The parsed entity
+ */
+export const fetchRegistry = async <T>(
+  url: string,
+  params: FetchRegistryParams<T>
+): Promise<T> => {
+  const { schema, appFetch = fetch, asJson = false } = params;
+
+  const response = await appFetch(url, {
+    method: "GET",
+    headers: {
+      Accept: asJson ? "application/json" : "application/jwt",
+    },
+  }).then(hasStatusOrThrow(200));
+
+  const contentType = response.headers.get("Content-Type");
+
+  if (contentType?.includes("application/json")) {
+    const responseJson = await response.json();
+    return schema.parse(responseJson);
+  }
+
+  if (contentType?.includes("application/jwt")) {
+    assert("jwks" in params, "params.jwks required when response is JWT");
+
+    const responseText = await response.text();
+    const responseJwt = decodeJwt(responseText);
+    const headerKid = responseJwt.protectedHeader.kid;
+    const signatureJwk = params.jwks.find((jwk) => jwk.kid === headerKid);
+    if (!signatureJwk) {
+      throw new IoWalletError(
+        `Could not find JWK with kid ${headerKid} in Trust Anchor's Entity Configuration`
+      );
+    }
+    await verify(responseText, signatureJwk);
+    return schema.parse({
+      header: responseJwt.protectedHeader,
+      payload: responseJwt.payload,
+    });
+  }
+
+  throw new IoWalletError(`Unsupported content-type: ${contentType}`);
+};

package/src/index.ts

@@ -4,14 +4,17 @@ import { fixBase64EncodingOnKey } from "./utils/jwk";
 // https://github.com/facebook/react-native/issues/24428
 import "react-native-url-polyfill/auto";
 
-import * as Credential from "./credential";
+import * as Trust from "./trust";
 import * as CredentialsCatalogue from "./credentials-catalogue";
-import * as PID from "./pid";
+import * as CredentialIssuance from "./credential/issuance";
+import * as CredentialOffer from "./credential/offer";
+import * as CredentialStatus from "./credential/status";
+import * as RemotePresentation from "./credential/presentation";
+import * as Trustmark from "./credential/trustmark";
 import * as SdJwt from "./sd-jwt";
 import * as Mdoc from "./mdoc";
 import * as Errors from "./utils/errors";
 import * as WalletInstanceAttestation from "./wallet-instance-attestation";
-import * as Trust from "./trust";
 import * as WalletInstance from "./wallet-instance";
 import * as Logging from "./utils/logging";
 import { AuthorizationDetail, AuthorizationDetails } from "./utils/par";
@@ -19,15 +22,18 @@ import { createCryptoContextFor } from "./utils/crypto";
 import type { IntegrityContext } from "./utils/integrity";
 
 export {
+  Trust,
+  CredentialIssuance,
+  CredentialOffer,
+  CredentialsCatalogue,
+  CredentialStatus,
+  RemotePresentation,
   SdJwt,
   Mdoc,
-  PID,
-  Credential,
-  CredentialsCatalogue,
   WalletInstanceAttestation,
   WalletInstance,
+  Trustmark,
   Errors,
-  Trust,
   createCryptoContextFor,
   AuthorizationDetail,
   AuthorizationDetails,
@@ -36,3 +42,8 @@ export {
 };
 
 export type { IntegrityContext, AuthorizationContext };
+
+export type * from "./api";
+
+// Export SDK entrypoint
+export { IoWallet } from "./IoWallet";