@sphereon/ssi-sdk.oid4vci-holder 0.32.1-feature.IATAB2B.52.190 → 0.32.1-feature.MWALL.715.120

package/src/machines/firstPartyMachine.ts

@@ -1,17 +1,8 @@
 import { assign, createMachine, DoneInvokeEvent, interpret } from 'xstate'
-import {
-  AuthorizationChallengeCodeResponse,
-  AuthorizationChallengeError,
-  AuthorizationChallengeErrorResponse
-} from '@sphereon/oid4vci-common'
+import { AuthorizationChallengeCodeResponse, AuthorizationChallengeError, AuthorizationChallengeErrorResponse } from '@sphereon/oid4vci-common'
 import { DidAuthConfig } from '@sphereon/ssi-sdk.data-store'
 import { CreateConfigResult } from '@sphereon/ssi-sdk.siopv2-oid4vp-op-auth'
-import {
-  createConfig,
-  getSiopRequest,
-  sendAuthorizationChallengeRequest,
-  sendAuthorizationResponse
-} from '../services/FirstPartyMachineServices'
+import { createConfig, getSiopRequest, sendAuthorizationChallengeRequest, sendAuthorizationResponse } from '../services/FirstPartyMachineServices'
 import { translate } from '../localization/Localization'
 import { ErrorDetails } from '../types/IOID4VCIHolder'
 import {
@@ -31,7 +22,7 @@ import {
   InstanceFirstPartyMachineOpts,
   SiopV2AuthorizationRequestData,
   SendAuthorizationResponseArgs,
-  FirstPartySelectCredentialsEvent
+  FirstPartySelectCredentialsEvent,
 } from '../types/FirstPartyMachine'
 
 const firstPartyMachineStates: FirstPartyMachineStatesConfig = {
@@ -42,16 +33,18 @@ const firstPartyMachineStates: FirstPartyMachineStatesConfig = {
       onDone: {
         target: FirstPartyMachineStateTypes.done,
         actions: assign({
-          authorizationCodeResponse: (_ctx: FirstPartyMachineContext, _event: DoneInvokeEvent<AuthorizationChallengeCodeResponse>) => _event.data
-        })
+          authorizationCodeResponse: (_ctx: FirstPartyMachineContext, _event: DoneInvokeEvent<AuthorizationChallengeCodeResponse>) => _event.data,
+        }),
       },
       onError: [
         {
           target: FirstPartyMachineStateTypes.createConfig,
-          cond: (_ctx: FirstPartyMachineContext, _event: DoneInvokeEvent<AuthorizationChallengeErrorResponse>): boolean => _event.data.error === AuthorizationChallengeError.insufficient_authorization,
+          cond: (_ctx: FirstPartyMachineContext, _event: DoneInvokeEvent<AuthorizationChallengeErrorResponse>): boolean =>
+            _event.data.error === AuthorizationChallengeError.insufficient_authorization,
           actions: assign({
             authSession: (_ctx: FirstPartyMachineContext, _event: DoneInvokeEvent<AuthorizationChallengeErrorResponse>) => _event.data.auth_session,
-            presentationUri: (_ctx: FirstPartyMachineContext, _event: DoneInvokeEvent<AuthorizationChallengeErrorResponse>) => _event.data.presentation,
+            presentationUri: (_ctx: FirstPartyMachineContext, _event: DoneInvokeEvent<AuthorizationChallengeErrorResponse>) =>
+              _event.data.presentation,
           }),
         },
         {
@@ -63,9 +56,9 @@ const firstPartyMachineStates: FirstPartyMachineStatesConfig = {
               stack: _event.data.stack,
             }),
           }),
-        }
+        },
       ],
-    }
+    },
   },
   [FirstPartyMachineStateTypes.createConfig]: {
     id: FirstPartyMachineStateTypes.createConfig,
@@ -115,7 +108,7 @@ const firstPartyMachineStates: FirstPartyMachineStatesConfig = {
     id: FirstPartyMachineStateTypes.selectCredentials,
     on: {
       [FirstPartyMachineEvents.SET_SELECTED_CREDENTIALS]: {
-        actions: assign({selectedCredentials: (_ctx: FirstPartyMachineContext, _event: FirstPartySelectCredentialsEvent) => _event.data}),
+        actions: assign({ selectedCredentials: (_ctx: FirstPartyMachineContext, _event: FirstPartySelectCredentialsEvent) => _event.data }),
       },
       [FirstPartyMachineEvents.NEXT]: {
         target: FirstPartyMachineStateTypes.sendAuthorizationResponse,
@@ -148,15 +141,15 @@ const firstPartyMachineStates: FirstPartyMachineStatesConfig = {
           }),
         }),
       },
-    }
+    },
   },
   [FirstPartyMachineStateTypes.aborted]: {
     id: FirstPartyMachineStateTypes.aborted,
-    type: 'final'
+    type: 'final',
   },
   [FirstPartyMachineStateTypes.declined]: {
     id: FirstPartyMachineStateTypes.declined,
-    type: 'final'
+    type: 'final',
   },
   [FirstPartyMachineStateTypes.error]: {
     id: FirstPartyMachineStateTypes.error,
@@ -165,7 +158,7 @@ const firstPartyMachineStates: FirstPartyMachineStatesConfig = {
   [FirstPartyMachineStateTypes.done]: {
     id: FirstPartyMachineStateTypes.done,
     type: 'final',
-  }
+  },
 }
 
 const createFirstPartyActivationMachine = (opts: CreateFirstPartyMachineOpts): FirstPartyStateMachine => {
@@ -173,66 +166,64 @@ const createFirstPartyActivationMachine = (opts: CreateFirstPartyMachineOpts): F
     openID4VCIClientState: opts.openID4VCIClientState,
     contact: opts.contact,
     selectedCredentials: [],
-  };
+  }
 
-  return createMachine<FirstPartyMachineContext, FirstPartyMachineEventTypes>(
-    {
-      id: opts?.machineId ?? 'FirstParty',
-      predictableActionArguments: true,
-      initial: FirstPartyMachineStateTypes.sendAuthorizationChallengeRequest,
-      context: initialContext,
-      states: firstPartyMachineStates,
-      schema: {
-        events: {} as FirstPartyMachineEventTypes,
-        services: {} as {
-          [FirstPartyMachineServices.sendAuthorizationChallengeRequest]: {
-            data: void
-          },
-          [FirstPartyMachineServices.createConfig]: {
-            data: CreateConfigResult
-          },
-          [FirstPartyMachineServices.getSiopRequest]: {
-            data: SiopV2AuthorizationRequestData
-          },
-          [FirstPartyMachineServices.sendAuthorizationResponse]: {
-            data: string
-          }
+  return createMachine<FirstPartyMachineContext, FirstPartyMachineEventTypes>({
+    id: opts?.machineId ?? 'FirstParty',
+    predictableActionArguments: true,
+    initial: FirstPartyMachineStateTypes.sendAuthorizationChallengeRequest,
+    context: initialContext,
+    states: firstPartyMachineStates,
+    schema: {
+      events: {} as FirstPartyMachineEventTypes,
+      services: {} as {
+        [FirstPartyMachineServices.sendAuthorizationChallengeRequest]: {
+          data: void
         }
-      }
-    }
-  );
-};
+        [FirstPartyMachineServices.createConfig]: {
+          data: CreateConfigResult
+        }
+        [FirstPartyMachineServices.getSiopRequest]: {
+          data: SiopV2AuthorizationRequestData
+        }
+        [FirstPartyMachineServices.sendAuthorizationResponse]: {
+          data: string
+        }
+      },
+    },
+  })
+}
 
 export class FirstPartyMachine {
-  private static _instance: FirstPartyMachineInterpreter | undefined;
+  private static _instance: FirstPartyMachineInterpreter | undefined
 
   static hasInstance(): boolean {
-    return FirstPartyMachine._instance !== undefined;
+    return FirstPartyMachine._instance !== undefined
   }
 
   static get instance(): FirstPartyMachineInterpreter {
     if (!FirstPartyMachine._instance) {
-      throw Error('Please initialize ESIMActivation machine first');
+      throw Error('Please initialize ESIMActivation machine first')
     }
-    return FirstPartyMachine._instance;
+    return FirstPartyMachine._instance
   }
 
-  static clearInstance(opts: {stop: boolean}) {
-    const {stop} = opts;
+  static clearInstance(opts: { stop: boolean }) {
+    const { stop } = opts
     if (FirstPartyMachine.hasInstance()) {
       if (stop) {
-        FirstPartyMachine.stopInstance();
+        FirstPartyMachine.stopInstance()
       }
     }
-    FirstPartyMachine._instance = undefined;
+    FirstPartyMachine._instance = undefined
   }
 
   static stopInstance(): void {
     if (!FirstPartyMachine.hasInstance()) {
-      return;
+      return
     }
-    FirstPartyMachine.instance.stop();
-    FirstPartyMachine._instance = undefined;
+    FirstPartyMachine.instance.stop()
+    FirstPartyMachine._instance = undefined
   }
 
   public static newInstance(opts: InstanceFirstPartyMachineOpts): FirstPartyMachineInterpreter {
@@ -254,10 +245,10 @@ export class FirstPartyMachine {
           ...opts?.guards,
         },
       }),
-    );
+    )
 
     if (typeof opts?.subscription === 'function') {
-      newInst.onTransition(opts.subscription);
+      newInst.onTransition(opts.subscription)
     }
 
     if (opts?.requireCustomNavigationHook !== true) {
@@ -265,23 +256,23 @@ export class FirstPartyMachine {
         if (opts?.stateNavigationListener) {
           void opts.stateNavigationListener(newInst, snapshot)
         }
-      });
+      })
     }
 
-    return newInst;
+    return newInst
   }
 
   static getInstance(
     opts: InstanceFirstPartyMachineOpts & {
-      requireExisting?: boolean;
+      requireExisting?: boolean
     },
   ): FirstPartyMachineInterpreter {
     if (!FirstPartyMachine._instance) {
       if (opts?.requireExisting === true) {
-        throw Error(`Existing FirstPartyMachine instance requested, but none was created at this point!`);
+        throw Error(`Existing FirstPartyMachine instance requested, but none was created at this point!`)
       }
-      FirstPartyMachine._instance = FirstPartyMachine.newInstance(opts);
+      FirstPartyMachine._instance = FirstPartyMachine.newInstance(opts)
     }
-    return FirstPartyMachine._instance;
+    return FirstPartyMachine._instance
   }
 }

package/src/machines/oid4vciMachine.ts

@@ -1,8 +1,4 @@
-import {
-  AuthorizationChallengeCodeResponse,
-  AuthzFlowType,
-  toAuthorizationResponsePayload
-} from '@sphereon/oid4vci-common'
+import { AuthorizationChallengeCodeResponse, AuthzFlowType, toAuthorizationResponsePayload } from '@sphereon/oid4vci-common'
 import { IBasicIssuerLocaleBranding, Identity, IIssuerLocaleBranding, Party } from '@sphereon/ssi-sdk.data-store'
 import { assign, createMachine, DoneInvokeEvent, interpret } from 'xstate'
 import { translate } from '../localization/Localization'
@@ -456,18 +452,20 @@ const createOID4VCIMachine = (opts?: CreateOID4VCIMachineOpts): OID4VCIStateMach
           },
         ],
       },
-      [OID4VCIMachineStates.startFirstPartApplicationFlow] :{
+      [OID4VCIMachineStates.startFirstPartApplicationFlow]: {
         id: OID4VCIMachineStates.startFirstPartApplicationFlow,
         invoke: {
           src: OID4VCIMachineServices.startFirstPartApplicationFlow,
           onDone: [
             {
               target: OID4VCIMachineStates.aborted,
-              cond: (_ctx: OID4VCIMachineContext, _event: DoneInvokeEvent<FirstPartyMachineStateTypes>): boolean => _event.data === FirstPartyMachineStateTypes.aborted,
+              cond: (_ctx: OID4VCIMachineContext, _event: DoneInvokeEvent<FirstPartyMachineStateTypes>): boolean =>
+                _event.data === FirstPartyMachineStateTypes.aborted,
             },
             {
               target: OID4VCIMachineStates.declined,
-              cond: (_ctx: OID4VCIMachineContext, _event: DoneInvokeEvent<FirstPartyMachineStateTypes>): boolean => _event.data === FirstPartyMachineStateTypes.declined,
+              cond: (_ctx: OID4VCIMachineContext, _event: DoneInvokeEvent<FirstPartyMachineStateTypes>): boolean =>
+                _event.data === FirstPartyMachineStateTypes.declined,
             },
             {
               target: OID4VCIMachineStates.getCredentials,
@@ -475,9 +473,9 @@ const createOID4VCIMachine = (opts?: CreateOID4VCIMachineOpts): OID4VCIStateMach
                 openID4VCIClientState: (_ctx: OID4VCIMachineContext, _event: DoneInvokeEvent<AuthorizationChallengeCodeResponse>) => {
                   const authorizationCodeResponse = toAuthorizationResponsePayload(_event.data)
                   return { ..._ctx.openID4VCIClientState!, authorizationCodeResponse }
-                }
-              })
-            }
+                },
+              }),
+            },
           ],
           onError: {
             target: OID4VCIMachineStates.handleError,

package/src/mappers/OIDC4VCIBrandingMapper.ts

@@ -1,15 +1,6 @@
 import { CredentialsSupportedDisplay, NameAndLocale } from '@sphereon/oid4vci-common'
-import {
-  IBasicCredentialClaim,
-  IBasicCredentialLocaleBranding,
-  IBasicIssuerLocaleBranding
-} from '@sphereon/ssi-sdk.data-store'
-import {
-  SdJwtClaimDisplayMetadata,
-  SdJwtClaimMetadata,
-  SdJwtClaimPath,
-  SdJwtTypeDisplayMetadata
-} from '@sphereon/ssi-types'
+import { IBasicCredentialClaim, IBasicCredentialLocaleBranding, IBasicIssuerLocaleBranding } from '@sphereon/ssi-sdk.data-store'
+import { SdJwtClaimDisplayMetadata, SdJwtClaimMetadata, SdJwtClaimPath, SdJwtTypeDisplayMetadata } from '@sphereon/ssi-types'
 import {
   IssuerLocaleBrandingFromArgs,
   Oid4vciCombineDisplayLocalesFromArgs,
@@ -26,7 +17,9 @@ import {
 
 // FIXME should we not move this to the branding plugin?
 
-export const oid4vciGetCredentialBrandingFrom = async (args: Oid4vciGetCredentialBrandingFromArgs): Promise<Array<IBasicCredentialLocaleBranding>> => {
+export const oid4vciGetCredentialBrandingFrom = async (
+  args: Oid4vciGetCredentialBrandingFromArgs,
+): Promise<Array<IBasicCredentialLocaleBranding>> => {
   const { credentialDisplay, issuerCredentialSubject } = args
 
   return oid4vciCombineDisplayLocalesFrom({
@@ -35,7 +28,9 @@ export const oid4vciGetCredentialBrandingFrom = async (args: Oid4vciGetCredentia
   })
 }
 
-export const oid4vciCredentialDisplayLocalesFrom = async (args: Oid4vciCredentialDisplayLocalesFromArgs): Promise<Map<string, CredentialsSupportedDisplay>> => {
+export const oid4vciCredentialDisplayLocalesFrom = async (
+  args: Oid4vciCredentialDisplayLocalesFromArgs,
+): Promise<Map<string, CredentialsSupportedDisplay>> => {
   const { credentialDisplay } = args
   return credentialDisplay.reduce((localeDisplays, display) => {
     const localeKey = display.locale || ''
@@ -44,7 +39,9 @@ export const oid4vciCredentialDisplayLocalesFrom = async (args: Oid4vciCredentia
   }, new Map<string, CredentialsSupportedDisplay>())
 }
 
-export const oid4vciIssuerCredentialSubjectLocalesFrom = async (args: Oid4vciIssuerCredentialSubjectLocalesFromArgs): Promise<Map<string, Array<IBasicCredentialClaim>>> => {
+export const oid4vciIssuerCredentialSubjectLocalesFrom = async (
+  args: Oid4vciIssuerCredentialSubjectLocalesFromArgs,
+): Promise<Map<string, Array<IBasicCredentialClaim>>> => {
   const { issuerCredentialSubject } = args
   const localeClaims = new Map<string, Array<IBasicCredentialClaim>>()
 
@@ -125,7 +122,9 @@ export const oid4vciCredentialLocaleBrandingFrom = async (args: Oid4vciCredentia
   }
 }
 
-export const oid4vciCombineDisplayLocalesFrom = async (args: Oid4vciCombineDisplayLocalesFromArgs): Promise<Array<IBasicCredentialLocaleBranding>> => {
+export const oid4vciCombineDisplayLocalesFrom = async (
+  args: Oid4vciCombineDisplayLocalesFromArgs,
+): Promise<Array<IBasicCredentialLocaleBranding>> => {
   const {
     credentialDisplayLocales = new Map<string, CredentialsSupportedDisplay>(),
     issuerCredentialSubjectLocales = new Map<string, Array<IBasicCredentialClaim>>(),
@@ -156,7 +155,9 @@ export const sdJwtGetCredentialBrandingFrom = async (args: SdJwtGetCredentialBra
   })
 }
 
-export const sdJwtCredentialDisplayLocalesFrom = async (args: SdJwtCredentialDisplayLocalesFromArgs): Promise<Map<string, SdJwtTypeDisplayMetadata>> => {
+export const sdJwtCredentialDisplayLocalesFrom = async (
+  args: SdJwtCredentialDisplayLocalesFromArgs,
+): Promise<Map<string, SdJwtTypeDisplayMetadata>> => {
   const { credentialDisplay } = args
   return credentialDisplay.reduce((localeDisplays, display) => {
     const localeKey = display.lang || ''
@@ -165,14 +166,16 @@ export const sdJwtCredentialDisplayLocalesFrom = async (args: SdJwtCredentialDis
   }, new Map<string, SdJwtTypeDisplayMetadata>())
 }
 
-export const sdJwtCredentialClaimLocalesFrom = async (args: SdJwtCredentialClaimLocalesFromArgs): Promise<Map<string, Array<IBasicCredentialClaim>>> => {
+export const sdJwtCredentialClaimLocalesFrom = async (
+  args: SdJwtCredentialClaimLocalesFromArgs,
+): Promise<Map<string, Array<IBasicCredentialClaim>>> => {
   const { claimsMetadata } = args
   const localeClaims = new Map<string, Array<IBasicCredentialClaim>>()
 
   claimsMetadata.forEach((claim: SdJwtClaimMetadata): void => {
     claim.display?.forEach((display: SdJwtClaimDisplayMetadata): void => {
-      const { lang = '', label } = display;
-      const key = claim.path.map((value: SdJwtClaimPath) => String(value)).join('.');
+      const { lang = '', label } = display
+      const key = claim.path.map((value: SdJwtClaimPath) => String(value)).join('.')
       if (!localeClaims.has(lang)) {
         localeClaims.set(lang, [])
       }
@@ -180,7 +183,7 @@ export const sdJwtCredentialClaimLocalesFrom = async (args: SdJwtCredentialClaim
     })
   })
 
-  return localeClaims;
+  return localeClaims
 }
 
 export const sdJwtCredentialLocaleBrandingFrom = async (args: SdJwtCredentialLocaleBrandingFromArgs): Promise<IBasicCredentialLocaleBranding> => {
@@ -213,17 +216,15 @@ export const sdJwtCredentialLocaleBrandingFrom = async (args: SdJwtCredentialLoc
     }),
     ...(credentialDisplay.rendering?.simple?.background_color && {
       background: {
-        color: credentialDisplay.rendering.simple.background_color ,
+        color: credentialDisplay.rendering.simple.background_color,
       },
     }),
   }
 }
 
 export const sdJwtCombineDisplayLocalesFrom = async (args: SdJwtCombineDisplayLocalesFromArgs): Promise<Array<IBasicCredentialLocaleBranding>> => {
-  const {
-    credentialDisplayLocales = new Map<string, SdJwtTypeDisplayMetadata>(),
-    claimsMetadata = new Map<string, Array<IBasicCredentialClaim>>(),
-  } = args
+  const { credentialDisplayLocales = new Map<string, SdJwtTypeDisplayMetadata>(), claimsMetadata = new Map<string, Array<IBasicCredentialClaim>>() } =
+    args
 
   const locales: Array<string> = Array.from(new Set([...claimsMetadata.keys(), ...credentialDisplayLocales.keys()]))
 

package/src/services/FirstPartyMachineServices.ts

@@ -9,7 +9,7 @@ import {
   GetSiopRequestArgs,
   SendAuthorizationChallengeRequestArgs,
   SendAuthorizationResponseArgs,
-  SiopV2AuthorizationRequestData
+  SiopV2AuthorizationRequestData,
 } from '../types/FirstPartyMachine'
 
 export const sendAuthorizationChallengeRequest = async (args: SendAuthorizationChallengeRequestArgs): Promise<AuthorizationChallengeCodeResponse> => {
@@ -19,31 +19,32 @@ export const sendAuthorizationChallengeRequest = async (args: SendAuthorizationC
   return oid4vciClient.acquireAuthorizationChallengeCode({
     clientId: oid4vciClient.clientId ?? uuidv4(),
     ...(authSession && { authSession }),
-    ...(!authSession && openID4VCIClientState.credentialOffer?.preAuthorizedCode && { issuerState: openID4VCIClientState.credentialOffer?.preAuthorizedCode }),
+    ...(!authSession &&
+      openID4VCIClientState.credentialOffer?.preAuthorizedCode && { issuerState: openID4VCIClientState.credentialOffer?.preAuthorizedCode }),
     ...(!authSession && openID4VCIClientState.credentialOffer?.issuerState && { issuerState: openID4VCIClientState.credentialOffer?.issuerState }),
-    ...(presentationDuringIssuanceSession && { presentationDuringIssuanceSession })
+    ...(presentationDuringIssuanceSession && { presentationDuringIssuanceSession }),
   })
 }
 
 export const createConfig = async (args: CreateConfigArgs, context: RequiredContext): Promise<CreateConfigResult> => {
-  const { presentationUri } = args;
+  const { presentationUri } = args
 
   if (!presentationUri) {
-    return Promise.reject(Error('Missing presentation uri in context'));
+    return Promise.reject(Error('Missing presentation uri in context'))
   }
 
   return context.agent.siopCreateConfig({ url: presentationUri })
-};
+}
 
 export const getSiopRequest = async (args: GetSiopRequestArgs, context: RequiredContext): Promise<SiopV2AuthorizationRequestData> => {
-  const {didAuthConfig, presentationUri} = args;
+  const { didAuthConfig, presentationUri } = args
 
   if (presentationUri === undefined) {
-    return Promise.reject(Error('Missing presentation uri in context'));
+    return Promise.reject(Error('Missing presentation uri in context'))
   }
 
   if (didAuthConfig === undefined) {
-    return Promise.reject(Error('Missing did auth config in context'));
+    return Promise.reject(Error('Missing did auth config in context'))
   }
 
   return context.agent.siopGetSiopRequest({ didAuthConfig, url: presentationUri })
@@ -56,7 +57,7 @@ export const sendAuthorizationResponse = async (args: SendAuthorizationResponseA
     authorizationRequestData,
     selectedCredentials,
     didAuthConfig,
-    isFirstParty: true
+    isFirstParty: true,
   })
 
   return (<AuthorizationChallengeValidationResponse>responseData.body).presentation_during_issuance_session

package/src/services/OID4VCIHolderService.ts

@@ -10,7 +10,7 @@ import {
   getTypesFromObject,
   MetadataDisplay,
   OpenId4VCIVersion,
-  AuthorizationChallengeCodeResponse
+  AuthorizationChallengeCodeResponse,
 } from '@sphereon/oid4vci-common'
 import { KeyUse } from '@sphereon/ssi-sdk-ext.did-resolver-jwk'
 import { getOrCreatePrimaryIdentifier, SupportedDidMethodEnum } from '@sphereon/ssi-sdk-ext.did-utils'
@@ -26,6 +26,7 @@ import { keyTypeFromCryptographicSuite } from '@sphereon/ssi-sdk-ext.key-utils'
 import { IBasicCredentialLocaleBranding, IBasicIssuerLocaleBranding } from '@sphereon/ssi-sdk.data-store'
 import {
   CredentialMapper,
+  Hasher,
   IVerifiableCredential,
   JoseSignatureAlgorithm,
   JoseSignatureAlgorithmString,
@@ -58,13 +59,9 @@ import {
   VerificationResult,
   VerifyCredentialToAcceptArgs,
   StartFirstPartApplicationMachine,
-  RequiredContext
+  RequiredContext,
 } from '../types/IOID4VCIHolder'
-import {
-  oid4vciGetCredentialBrandingFrom,
-  sdJwtGetCredentialBrandingFrom,
-  issuerLocaleBrandingFrom
-} from '../mappers/OIDC4VCIBrandingMapper'
+import { oid4vciGetCredentialBrandingFrom, sdJwtGetCredentialBrandingFrom, issuerLocaleBrandingFrom } from '../mappers/OIDC4VCIBrandingMapper'
 import { FirstPartyMachine } from '../machines/firstPartyMachine'
 import { FirstPartyMachineState, FirstPartyMachineStateTypes } from '../types/FirstPartyMachine'
 
@@ -88,14 +85,14 @@ export const getCredentialBranding = async (args: GetCredentialBrandingArgs): Pr
       if (sdJwtTypeMetadata) {
         mappedLocaleBranding = await sdJwtGetCredentialBrandingFrom({
           credentialDisplay: sdJwtTypeMetadata.display,
-          claimsMetadata: sdJwtTypeMetadata.claims
+          claimsMetadata: sdJwtTypeMetadata.claims,
         })
       } else {
         mappedLocaleBranding = await oid4vciGetCredentialBrandingFrom({
           credentialDisplay: credentialsConfigSupported.display,
           issuerCredentialSubject:
-          // @ts-ignore // FIXME SPRIND-123 add proper support for type recognition as claim display can be located elsewhere for v13
-          credentialsSupported.claims !== undefined ? credentialsConfigSupported.claims : credentialsConfigSupported.credentialSubject,
+            // @ts-ignore // FIXME SPRIND-123 add proper support for type recognition as claim display can be located elsewhere for v13
+            credentialsSupported.claims !== undefined ? credentialsConfigSupported.claims : credentialsConfigSupported.credentialSubject,
         })
       }
       // TODO we should make the mapper part of the plugin, so that the logic for getting the branding becomes more clear and easier to use
@@ -226,7 +223,7 @@ export const mapCredentialToAccept = async (args: MapCredentialToAcceptArgs): Pr
     if (!hasher) {
       return Promise.reject('a hasher is required for encoded SD-JWT credentials')
     }
-    const asyncHasher = (data: string, algorithm: string) => Promise.resolve(hasher(data, algorithm))
+    const asyncHasher: Hasher = (data: string, algorithm: string) => Promise.resolve(hasher(data, algorithm))
     const decodedSdJwt = await CredentialMapper.decodeSdJwtVcAsync(wrappedVerifiableCredential.credential, asyncHasher)
     uniformVerifiableCredential = sdJwtDecodedCredentialToUniformCredential(<SdJwtDecodedVerifiableCredential>decodedSdJwt)
   } else if (CredentialMapper.isMsoMdocDecodedCredential(wrappedVerifiableCredential.credential)) {
@@ -621,7 +618,10 @@ export const getIssuanceCryptoSuite = async (opts: GetIssuanceCryptoSuiteArgs):
   }
 }
 
-export const startFirstPartApplicationMachine = async (args: StartFirstPartApplicationMachine, context: RequiredContext): Promise<AuthorizationChallengeCodeResponse | string> => {
+export const startFirstPartApplicationMachine = async (
+  args: StartFirstPartApplicationMachine,
+  context: RequiredContext,
+): Promise<AuthorizationChallengeCodeResponse | string> => {
   const { openID4VCIClientState, stateNavigationListener, contact } = args
 
   if (!openID4VCIClientState) {
@@ -636,8 +636,8 @@ export const startFirstPartApplicationMachine = async (args: StartFirstPartAppli
     openID4VCIClientState,
     contact,
     agentContext: context,
-    stateNavigationListener
-  });
+    stateNavigationListener,
+  })
 
   return new Promise((resolve, reject) => {
     try {
@@ -645,20 +645,20 @@ export const startFirstPartApplicationMachine = async (args: StartFirstPartAppli
         if (state.matches(FirstPartyMachineStateTypes.done)) {
           const authorizationCodeResponse = state.context.authorizationCodeResponse
           if (!authorizationCodeResponse) {
-            reject(Error('No authorizationCodeResponse acquired'));
+            reject(Error('No authorizationCodeResponse acquired'))
           }
-          resolve(authorizationCodeResponse!);
+          resolve(authorizationCodeResponse!)
         } else if (state.matches(FirstPartyMachineStateTypes.aborted)) {
-          resolve(FirstPartyMachineStateTypes.aborted);
+          resolve(FirstPartyMachineStateTypes.aborted)
         } else if (state.matches(FirstPartyMachineStateTypes.declined)) {
-          resolve(FirstPartyMachineStateTypes.declined);
+          resolve(FirstPartyMachineStateTypes.declined)
         } else if (state.matches(FirstPartyMachineStateTypes.error)) {
-          reject(state.context.error);
+          reject(state.context.error)
         }
       })
-      firstPartyMachineInstance.start();
+      firstPartyMachineInstance.start()
     } catch (error) {
-      reject(error);
+      reject(error)
     }
-  });
-};
+  })
+}