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

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

@@ -2,8 +2,8 @@ import * as z from "zod";
 import { UnixTime } from "../../utils/zod";
 
 const ASDataCapability = z.object({
+  // required per spec
   dataset_id: z.string(),
-  domains: z.array(z.string()),
   intended_purposes: z.array(z.string()),
   available_claims: z.array(
     z.object({
@@ -12,20 +12,48 @@ const ASDataCapability = z.object({
       mandatory: z.boolean(),
     })
   ),
-  user_information: z.string().optional(),
+  domains: z.array(z.string()).optional(),
+  data_origin_l10n_id: z.string(),
+  integration_endpoint: z.string(),
+  integration_method: z.string(),
+  user_information_l10n_id: z.string(),
+  // optional per spec (api_specification required in spec but absent in actual responses)
+  api_specification: z.string().optional(),
+  background_color: z.string().optional(),
+  contacts: z.array(z.string()).optional(),
+  data_provision: z
+    .object({
+      deferred_flow: z.boolean(),
+      immediate_flow: z.boolean(),
+    })
+    .optional(),
+  logo_uri: z.string().optional(),
+  "logo_uri#integrity": z.string().optional(),
+  service_documentation: z.string().optional(),
+  update_frequency: z.string().optional(),
 });
 
 export const AuthenticSource = z.object({
   entity_id: z.string(),
   organization_info: z.object({
-    organization_name: z.string(),
+    // required per spec
+    organization_name_l10n_id: z.string(),
     organization_type: z.string(),
     organization_country: z.string(),
+    legal_identifier: z.string(),
+    homepage_uri: z.string(),
+    contacts: z.array(z.string()),
+    policy_uri: z.string(),
+    // conditional: required for public AS
     ipa_code: z.string().optional(),
-    contacts: z.array(z.string()).optional(),
-    homepage_uri: z.string().optional(),
+    // conditional: required for private AS
+    tos_uri: z.string().optional(),
+    // optional per spec
     logo_uri: z.string().optional(),
-    policy_uri: z.string().optional(),
+    "logo_uri#integrity": z.string().optional(),
+    logo_extended_uri: z.string().optional(),
+    "logo_extended_uri#integrity": z.string().optional(),
+    dpa_contact: z.string().optional(),
   }),
   data_capabilities: z.array(ASDataCapability),
 });
@@ -44,42 +72,65 @@ export const Schema = z.object({
 });
 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 AdministrativeExpirationUserInfo = z.object({
+  title_l10n_id: z.string(),
+  description_l10n_id: z.string(),
 });
 
+const AllowedState = z
+  .object({
+    title_l10n_id: z.string(),
+    description_l10n_id: z.string(),
+  })
+  .catchall(z.string());
+
 const CredentialIssuer = z.object({
   id: z.string(),
-  organization_name: z.string(),
+  organization_name_l10n_id: z.string(),
   organization_code: z.string(),
   organization_country: z.string(),
+  legal_type: z.string().optional(),
   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(),
+  service_documentation: z.string().optional(),
+  issuance_flows: z.object({ deferred_flow: z.boolean() }).optional(),
 });
 
 export const DigitalCredential = z.object({
   version: z.string(),
   credential_type: z.string(),
-  credential_name: z.string(),
+  credential_name_l10n_id: z.string(),
   legal_type: z.string(),
-  description: z.string(),
+  restriction_policy: z
+    .object({
+      allowed_wallet_ids: z.array(z.string()).optional(),
+      allowed_issuer_ids: z.array(z.string()).optional(),
+      presentation_flows: z.object({
+        remote: z.boolean(),
+        proximity: z.boolean(),
+      }),
+    })
+    .optional(),
   validity_info: z.object({
     max_validity_days: z.number(),
     status_methods: z.array(z.string()),
-    allowed_states: z.array(z.string()),
+    administrative_expiration_user_info:
+      AdministrativeExpirationUserInfo.optional(),
+    allowed_states: z.array(AllowedState),
   }),
+  administrative_expiration_user_info:
+    AdministrativeExpirationUserInfo.optional(),
   authentication: z.object({
     user_auth_required: z.boolean(),
     min_loa: z.string(),
-    supported_eid_schemes: z.array(z.string()),
+    supported_schemes: z.array(z.string()),
   }),
-  purposes: z.array(CredentialPurpose),
+  domains: z.array(z.string()).optional(),
+  classes: z.array(z.string()).optional(),
+  purposes: z.array(z.string()),
   issuers: z.array(CredentialIssuer),
   authentic_sources: z.array(
     z.object({
@@ -102,7 +153,8 @@ const JwtHeader = z.object({
  */
 export const SchemaRegistry = z.object({
   version: z.string(),
-  last_modified: z.string(),
+  last_modified: z.string().optional(),
+  last_updated: z.string().optional(),
   schemas: z.array(Schema),
 });
 export type SchemaRegistry = z.infer<typeof SchemaRegistry>;
@@ -112,8 +164,17 @@ export type SchemaRegistry = z.infer<typeof SchemaRegistry>;
  * @see https://italia.github.io/eid-wallet-it-docs/releases/1.3.3/en/registry.html#authentic-source-registry
  */
 export const AuthenticSourceRegistry = z.object({
+  id: z.string().optional(),
   version: z.string(),
   last_modified: z.string(),
+  localization: z
+    .object({
+      available_locales: z.array(z.string()),
+      base_uri: z.string(),
+      default_locale: z.string(),
+      version: z.string(),
+    })
+    .optional(),
   authentic_sources: z.array(AuthenticSource),
 });
 export type AuthenticSourceRegistry = z.infer<typeof AuthenticSourceRegistry>;
@@ -125,8 +186,18 @@ export type AuthenticSourceRegistry = z.infer<typeof AuthenticSourceRegistry>;
 export const DigitalCredentialsCatalogueJwt = z.object({
   header: JwtHeader,
   payload: z.object({
+    iss: z.string(),
+    id: z.string(),
     version: z.string(),
     last_modified: z.string(),
+    localization: z
+      .object({
+        available_locales: z.array(z.string()),
+        base_uri: z.string(),
+        default_locale: z.string(),
+        version: z.string(),
+      })
+      .optional(),
     credentials: z.array(DigitalCredential),
     iat: UnixTime,
     exp: UnixTime,
@@ -141,22 +212,24 @@ export type DigitalCredentialsCatalogueJwt = z.infer<
  * 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
  */
+const RegistryDiscoveryEndpoints = z.object({
+  claims_registry: z.string(),
+  authentic_sources: z.string(),
+  credential_catalog: z.string(),
+  taxonomy: z.string(),
+  schema_registry: z.string(),
+  federation_list_endpoint: z.string(),
+  federation_fetch_endpoint: z.string(),
+  federation_resolve_endpoint: z.string(),
+  federation_trust_mark_status_endpoint: z.string(),
+});
+
 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(),
-    }),
+    endpoints: RegistryDiscoveryEndpoints,
   }),
 });
 export type RegistryDiscoveryJwt = z.infer<typeof RegistryDiscoveryJwt>;

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

@@ -11,7 +11,7 @@ type FetchRegistryParams<T> = {
 
 /**
  * Utility to fetch an entity from the Registry Infrastructure.
- * The function supports both `application/json` and `application/jwt` responses.
+ * The function supports `application/json` and signed JOSE/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
@@ -30,7 +30,7 @@ export const fetchRegistry = async <T>(
   const response = await appFetch(url, {
     method: "GET",
     headers: {
-      Accept: asJson ? "application/json" : "application/jwt",
+      Accept: asJson ? "application/json" : "application/jose, application/jwt",
     },
   }).then(hasStatusOrThrow(200));
 
@@ -41,7 +41,10 @@ export const fetchRegistry = async <T>(
     return schema.parse(responseJson);
   }
 
-  if (contentType?.includes("application/jwt")) {
+  if (
+    contentType?.includes("application/jwt") ||
+    contentType?.includes("application/jose")
+  ) {
     assert("jwks" in params, "params.jwks required when response is JWT");
 
     const responseText = await response.text();
@@ -60,5 +63,40 @@ export const fetchRegistry = async <T>(
     });
   }
 
-  throw new IoWalletError(`Unsupported content-type: ${contentType}`);
+  throw new IoWalletError(
+    `Unsupported content-type for ${url}: ${contentType}`
+  );
+};
+
+/**
+ * Fetch a locale bundle file from the Registry Infrastructure.
+ * Bundle files are flat JSON objects mapping l10n_id keys to translated strings.
+ * @see https://italia.github.io/eid-wallet-it-docs/releases/1.3.3/en/registry.html
+ *
+ * @param baseUri The base URI from a registry's localization object
+ * @param locale The locale code (e.g. "it", "en")
+ * @param appFetch Custom fetch implementation
+ * @returns Flat key→value translation map
+ */
+export const fetchLocaleBundle = async (
+  baseUri: string,
+  locale: string,
+  appFetch: GlobalFetch["fetch"] = fetch
+): Promise<Record<string, string>> => {
+  const url = `${baseUri.replace(/\/$/, "")}/${locale}.json`;
+
+  const response = await appFetch(url, {
+    method: "GET",
+    headers: { Accept: "application/json" },
+  }).then(hasStatusOrThrow(200));
+
+  const contentType = response.headers.get("Content-Type");
+  if (!contentType?.includes("application/json")) {
+    throw new IoWalletError(
+      `Locale bundle at ${url} returned unexpected Content-Type: ${contentType}`
+    );
+  }
+
+  const responseJson = await response.json();
+  return z.record(z.string(), z.string()).parse(responseJson);
 };

package/src/index.ts

@@ -15,10 +15,14 @@ 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 WalletUnitAttestation from "./wallet-unit-attestation";
 import * as WalletInstance from "./wallet-instance";
 import * as Logging from "./utils/logging";
 import { AuthorizationDetail, AuthorizationDetails } from "./utils/par";
-import { createCryptoContextFor } from "./utils/crypto";
+import {
+  createCryptoContextFor,
+  type KeyAttestationCryptoContext,
+} from "./utils/crypto";
 import type { IntegrityContext } from "./utils/integrity";
 
 export {
@@ -31,6 +35,7 @@ export {
   SdJwt,
   Mdoc,
   WalletInstanceAttestation,
+  WalletUnitAttestation,
   WalletInstance,
   Trustmark,
   Errors,
@@ -41,7 +46,11 @@ export {
   Logging,
 };
 
-export type { IntegrityContext, AuthorizationContext };
+export type {
+  IntegrityContext,
+  AuthorizationContext,
+  KeyAttestationCryptoContext,
+};
 
 export type * from "./api";
 

package/src/trust/common/types.ts

@@ -50,7 +50,7 @@ export const FederationEntityMetadata = z
     logo_uri: z.string().optional(),
     contacts: z.array(z.string()).optional(),
   })
-  .passthrough();
+  .loose();
 
 // Structure common to every Entity Configuration document
 export type BaseEntityConfiguration = z.infer<typeof BaseEntityConfiguration>;
@@ -67,12 +67,12 @@ export const BaseEntityConfiguration = z.object({
         .object({
           federation_entity: FederationEntityMetadata,
         })
-        .passthrough(),
+        .loose(),
       jwks: z.object({
         keys: z.array(JWK),
       }),
     })
-    .passthrough(),
+    .loose(),
 });
 
 export const FederationListResponse = z.array(z.string());

package/src/trust/v1.0.0/types.ts

@@ -1,7 +1,7 @@
 import * as z from "zod";
+import { jsonWebKeySchema } from "@pagopa/io-wallet-oid-federation";
 import { JWK } from "../../utils/jwk";
 import { BaseEntityConfiguration } from "../common/types";
-import { jsonWebKeySchema } from "@openid-federation/core";
 
 const RelyingPartyMetadata = z.object({
   application_type: z.string().optional(),
@@ -65,7 +65,9 @@ const SupportedCredentialMetadata = z.intersection(
     cryptographic_binding_methods_supported: z.array(z.string()),
     credential_signing_alg_values_supported: z.array(z.string()),
     authentic_source: z.string().optional(),
-    issuance_errors_supported: z.record(IssuanceErrorSupported).optional(),
+    issuance_errors_supported: z
+      .record(z.string(), IssuanceErrorSupported)
+      .optional(),
   })
 );
 
@@ -92,6 +94,7 @@ export const CredentialIssuerEntityConfiguration = BaseEntityConfiguration.and(
           status_attestation_endpoint: z.string(),
           display: z.array(CredentialIssuerDisplayMetadata),
           credential_configurations_supported: z.record(
+            z.string(),
             SupportedCredentialMetadata
           ),
           jwks: z.object({ keys: z.array(JWK) }),
@@ -157,7 +160,7 @@ export const WalletProviderEntityConfiguration = BaseEntityConfiguration.and(
             ),
             jwks: z.object({ keys: z.array(JWK) }),
           })
-          .passthrough(),
+          .loose(),
       }),
     }),
   })
@@ -165,14 +168,11 @@ export const WalletProviderEntityConfiguration = BaseEntityConfiguration.and(
 
 // Maps any entity configuration by the union of every possible shapes
 export type EntityConfiguration = z.infer<typeof EntityConfiguration>;
-export const EntityConfiguration = z.union(
-  [
+export const EntityConfiguration = z
+  .union([
     WalletProviderEntityConfiguration,
     CredentialIssuerEntityConfiguration,
     TrustAnchorEntityConfiguration,
     RelyingPartyEntityConfiguration,
-  ],
-  {
-    description: "Any kind of Entity Configuration allowed in the ecosystem",
-  }
-);
+  ])
+  .describe("Any kind of Entity Configuration allowed in the ecosystem");

package/src/trust/v1.3.3/types.ts

@@ -56,13 +56,10 @@ export const WalletProviderEntityConfiguration = BaseEntityConfiguration.and(
 
 // Maps any entity configuration by the union of every possible shapes
 export type EntityConfiguration = z.infer<typeof EntityConfiguration>;
-export const EntityConfiguration = z.union(
-  [
+export const EntityConfiguration = z
+  .union([
     WalletProviderEntityConfiguration,
     CredentialIssuerEntityConfiguration,
     RelyingPartyEntityConfiguration,
-  ],
-  {
-    description: "Any kind of Entity Configuration allowed in the ecosystem",
-  }
-);
+  ])
+  .describe("Any kind of Entity Configuration allowed in the ecosystem");

package/src/utils/callbacks.ts

@@ -12,6 +12,12 @@ type PartialCallbackContext = Omit<
   "signJwt" | "clientAuthentication"
 >;
 
+// Fix incompatibility between ArrayBuffer types
+type DigestFixed = (
+  data: string | ArrayBuffer | ArrayBufferView,
+  algorithm?: string
+) => Uint8Array;
+
 /**
  * Shared callbacks with React Native implementations for use
  * in IO Wallet SDK. Callbacks not found here must be provided by the caller,
@@ -19,7 +25,7 @@ type PartialCallbackContext = Omit<
  */
 export const partialCallbacks: PartialCallbackContext = {
   generateRandom: generateRandomBytes,
-  hash: digest,
+  hash: digest as DigestFixed,
   encryptJwe: async ({ publicJwk, alg, enc, kid }, data) => ({
     // @ts-expect-error `alg` and `enc` are strings, but EncryptJwe expects specific string literals
     jwe: await new EncryptJwe(data, { alg, enc, kid }).encrypt(publicJwk),

package/src/utils/crypto.ts

@@ -90,3 +90,21 @@ export const getSigninJwkFromCert = (pemCert: string): JWK => {
     "Unable to find the signing key inside the PEM certificate"
   );
 };
+
+/**
+ * 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 }>;
+};

package/src/utils/dpop.ts

@@ -29,7 +29,7 @@ export const createDPopToken = async (
 export type DPoPPayload = z.infer<typeof DPoPPayload>;
 export const DPoPPayload = z.object({
   jti: z.string(),
-  htm: z.union([z.literal("POST"), z.literal("GET")]),
+  htm: z.enum(["POST", "GET"]),
   htu: z.string(),
   ath: z.string().optional(),
 });

package/src/utils/jwk.ts

@@ -20,7 +20,7 @@ export const JWK = z.object({
   /** JWK "kty" (Key Type) Parameter.
    * This attribute is required to discriminate the
    * type of EC/RSA algorithm */
-  kty: z.union([z.literal("RSA"), z.literal("EC")]),
+  kty: z.enum(["RSA", "EC"]),
   n: z.string().optional(),
   p: z.string().optional(),
   q: z.string().optional(),

package/src/utils/mappers.ts

@@ -33,8 +33,8 @@ export function createMapper<I, O>(
 export function createMapper<I, O>(
   mapper: (input: I) => O,
   config?: {
-    inputSchema?: z.ZodType<I>;
-    outputSchema: z.ZodType<O>;
+    inputSchema?: z.ZodType<I, any>;
+    outputSchema: z.ZodType<O, any>;
   }
 ) {
   if (!config) {

package/src/utils/zod.ts

@@ -11,7 +11,11 @@ type Literal = z.infer<typeof literalSchema>;
 type Json = Literal | { [key: string]: Json } | Json[];
 
 const jsonSchema: z.ZodType<Json> = z.lazy(() =>
-  z.union([literalSchema, z.array(jsonSchema), z.record(jsonSchema)])
+  z.union([
+    literalSchema,
+    z.array(jsonSchema),
+    z.record(z.string(), jsonSchema),
+  ])
 );
 
 export const json = () => jsonSchema;

package/src/wallet-instance-attestation/README.md

@@ -30,16 +30,19 @@ const { WALLET_PROVIDER_BASE_URL } = env; // Let's assume env is an object conta
  * WARNING: The integrity context must be the same used when creating the Wallet Instance with the same keytag.
  */
 const wallet = new IoWallet({ version: "1.0.0" });
-const issuedAttestation = await wallet.WalletInstanceAttestation.getAttestation({
-  wiaCryptoContext,
-  integrityContext,
-  walletProviderBaseUrl: WALLET_PROVIDER_BASE_URL,
-  appFetch,
-});
-// [
-//   { type: "wallet_instance_attestation", "format": "jwt", "attestation": "ey..." },
-//   { type: "wallet_instance_attestation", "format": "dc+sd-jwt", "attestation": "ey..." }
-// ]
+const issuedAttestation = await wallet.WalletInstanceAttestation.getAttestation(
+  {
+    walletProviderBaseUrl: WALLET_PROVIDER_BASE_URL,
+    walletSolutionId: "exampleId",
+    walletSolutionVersion: "1.2.3",
+  },
+  {
+    wiaCryptoContext,
+    integrityContext,
+    appFetch,
+  }
+);
+// [{ "format": "jwt", "attestation": "ey..." }, { "format": "dc+sd-jwt", "attestation": "ey..." }]
 return issuedAttestation;
 ```
 

package/src/wallet-instance-attestation/api/index.ts

@@ -1,24 +1,31 @@
 import type { CryptoContext } from "@pagopa/io-react-native-jwt";
 import type { IntegrityContext } from "../../utils/integrity";
-import type { DecodedAttestationJwt, WalletAttestation } from "./types";
+import type {
+  DecodedWalletInstanceAttestation,
+  WalletAttestation,
+  WalletAttestationRequestParams,
+} from "./types";
 
 export interface WalletInstanceAttestationApi {
   /**
    * Request a Wallet Instance Attestation (WIA) to the Wallet provider.
-   * The Wallet Attestation may be issued in different formats and components (Wallet App and Wallet Unit).
+   * The Wallet Instance Attestation may be issued in different formats.
    *
-   * @param params.wiaCryptoContext The key pair associated with the WIA. Will be use to prove the ownership of the attestation.
-   * @param params.appFetch (optional) Http client
-   * @param walletProviderBaseUrl Base url for the Wallet Provider
+   * @param requestParams Wallet Provider data for the Wallet Attestation request
+   * @param ctx.wiaCryptoContext The key pair associated with the WIA. Will be use to prove the ownership of the attestation.
+   * @param ctx.integrityContext The hardware key pair associated with the Wallet Instance
+   * @param ctx.appFetch (optional) Http client
    * @returns The retrieved Wallet Instance Attestation tokens
    * @throws {WalletProviderResponseError} with a specific code for more context
    */
-  getAttestation(ctx: {
-    wiaCryptoContext: CryptoContext;
-    integrityContext: IntegrityContext;
-    walletProviderBaseUrl: string;
-    appFetch?: GlobalFetch["fetch"];
-  }): Promise<WalletAttestation[]>;
+  getAttestation(
+    requestParams: WalletAttestationRequestParams,
+    ctx: {
+      wiaCryptoContext: CryptoContext;
+      integrityContext: IntegrityContext;
+      appFetch?: GlobalFetch["fetch"];
+    }
+  ): Promise<WalletAttestation[]>;
 
   /**
    * Decode a given JWT to get the parsed Wallet Instance Attestation object they define.
@@ -32,7 +39,7 @@ export interface WalletInstanceAttestationApi {
    * @throws A decoding error if the token doesn't resolve in a valid JWT
    * @throws A validation error if the provided data doesn't result in a valid Wallet Instance Attestation
    */
-  decode(token: string): DecodedAttestationJwt;
+  decode(token: string): DecodedWalletInstanceAttestation;
 
   /**
    * Verify a given JWT to get the parsed Wallet Instance Attestation object they define.
@@ -44,5 +51,5 @@ export interface WalletInstanceAttestationApi {
    * @throws A validation error if the provided data doesn't result in a valid Wallet Instance Attestation
    * @throws Invalid signature error if the token signature is not valid
    */
-  verify(token: string): Promise<DecodedAttestationJwt>;
+  verify(token: string): Promise<DecodedWalletInstanceAttestation>;
 }

package/src/wallet-instance-attestation/api/types.ts

@@ -3,23 +3,35 @@ import { UnixTime } from "../../utils/zod";
 import { JWK } from "../../utils/jwk";
 
 /**
- * Common Wallet Attestation shape. This object is
+ * Common Wallet Instance Attestation shape. This object is
  * an abstraction over the version-specific JWTs.
  */
-export type DecodedAttestationJwt = z.infer<typeof DecodedAttestationJwt>;
-export const DecodedAttestationJwt = z.object({
+export type DecodedWalletInstanceAttestation = z.infer<
+  typeof DecodedWalletInstanceAttestation
+>;
+export const DecodedWalletInstanceAttestation = z.object({
   iss: z.string(),
   iat: UnixTime,
   exp: UnixTime,
   cnf: z.object({ jwk: JWK }),
   sub: z.string(),
+  wallet_provider_name: z.string().optional(),
+  wallet_solution_id: z.string().optional(),
+  /** @deprecated */
   wallet_link: z.string().optional(),
+  /** @deprecated */
   wallet_name: z.string().optional(),
+  /** @deprecated */
   aal: z.string().optional(),
 });
 
 export type WalletAttestation = {
-  type: "wallet_instance_attestation" | "wallet_unit_attestation";
   format: string;
   attestation: string;
 };
+
+export type WalletAttestationRequestParams = {
+  walletProviderBaseUrl: string;
+  walletSolutionId: string;
+  walletSolutionVersion: string;
+};

package/src/wallet-instance-attestation/v1.0.0/index.ts

@@ -2,10 +2,10 @@ import type { WalletInstanceAttestationApi } from "../api";
 import { withMapper, withMapperAsync } from "../../utils/mappers";
 import { getAttestation } from "./issuing";
 import { decode, verify } from "./utils";
-import { mapToDecodedAttestationJwt } from "./mappers";
+import { mapToDecodedWalletInstanceAttestation } from "./mappers";
 
 export const WalletInstanceAttestation: WalletInstanceAttestationApi = {
   getAttestation,
-  decode: withMapper(mapToDecodedAttestationJwt, decode),
-  verify: withMapperAsync(mapToDecodedAttestationJwt, verify),
+  decode: withMapper(mapToDecodedWalletInstanceAttestation, decode),
+  verify: withMapperAsync(mapToDecodedWalletInstanceAttestation, verify),
 };