@pagopa/io-react-native-wallet 3.6.3 → 3.6.4

package/src/credential/issuance/v1.3.3/05-obtain-credential.ts

@@ -1,16 +1,24 @@
 import { type CryptoContext, SignJWT } from "@pagopa/io-react-native-jwt";
 import {
-  createTokenDPoP,
   type CallbackContext,
+  createTokenDPoP,
   type JwtSignerJwk,
 } from "@pagopa/io-wallet-oauth2";
 import {
-  fetchCredentialResponse,
   createCredentialRequest,
+  fetchCredentialResponse,
 } from "@pagopa/io-wallet-oid4vci";
 import { UnexpectedStatusCodeError as SdkUnexpectedStatusCodeError } from "@pagopa/io-wallet-utils";
 import { v4 as uuidv4 } from "uuid";
-import { hasStatusOrThrow, type Out } from "../../../utils/misc";
+
+import type { IssuanceApi, IssuerConfig } from "../api";
+import type { AuthorizeAccessApi } from "../api/04-authorize-access";
+
+import {
+  createSignJwtFromCryptoContext,
+  partialCallbacks,
+} from "../../../utils/callbacks";
+import { sdkConfigV1_3 } from "../../../utils/config";
 import {
   IoWalletError,
   IssuerResponseError,
@@ -18,26 +26,20 @@ import {
   ResponseErrorBuilder,
   ValidationFailed,
 } from "../../../utils/errors";
-import { LogLevel, Logger } from "../../../utils/logging";
-import { sdkConfigV1_3 } from "../../../utils/config";
-import {
-  createSignJwtFromCryptoContext,
-  partialCallbacks,
-} from "../../../utils/callbacks";
-import type { IssuanceApi, IssuerConfig } from "../api";
+import { Logger, LogLevel } from "../../../utils/logging";
+import { hasStatusOrThrow, type Out } from "../../../utils/misc";
 import { NonceResponse } from "./types";
-import type { AuthorizeAccessApi } from "../api/04-authorize-access";
 
-type CreateRequestParams = {
+interface CreateRequestParams {
+  accessToken: Out<AuthorizeAccessApi["authorizeAccess"]>["accessToken"];
+  appFetch?: GlobalFetch["fetch"];
   clientId: string;
+  credentialCryptoContexts: CryptoContext[];
   credentialIdentifier: string;
-  accessToken: Out<AuthorizeAccessApi["authorizeAccess"]>["accessToken"];
-  issuerConf: IssuerConfig;
   dPopCryptoContext: CryptoContext;
-  credentialCryptoContexts: CryptoContext[];
+  issuerConf: IssuerConfig;
   keyAttestationJwt: string;
-  appFetch?: GlobalFetch["fetch"];
-};
+}
 
 /**
  * Helper to create a credential request and fetch it from the issuer.
@@ -47,18 +49,18 @@ type CreateRequestParams = {
  * @returns The raw credential response
  */
 export const requestCredentials = async ({
-  issuerConf,
   accessToken,
-  credentialIdentifier,
+  appFetch = fetch,
   clientId,
-  keyAttestationJwt,
   credentialCryptoContexts,
+  credentialIdentifier,
   dPopCryptoContext,
-  appFetch = fetch,
+  issuerConf,
+  keyAttestationJwt,
 }: CreateRequestParams) => {
   const { c_nonce } = await appFetch(issuerConf.nonce_endpoint, {
-    method: "POST",
     headers: { "Content-Type": "application/json" },
+    method: "POST",
   })
     .then(hasStatusOrThrow(200))
     .then((res) => res.json())
@@ -67,13 +69,13 @@ export const requestCredentials = async ({
   const keys = await Promise.all(
     credentialCryptoContexts.map(async (ctx) => {
       const publicJwk = await ctx.getPublicKey();
-      return { publicJwk, cryptoContext: ctx };
-    })
+      return { cryptoContext: ctx, publicJwk };
+    }),
   );
 
   const signJwt: CallbackContext["signJwt"] = async (
     jwtSigner,
-    { header, payload }
+    { header, payload },
   ) => {
     if (jwtSigner.method !== "jwk") {
       throw new IoWalletError(`Unsupported signer method: ${jwtSigner.method}`);
@@ -85,7 +87,7 @@ export const requestCredentials = async ({
 
     if (!cryptoContext) {
       throw new IoWalletError(
-        `Could not find CryptoContext for key ${jwtSigner.publicJwk.kid}`
+        `Could not find CryptoContext for key ${jwtSigner.publicJwk.kid}`,
       );
     }
 
@@ -105,45 +107,45 @@ export const requestCredentials = async ({
   }));
 
   const credentialRequest = await createCredentialRequest({
-    config: sdkConfigV1_3,
     callbacks: {
       hash: partialCallbacks.hash,
       signJwt,
     },
     clientId,
+    config: sdkConfigV1_3,
     credential_identifier: credentialIdentifier,
     issuerIdentifier: issuerConf.credential_endpoint,
+    keyAttestation: keyAttestationJwt,
     maxBatchSize: issuerConf.credential_issuance_batch_size,
     nonce: c_nonce,
-    keyAttestation: keyAttestationJwt,
     signers,
   });
 
   const credentialDPoP = await createTokenDPoP({
+    accessToken: accessToken.access_token,
     callbacks: {
       ...partialCallbacks,
       signJwt: createSignJwtFromCryptoContext(dPopCryptoContext),
     },
+    jti: uuidv4(),
     signer: {
-      method: "jwk",
       alg: "ES256",
+      method: "jwk",
       publicJwk: await dPopCryptoContext.getPublicKey(),
     },
-    jti: uuidv4(),
     tokenRequest: {
       method: "POST",
       url: issuerConf.credential_endpoint,
     },
-    accessToken: accessToken.access_token,
   });
 
   return await fetchCredentialResponse({
+    accessToken: accessToken.access_token,
     callbacks: {
       fetch: appFetch,
     },
     credentialEndpoint: issuerConf.credential_endpoint,
     credentialRequest: credentialRequest,
-    accessToken: accessToken.access_token,
     dPoP: credentialDPoP.jwt,
   }).catch(handleObtainCredentialError);
 };
@@ -153,13 +155,13 @@ export const obtainCredential: IssuanceApi["obtainCredential"] = async (
   accessToken,
   clientId,
   credentialDefinition,
-  context
+  context,
 ) => {
   const {
+    appFetch = fetch,
     credentialCryptoContext,
     dPopCryptoContext,
     walletUnitAttestation,
-    appFetch = fetch,
   } = context;
   if (!walletUnitAttestation) {
     throw new ValidationFailed({
@@ -177,13 +179,13 @@ export const obtainCredential: IssuanceApi["obtainCredential"] = async (
       c.credential_configuration_id === credential_configuration_id &&
       (credential_identifier
         ? c.credential_identifiers.includes(credential_identifier)
-        : true)
+        : true),
   );
 
   if (!containsCredentialDefinition) {
     Logger.log(
       LogLevel.ERROR,
-      `Credential definition not found in the access token response ${accessToken.authorization_details}`
+      `Credential definition not found in the access token response ${accessToken.authorization_details}`,
     );
     throw new ValidationFailed({
       message:
@@ -192,19 +194,20 @@ export const obtainCredential: IssuanceApi["obtainCredential"] = async (
   }
 
   const credentialRes = await requestCredentials({
-    issuerConf,
     accessToken,
+    appFetch,
     clientId,
     credentialCryptoContexts: [credentialCryptoContext],
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- value validated as defined above
     credentialIdentifier: credential_identifier!,
     dPopCryptoContext,
+    issuerConf,
     keyAttestationJwt: walletUnitAttestation,
-    appFetch,
   });
 
   Logger.log(
     LogLevel.DEBUG,
-    `Credential Response: ${JSON.stringify(credentialRes)}`
+    `Credential Response: ${JSON.stringify(credentialRes)}`,
   );
 
   // Extract the format corresponding to the credential_configuration_id used
@@ -217,7 +220,9 @@ export const obtainCredential: IssuanceApi["obtainCredential"] = async (
 
   // TODO: [SIW-2264] Handle multiple credentials
   return {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- value validated as defined above
     credential: credentialRes.credentials.at(0)!.credential,
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- value validated as defined above
     format: issuerCredentialConfig!.format,
   };
 };
@@ -225,10 +230,10 @@ export const obtainCredential: IssuanceApi["obtainCredential"] = async (
 export const obtainCredentialsBatch: IssuanceApi["obtainCredentialsBatch"] =
   async (issuerConf, accessToken, clientId, credentialDefinition, context) => {
     const {
+      appFetch = fetch,
       credentialCryptoContexts,
       dPopCryptoContext,
       walletUnitAttestation,
-      appFetch = fetch,
     } = context;
     if (!walletUnitAttestation) {
       throw new ValidationFailed({
@@ -241,14 +246,14 @@ export const obtainCredentialsBatch: IssuanceApi["obtainCredentialsBatch"] =
       credentialDefinition;
 
     const credentialRes = await requestCredentials({
-      issuerConf,
       accessToken,
+      appFetch,
       clientId,
       credentialCryptoContexts,
       credentialIdentifier: credential_identifier,
       dPopCryptoContext,
+      issuerConf,
       keyAttestationJwt: walletUnitAttestation,
-      appFetch,
     });
 
     // Extract the format corresponding to the credential_configuration_id used
@@ -263,12 +268,13 @@ export const obtainCredentialsBatch: IssuanceApi["obtainCredentialsBatch"] =
 
     if (credentialRes.credentials.length !== credentialCryptoContexts.length) {
       throw new IoWalletError(
-        `Batch size mismatch: expected ${credentialCryptoContexts.length} credentials, but got ${credentialRes.credentials.length}`
+        `Batch size mismatch: expected ${credentialCryptoContexts.length} credentials, but got ${credentialRes.credentials.length}`,
       );
     }
 
     return credentialRes.credentials.map(({ credential }) => ({
       credential,
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- value validated as defined above
       format: issuerCredentialConfig!.format,
     }));
   };

package/src/credential/issuance/v1.3.3/06-verify-and-parse-credential.ts

@@ -1,6 +1,7 @@
+import type { IssuanceApi } from "../api";
+
 import { IoWalletError } from "../../../utils/errors";
 import { Logger, LogLevel } from "../../../utils/logging";
-import type { IssuanceApi } from "../api";
 import { verifyAndParseCredentialMDoc } from "../common/06-verify-and-parse-credential.mdoc";
 import { verifyAndParseCredentialSdJwt } from "../common/06-verify-and-parse-credential.sdjwt";
 
@@ -10,7 +11,7 @@ export const verifyAndParseCredential: IssuanceApi["verifyAndParseCredential"] =
     credential,
     credentialConfigurationId,
     context,
-    x509CertRoot
+    x509CertRoot,
   ) => {
     const format =
       issuerConf.credential_configurations_supported[credentialConfigurationId]
@@ -24,7 +25,7 @@ export const verifyAndParseCredential: IssuanceApi["verifyAndParseCredential"] =
           credential,
           credentialConfigurationId,
           { validateCertificateChain: true, ...context },
-          x509CertRoot
+          x509CertRoot,
         );
       }
       case "mso_mdoc": {
@@ -34,7 +35,7 @@ export const verifyAndParseCredential: IssuanceApi["verifyAndParseCredential"] =
           credential,
           credentialConfigurationId,
           context,
-          x509CertRoot
+          x509CertRoot,
         );
       }
 

package/src/credential/issuance/v1.3.3/index.ts

@@ -1,12 +1,14 @@
 import type { IssuanceApi } from "../api";
+
+import { MRTDPoPv1_3 } from "../mrtd-pop";
 import { evaluateIssuerTrust } from "./01-evaluate-issuer-trust";
 import { startUserAuthorization } from "./02-start-user-authorization";
 import {
-  continueUserAuthorizationWithMRTDPoPChallenge,
-  completePidUserAuthorizationWithQueryMode,
+  buildAuthorizationUrl,
   completeEaaUserAuthorizationWithQueryMode,
+  completePidUserAuthorizationWithQueryMode,
   completeUserAuthorizationWithFormPostJwtMode,
-  buildAuthorizationUrl,
+  continueUserAuthorizationWithMRTDPoPChallenge,
   getRequestedCredentialToBePresented,
 } from "./03-complete-user-authorization";
 import { authorizeAccess } from "./04-authorize-access";
@@ -15,20 +17,19 @@ import {
   obtainCredentialsBatch,
 } from "./05-obtain-credential";
 import { verifyAndParseCredential } from "./06-verify-and-parse-credential";
-import { MRTDPoPv1_3 } from "../mrtd-pop";
 
 export const Issuance: IssuanceApi = {
-  evaluateIssuerTrust,
-  startUserAuthorization,
+  authorizeAccess,
   buildAuthorizationUrl,
-  completePidUserAuthorizationWithQueryMode,
   completeEaaUserAuthorizationWithQueryMode,
+  completePidUserAuthorizationWithQueryMode,
+  completeUserAuthorizationWithFormPostJwtMode,
   continueUserAuthorizationWithMRTDPoPChallenge,
+  evaluateIssuerTrust,
   getRequestedCredentialToBePresented,
-  completeUserAuthorizationWithFormPostJwtMode,
-  authorizeAccess,
+  MRTDPoP: MRTDPoPv1_3,
   obtainCredential,
   obtainCredentialsBatch,
+  startUserAuthorization,
   verifyAndParseCredential,
-  MRTDPoP: MRTDPoPv1_3,
 };

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

@@ -1,9 +1,11 @@
 import type { MetadataResponseV1_4 } from "@pagopa/io-wallet-oid4vci";
 import type { ParsedAuthorizeRequestResult } from "@pagopa/io-wallet-oid4vp";
-import { assert } from "../../../utils/misc";
-import { createMapper } from "../../../utils/mappers";
-import type { JWK } from "../../../utils/jwk";
+
 import type { RequestObject } from "../../../credential/presentation";
+import type { JWK } from "../../../utils/jwk";
+
+import { createMapper } from "../../../utils/mappers";
+import { assert } from "../../../utils/misc";
 import { IssuerConfig } from "../api/IssuerConfig";
 
 type CredentialConfigurations =
@@ -12,25 +14,26 @@ type OpenIdCredentialIssuer =
   MetadataResponseV1_4["metadata"]["openid_credential_issuer"];
 
 const mapCredentialConfigurationsSupported = (
-  oidIssuer: NonNullable<OpenIdCredentialIssuer>
+  oidIssuer: NonNullable<OpenIdCredentialIssuer>,
 ): CredentialConfigurations =>
   Object.entries(oidIssuer.credential_configurations_supported).reduce(
     (acc, [key, config]) => {
       acc[key] = {
         ...(config.format === "dc+sd-jwt"
           ? { format: config.format, vct: config.vct }
-          : { format: config.format, doctype: config.doctype }),
-        scope: config.scope,
-        display: config.credential_metadata.display!,
+          : { doctype: config.doctype, format: config.format }),
         claims:
           config.credential_metadata.claims?.map((claim) => ({
-            path: claim.path,
             display: claim.display,
+            path: claim.path,
           })) ?? [],
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- value validated as defined above
+        display: config.credential_metadata.display!,
+        scope: config.scope,
       };
       return acc;
     },
-    {} as CredentialConfigurations
+    {} as CredentialConfigurations,
   );
 
 export const mapToIssuerConfig = createMapper<
@@ -39,10 +42,10 @@ export const mapToIssuerConfig = createMapper<
 >(
   (x) => {
     const {
+      federation_entity,
       oauth_authorization_server,
       openid_credential_issuer,
       openid_credential_verifier,
-      federation_entity,
     } = x.metadata;
 
     // The Issuer's own `oauth_authorization_server` always describes the Issuer
@@ -56,37 +59,37 @@ export const mapToIssuerConfig = createMapper<
 
     assert(
       oauthAuthorizationServer,
-      "oauth_authorization_server is required in Issuer metadata"
+      "oauth_authorization_server is required in Issuer metadata",
     );
     assert(
       openid_credential_issuer,
-      "openid_credential_issuer is required in Issuer metadata"
+      "openid_credential_issuer is required in Issuer metadata",
     );
 
     return {
       authorization_endpoint: oauthAuthorizationServer.authorization_endpoint,
-      credential_endpoint: openid_credential_issuer.credential_endpoint,
-      credential_issuer: openid_credential_issuer.credential_issuer,
       authorization_servers: openid_credential_issuer.authorization_servers,
       credential_configurations_supported: mapCredentialConfigurationsSupported(
-        openid_credential_issuer
+        openid_credential_issuer,
       ),
+      credential_endpoint: openid_credential_issuer.credential_endpoint,
+      credential_issuance_batch_size:
+        openid_credential_issuer.batch_credential_issuance?.batch_size,
+      credential_issuer: openid_credential_issuer.credential_issuer,
+      encrypted_response_enc_values_supported:
+        openid_credential_verifier?.encrypted_response_enc_values_supported,
+      federation_entity: federation_entity ?? {},
       keys: [
         ...openid_credential_issuer.jwks.keys,
         ...oauthAuthorizationServer.jwks.keys,
       ] as JWK[],
+      nonce_endpoint: openid_credential_issuer.nonce_endpoint ?? "",
       pushed_authorization_request_endpoint:
         oauthAuthorizationServer.pushed_authorization_request_endpoint,
       token_endpoint: oauthAuthorizationServer.token_endpoint,
-      nonce_endpoint: openid_credential_issuer.nonce_endpoint ?? "",
-      federation_entity: federation_entity ?? {},
-      credential_issuance_batch_size:
-        openid_credential_issuer.batch_credential_issuance?.batch_size,
-      encrypted_response_enc_values_supported:
-        openid_credential_verifier?.encrypted_response_enc_values_supported,
     };
   },
-  { outputSchema: IssuerConfig } // Output validation for extra-safety
+  { outputSchema: IssuerConfig }, // Output validation for extra-safety
 );
 
 export const mapToRequestObject = createMapper<

package/src/credential/offer/api/01-resolve-credential-offer.ts

@@ -18,6 +18,6 @@ export interface ResolveCredentialOfferApi {
    */
   resolveCredentialOffer(
     credentialOffer: string,
-    callbacks?: { fetch?: GlobalFetch["fetch"] }
+    callbacks?: { fetch?: GlobalFetch["fetch"] },
   ): Promise<CredentialOffer>;
 }

package/src/credential/offer/api/03-validate-credential-offer.ts

@@ -1,4 +1,5 @@
 import type { ValidateCredentialOfferOptions } from "@pagopa/io-wallet-oid4vci";
+
 import type { CredentialOffer } from "./types";
 
 export interface ValidateCredentialOfferApi {
@@ -13,7 +14,7 @@ export interface ValidateCredentialOfferApi {
    * @throws {InvalidCredentialOfferError} If the Credential Offer fails validation.
    */
   validateCredentialOffer(options: {
-    offer: CredentialOffer;
     credentialIssuerMetadata: ValidateCredentialOfferOptions["credentialIssuerMetadata"];
+    offer: CredentialOffer;
   }): Promise<void>;
 }

package/src/credential/offer/api/index.ts

@@ -3,8 +3,8 @@ import type { ExtractGrantDetailsApi } from "./02-extract-grant-details";
 import type { ValidateCredentialOfferApi } from "./03-validate-credential-offer";
 
 export interface OfferApi
-  extends ResolveCredentialOfferApi,
-    ExtractGrantDetailsApi,
+  extends ExtractGrantDetailsApi,
+    ResolveCredentialOfferApi,
     ValidateCredentialOfferApi {}
 
 export * from "./types";

package/src/credential/offer/common/errors.ts

@@ -2,16 +2,8 @@ import { IoWalletError } from "../../../utils/errors";
 
 export class InvalidCredentialOfferError extends IoWalletError {
   code = "ERR_INVALID_CREDENTIAL_OFFER";
-
-  constructor(message?: string) {
-    super(message);
-  }
 }
 
 export class InvalidQRCodeError extends IoWalletError {
   code = "ERR_INVALID_QR_CODE";
-
-  constructor(message?: string) {
-    super(message);
-  }
 }

package/src/credential/offer/v1.0.0/index.ts

@@ -1,13 +1,14 @@
-import { UnimplementedFeatureError } from "../../../utils/errors";
 import type { OfferApi } from "../api";
 
+import { UnimplementedFeatureError } from "../../../utils/errors";
+
 export const Offer: OfferApi = {
-  async resolveCredentialOffer() {
-    throw new UnimplementedFeatureError("resolveCredentialOffer", "1.0.0");
-  },
   extractGrantDetails() {
     throw new UnimplementedFeatureError("extractGrantDetails", "1.0.0");
   },
+  async resolveCredentialOffer() {
+    throw new UnimplementedFeatureError("resolveCredentialOffer", "1.0.0");
+  },
   validateCredentialOffer() {
     throw new UnimplementedFeatureError("validateCredentialOffer", "1.0.0");
   },

package/src/credential/offer/v1.3.3/01-resolve-credential-offer.ts

@@ -1,10 +1,12 @@
 import {
-  resolveCredentialOffer as sdkResolveCredentialOffer,
   CredentialOfferError,
+  resolveCredentialOffer as sdkResolveCredentialOffer,
 } from "@pagopa/io-wallet-oid4vci";
-import { InvalidQRCodeError } from "../common/errors";
+
 import type { OfferApi } from "../api";
+
 import { sdkConfigV1_3 } from "../../../utils/config";
+import { InvalidQRCodeError } from "../common/errors";
 
 /**
  * v1.3.3 implementation — first step of the User Request Flow
@@ -28,9 +30,9 @@ export const resolveCredentialOffer: OfferApi["resolveCredentialOffer"] =
 
     // Parse the URI and fetch the offer when transmitted by reference
     const resolved = await sdkResolveCredentialOffer({
+      callbacks: { fetch: fetchFn },
       config: sdkConfigV1_3,
       credentialOffer,
-      callbacks: { fetch: fetchFn },
     }).catch((e: unknown) => {
       if (e instanceof CredentialOfferError) {
         throw new InvalidQRCodeError(e.message);

package/src/credential/offer/v1.3.3/02-extract-grant-details.ts

@@ -1,11 +1,13 @@
 import {
-  extractGrantDetails as sdkExtractGrantDetails,
   CredentialOfferError,
+  extractGrantDetails as sdkExtractGrantDetails,
 } from "@pagopa/io-wallet-oid4vci";
-import { InvalidCredentialOfferError } from "../common/errors";
-import { withMappedErrors } from "../../../utils/errors";
+
 import type { OfferApi } from "../api";
+
 import { sdkConfigV1_3 } from "../../../utils/config";
+import { withMappedErrors } from "../../../utils/errors";
+import { InvalidCredentialOfferError } from "../common/errors";
 
 /**
  * v1.3.3 implementation — second and final step of the User Request Flow
@@ -28,5 +30,5 @@ export const extractGrantDetails: OfferApi["extractGrantDetails"] = (offer) =>
         credentialOffer: offer,
       }),
     CredentialOfferError,
-    (e) => new InvalidCredentialOfferError(e.message)
+    (e) => new InvalidCredentialOfferError(e.message),
   );

package/src/credential/offer/v1.3.3/03-validate-credential-offer.ts

@@ -1,10 +1,12 @@
 import {
-  validateCredentialOffer as sdkValidateCredentialOffer,
   CredentialOfferError,
+  validateCredentialOffer as sdkValidateCredentialOffer,
 } from "@pagopa/io-wallet-oid4vci";
-import { InvalidCredentialOfferError } from "../common/errors";
+
 import type { OfferApi } from "../api";
+
 import { sdkConfigV1_3 } from "../../../utils/config";
+import { InvalidCredentialOfferError } from "../common/errors";
 
 /**
  * v1.3.3 implementation — validates a resolved Credential Offer against the
@@ -19,11 +21,11 @@ import { sdkConfigV1_3 } from "../../../utils/config";
  * are mapped to {@link InvalidCredentialOfferError}.
  */
 export const validateCredentialOffer: OfferApi["validateCredentialOffer"] =
-  async ({ offer, credentialIssuerMetadata }) => {
+  async ({ credentialIssuerMetadata, offer }) => {
     await sdkValidateCredentialOffer({
       config: sdkConfigV1_3,
-      credentialOffer: offer,
       credentialIssuerMetadata,
+      credentialOffer: offer,
     }).catch((e: unknown) => {
       if (e instanceof CredentialOfferError) {
         throw new InvalidCredentialOfferError(e.message);

package/src/credential/offer/v1.3.3/index.ts

@@ -1,10 +1,11 @@
 import type { OfferApi } from "../api";
+
 import { resolveCredentialOffer } from "./01-resolve-credential-offer";
 import { extractGrantDetails } from "./02-extract-grant-details";
 import { validateCredentialOffer } from "./03-validate-credential-offer";
 
 export const Offer: OfferApi = {
-  resolveCredentialOffer,
   extractGrantDetails,
+  resolveCredentialOffer,
   validateCredentialOffer,
 };

package/src/credential/presentation/api/01-start-flow.ts

@@ -1,9 +1,5 @@
 import type { PresentationParams } from "./types";
 
-type NullablePresentationParams = {
-  [K in keyof PresentationParams]?: PresentationParams[K] | null;
-};
-
 export interface StartFlowApi {
   /**
    * Start a presentation flow by validating the required parameters.
@@ -16,3 +12,7 @@ export interface StartFlowApi {
    */
   startFlowFromQR(params: NullablePresentationParams): PresentationParams;
 }
+
+type NullablePresentationParams = {
+  [K in keyof PresentationParams]?: null | PresentationParams[K];
+};

package/src/credential/presentation/api/02-evaluate-rp-trust.ts

@@ -12,7 +12,7 @@ export interface EvaluateRelyingPartyTrustApi {
    */
   evaluateRelyingPartyTrust(
     rpUrl: string,
-    ctx?: { appFetch?: GlobalFetch["fetch"] }
+    ctx?: { appFetch?: GlobalFetch["fetch"] },
   ): Promise<{
     rpConf: RelyingPartyConfig;
   }>;

package/src/credential/presentation/api/03-get-request-object.ts

@@ -15,6 +15,6 @@ export interface GetRequestObjectApi {
     context?: {
       appFetch?: GlobalFetch["fetch"];
       walletCapabilities?: RequestObjectWalletCapabilities;
-    }
+    },
   ): Promise<{ requestObjectEncodedJwt: string }>;
 }

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

@@ -22,6 +22,6 @@ export interface VerifyAuthRequestCertificateChainApi {
     requestObjectJwt: string,
     params: {
       caRootCert: string;
-    }
+    },
   ): Promise<CertificateValidationResult>;
 }