@sphereon/ssi-sdk.oid4vci-holder 0.32.1-next.54 → 0.33.0

package/src/agent/OID4VCIHolder.ts

@@ -4,6 +4,8 @@ import {
   AuthorizationRequestOpts,
   AuthorizationServerClientOpts,
   AuthorizationServerOpts,
+  CredentialConfigurationSupportedJwtVcJsonLdAndLdpVcV1_0_13,
+  CredentialDefinitionJwtVcJsonLdAndLdpVcV1_0_13,
   CredentialOfferRequestWithBaseUrl,
   DefaultURISchemes,
   EndpointMetadataResult,
@@ -45,7 +47,7 @@ import {
 } from '@sphereon/ssi-sdk.data-store'
 import {
   CredentialMapper,
-  Hasher,
+  HasherSync,
   IVerifiableCredential,
   JoseSignatureAlgorithm,
   JoseSignatureAlgorithmString,
@@ -107,7 +109,7 @@ import {
   StoreIssuerBrandingArgs,
   VerificationResult,
   VerifyEBSICredentialIssuerArgs,
-  VerifyEBSICredentialIssuerResult
+  VerifyEBSICredentialIssuerResult,
 } from '../types/IOID4VCIHolder'
 import {
   getBasicIssuerLocaleBranding,
@@ -117,10 +119,11 @@ import {
   getIssuanceOpts,
   mapCredentialToAccept,
   selectCredentialLocaleBranding,
+  startFirstPartApplicationMachine,
   verifyCredentialToAccept,
-  startFirstPartApplicationMachine
 } from '../services/OID4VCIHolderService'
 import 'cross-fetch/polyfill'
+import { defaultHasher } from '@sphereon/ssi-sdk.core'
 
 /**
  * {@inheritDoc IOID4VCIHolder}
@@ -202,7 +205,7 @@ export async function verifyEBSICredentialIssuer(args: VerifyEBSICredentialIssue
 }
 
 export class OID4VCIHolder implements IAgentPlugin {
-  private readonly hasher?: Hasher
+  private readonly hasher?: HasherSync
   readonly eventTypes: Array<OID4VCIHolderEvent> = [
     OID4VCIHolderEvent.CONTACT_IDENTITY_CREATED,
     OID4VCIHolderEvent.CREDENTIAL_STORED,
@@ -264,7 +267,7 @@ export class OID4VCIHolder implements IAgentPlugin {
       didMethodPreferences,
       jwtCryptographicSuitePreferences,
       defaultAuthorizationRequestOptions,
-      hasher,
+      hasher = defaultHasher,
     } = { ...options }
 
     this.hasher = hasher
@@ -319,15 +322,19 @@ export class OID4VCIHolder implements IAgentPlugin {
           },
           context,
         ),
-      [OID4VCIMachineServices.startFirstPartApplicationFlow]: (args: StartFirstPartApplicationMachine) => startFirstPartApplicationMachine({ ...args, stateNavigationListener: opts.firstPartyStateNavigationListener }, context),
-      [OID4VCIMachineServices.createCredentialsToSelectFrom]: (args: CreateCredentialsToSelectFromArgs) => this.oid4vciHolderCreateCredentialsToSelectFrom(args, context),
+      [OID4VCIMachineServices.startFirstPartApplicationFlow]: (args: StartFirstPartApplicationMachine) =>
+        startFirstPartApplicationMachine({ ...args, stateNavigationListener: opts.firstPartyStateNavigationListener }, context),
+      [OID4VCIMachineServices.createCredentialsToSelectFrom]: (args: CreateCredentialsToSelectFromArgs) =>
+        this.oid4vciHolderCreateCredentialsToSelectFrom(args, context),
       [OID4VCIMachineServices.getContact]: (args: GetContactArgs) => this.oid4vciHolderGetContact(args, context),
-      [OID4VCIMachineServices.getCredentials]: (args: GetCredentialsArgs) => this.oid4vciHolderGetCredentials({ accessTokenOpts: args.accessTokenOpts ?? opts.accessTokenOpts, ...args }, context),
+      [OID4VCIMachineServices.getCredentials]: (args: GetCredentialsArgs) =>
+        this.oid4vciHolderGetCredentials({ accessTokenOpts: args.accessTokenOpts ?? opts.accessTokenOpts, ...args }, context),
       [OID4VCIMachineServices.addContactIdentity]: (args: AddContactIdentityArgs) => this.oid4vciHolderAddContactIdentity(args, context),
       [OID4VCIMachineServices.getIssuerBranding]: (args: GetIssuerBrandingArgs) => this.oid4vciHolderGetIssuerBranding(args, context),
       [OID4VCIMachineServices.storeIssuerBranding]: (args: StoreIssuerBrandingArgs) => this.oid4vciHolderStoreIssuerBranding(args, context),
       [OID4VCIMachineServices.assertValidCredentials]: (args: AssertValidCredentialsArgs) => this.oid4vciHolderAssertValidCredentials(args, context),
-      [OID4VCIMachineServices.storeCredentialBranding]: (args: StoreCredentialBrandingArgs) => this.oid4vciHolderStoreCredentialBranding(args, context),
+      [OID4VCIMachineServices.storeCredentialBranding]: (args: StoreCredentialBrandingArgs) =>
+        this.oid4vciHolderStoreCredentialBranding(args, context),
       [OID4VCIMachineServices.storeCredentials]: (args: StoreCredentialsArgs) => this.oid4vciHolderStoreCredentials(args, context),
       [OID4VCIMachineServices.sendNotification]: (args: SendNotificationArgs) => this.oid4vciHolderSendNotification(args, context),
       [OID4VCIMachineServices.getFederationTrust]: (args: GetFederationTrustArgs) => this.getFederationTrust(args, context),
@@ -632,7 +639,7 @@ export class OID4VCIHolder implements IAgentPlugin {
     // The VCI lib either expects a jwk or a kid
     const jwk = isManagedIdentifierJwkResult(identifier) ? identifier.jwk : undefined
 
-    const callbacks: ProofOfPossessionCallbacks<never> = {
+    const callbacks: ProofOfPossessionCallbacks = {
       signCallback: signCallback(identifier, context),
     }
 
@@ -678,7 +685,10 @@ export class OID4VCIHolder implements IAgentPlugin {
       if (!credentialTypes || credentialTypes.length === 0) {
         return Promise.reject(Error('cannot determine credential id to request'))
       }
+
+      const credentialDefinition = this.getCredentialDefinition(issuanceOpt)
       const credentialResponse = await client.acquireCredentials({
+        ...(credentialDefinition && { context: credentialDefinition['@context'] }),
         credentialTypes,
         proofCallbacks: callbacks,
         format: issuanceOpt.format,
@@ -911,7 +921,7 @@ export class OID4VCIHolder implements IAgentPlugin {
           : 'credential_deleted_holder_signed'
         logger.log(`Subject issuance/signing will be used, with event`, event)
         const issuerVC = mappedCredentialToAccept.credentialToAccept.credentialResponse.credential as OriginalVerifiableCredential
-        const wrappedIssuerVC = CredentialMapper.toWrappedVerifiableCredential(issuerVC, { hasher: this.hasher })
+        const wrappedIssuerVC = CredentialMapper.toWrappedVerifiableCredential(issuerVC, { hasher: this.hasher ?? defaultHasher })
         console.log(`Wrapped VC: ${wrappedIssuerVC.type}, ${wrappedIssuerVC.format}`)
         // We will use the subject of the VCI Issuer (the holder, as the issuer of the new credential, so the below is not a mistake!)
 
@@ -1078,6 +1088,11 @@ export class OID4VCIHolder implements IAgentPlugin {
     const params = new URLSearchParams(url.search)
     const openidFederation = params.get('openid_federation')
     const entityIdentifier = openidFederation ?? serverMetadata.issuer
+    if (entityIdentifier.startsWith('http://')) {
+      console.warn(`OpenID federation does not support http://, only https:// allowed; got: (${url.toString()})`)
+      // OIDF always needs to be https
+      return []
+    }
 
     const result = await context.agent.identifierExternalResolveByOIDFEntityId({
       method: 'entity_id',
@@ -1130,4 +1145,11 @@ export class OID4VCIHolder implements IAgentPlugin {
     }
     return undefined
   }
+
+  private getCredentialDefinition(issuanceOpt: IssuanceOpts): CredentialDefinitionJwtVcJsonLdAndLdpVcV1_0_13 | undefined {
+    if (issuanceOpt.format == 'ldp_vc' || issuanceOpt.format == 'jwt_vc_json-ld') {
+      return (issuanceOpt as CredentialConfigurationSupportedJwtVcJsonLdAndLdpVcV1_0_13).credential_definition
+    }
+    return undefined
+  }
 }

package/src/index.ts

@@ -3,6 +3,7 @@
  */
 
 export { OID4VCIHolder, oid4vciHolderContextMethods, signCallback } from './agent/OID4VCIHolder'
+export * from './mappers/OIDC4VCIBrandingMapper'
 export * from './services/OID4VCIHolderService'
 export * from './services/FirstPartyMachineServices'
 export * from './types/IOID4VCIHolder'

package/src/link-handler/index.ts

@@ -3,12 +3,7 @@ import { AuthorizationRequestOpts, AuthorizationServerClientOpts, AuthzFlowType,
 import { DefaultLinkPriorities, LinkHandlerAdapter } from '@sphereon/ssi-sdk.core'
 import { IMachineStatePersistence, interpreterStartOrResume, SerializableState } from '@sphereon/ssi-sdk.xstate-machine-persistence'
 import { IAgentContext } from '@veramo/core'
-import {
-  GetMachineArgs,
-  IOID4VCIHolder,
-  OID4VCIMachineEvents,
-  OID4VCIMachineStateNavigationListener
-} from '../types/IOID4VCIHolder'
+import { GetMachineArgs, IOID4VCIHolder, OID4VCIMachineEvents, OID4VCIMachineStateNavigationListener } from '../types/IOID4VCIHolder'
 import { FirstPartyMachineStateNavigationListener } from '../types/FirstPartyMachine'
 
 /**
@@ -24,7 +19,10 @@ export class OID4VCIHolderLinkHandler extends LinkHandlerAdapter {
   private readonly trustAnchors?: Array<string>
 
   constructor(
-    args: Pick<GetMachineArgs, 'stateNavigationListener' | 'authorizationRequestOpts' | 'clientOpts' | 'trustAnchors' | 'firstPartyStateNavigationListener'> & {
+    args: Pick<
+      GetMachineArgs,
+      'stateNavigationListener' | 'authorizationRequestOpts' | 'clientOpts' | 'trustAnchors' | 'firstPartyStateNavigationListener'
+    > & {
       priority?: number | DefaultLinkPriorities
       protocols?: Array<string | RegExp>
       noStateMachinePersistence?: boolean
@@ -69,7 +67,7 @@ export class OID4VCIHolderLinkHandler extends LinkHandlerAdapter {
       authorizationRequestOpts: { ...this.authorizationRequestOpts, ...opts?.authorizationRequestOpts },
       ...((clientOpts.clientId || clientOpts.clientAssertionType) && { clientOpts: clientOpts as AuthorizationServerClientOpts }),
       stateNavigationListener: this.stateNavigationListener,
-      firstPartyStateNavigationListener: this.firstPartyStateNavigationListener
+      firstPartyStateNavigationListener: this.firstPartyStateNavigationListener,
     })
 
     const interpreter = oid4vciMachine.interpreter

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