@sphereon/ssi-sdk.oid4vci-holder 0.32.1-next.13 → 0.32.1-next.141

package/src/agent/OID4VCIHolder.ts

@@ -4,6 +4,8 @@ import {
   AuthorizationRequestOpts,
   AuthorizationServerClientOpts,
   AuthorizationServerOpts,
+  CredentialConfigurationSupportedJwtVcJsonLdAndLdpVcV1_0_13,
+  CredentialDefinitionJwtVcJsonLdAndLdpVcV1_0_13,
   CredentialOfferRequestWithBaseUrl,
   DefaultURISchemes,
   EndpointMetadataResult,
@@ -70,12 +72,12 @@ import {
 import { asArray, computeEntryHash } from '@veramo/utils'
 import { decodeJWT } from 'did-jwt'
 import { v4 as uuidv4 } from 'uuid'
-import { OID4VCIMachine } from '../machine/oid4vciMachine'
+import { OID4VCIMachine } from '../machines/oid4vciMachine'
 import {
   AddContactIdentityArgs,
   AssertValidCredentialsArgs,
   Attribute,
-  createCredentialsToSelectFromArgs,
+  CreateCredentialsToSelectFromArgs,
   CredentialToAccept,
   CredentialToSelectFromResult,
   GetContactArgs,
@@ -91,6 +93,8 @@ import {
   OID4VCIHolderOptions,
   OID4VCIMachine as OID4VCIMachineId,
   OID4VCIMachineInstanceOpts,
+  OID4VCIMachineServiceDefinitions,
+  OID4VCIMachineServices,
   OnContactIdentityCreatedArgs,
   OnCredentialStoredArgs,
   OnIdentifierCreatedArgs,
@@ -98,13 +102,14 @@ import {
   RequestType,
   RequiredContext,
   SendNotificationArgs,
+  StartFirstPartApplicationMachine,
   StartResult,
   StoreCredentialBrandingArgs,
   StoreCredentialsArgs,
   StoreIssuerBrandingArgs,
   VerificationResult,
   VerifyEBSICredentialIssuerArgs,
-  VerifyEBSICredentialIssuerResult,
+  VerifyEBSICredentialIssuerResult
 } from '../types/IOID4VCIHolder'
 import {
   getBasicIssuerLocaleBranding,
@@ -115,8 +120,8 @@ import {
   mapCredentialToAccept,
   selectCredentialLocaleBranding,
   verifyCredentialToAccept,
-} from './OID4VCIHolderService'
-
+  startFirstPartApplicationMachine
+} from '../services/OID4VCIHolderService'
 import 'cross-fetch/polyfill'
 
 /**
@@ -307,8 +312,8 @@ export class OID4VCIHolder implements IAgentPlugin {
    */
   private async oid4vciHolderGetMachineInterpreter(opts: OID4VCIMachineInstanceOpts, context: RequiredContext): Promise<OID4VCIMachineId> {
     const authorizationRequestOpts = { ...this.defaultAuthorizationRequestOpts, ...opts.authorizationRequestOpts }
-    const services = {
-      start: (args: PrepareStartArgs) =>
+    const services: OID4VCIMachineServiceDefinitions = {
+      [OID4VCIMachineServices.start]: (args: PrepareStartArgs) =>
         this.oid4vciHolderStart(
           {
             ...args,
@@ -316,18 +321,18 @@ export class OID4VCIHolder implements IAgentPlugin {
           },
           context,
         ),
-      createCredentialsToSelectFrom: (args: createCredentialsToSelectFromArgs) => this.oid4vciHolderCreateCredentialsToSelectFrom(args, context),
-      getContact: (args: GetContactArgs) => this.oid4vciHolderGetContact(args, context),
-      getCredentials: (args: GetCredentialsArgs) =>
-        this.oid4vciHolderGetCredentials({ accessTokenOpts: args.accessTokenOpts ?? opts.accessTokenOpts, ...args }, context),
-      addContactIdentity: (args: AddContactIdentityArgs) => this.oid4vciHolderAddContactIdentity(args, context),
-      getIssuerBranding: (args: GetIssuerBrandingArgs) => this.oid4vciHolderGetIssuerBranding(args, context),
-      storeIssuerBranding: (args: StoreIssuerBrandingArgs) => this.oid4vciHolderStoreIssuerBranding(args, context),
-      assertValidCredentials: (args: AssertValidCredentialsArgs) => this.oid4vciHolderAssertValidCredentials(args, context),
-      storeCredentialBranding: (args: StoreCredentialBrandingArgs) => this.oid4vciHolderStoreCredentialBranding(args, context),
-      storeCredentials: (args: StoreCredentialsArgs) => this.oid4vciHolderStoreCredentials(args, context),
-      sendNotification: (args: SendNotificationArgs) => this.oid4vciHolderSendNotification(args, context),
-      getFederationTrust: (args: GetFederationTrustArgs) => this.getFederationTrust(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.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.storeCredentials]: (args: StoreCredentialsArgs) => this.oid4vciHolderStoreCredentials(args, context),
+      [OID4VCIMachineServices.sendNotification]: (args: SendNotificationArgs) => this.oid4vciHolderSendNotification(args, context),
+      [OID4VCIMachineServices.getFederationTrust]: (args: GetFederationTrustArgs) => this.getFederationTrust(args, context),
     }
 
     const oid4vciMachineInstanceArgs: OID4VCIMachineInstanceOpts = {
@@ -463,7 +468,7 @@ export class OID4VCIHolder implements IAgentPlugin {
   }
 
   private async oid4vciHolderCreateCredentialsToSelectFrom(
-    args: createCredentialsToSelectFromArgs,
+    args: CreateCredentialsToSelectFromArgs,
     context: RequiredContext,
   ): Promise<Array<CredentialToSelectFromResult>> {
     const { credentialBranding, locale, selectedCredentials /*, openID4VCIClientState*/, credentialsSupported } = args
@@ -675,7 +680,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,
@@ -1127,4 +1135,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,7 +3,9 @@
  */
 
 export { OID4VCIHolder, oid4vciHolderContextMethods, signCallback } from './agent/OID4VCIHolder'
-export * from './agent/OID4VCIHolderService'
+export * from './services/OID4VCIHolderService'
+export * from './services/FirstPartyMachineServices'
 export * from './types/IOID4VCIHolder'
-export * from './machine/headlessStateNavListener'
+export * from './types/FirstPartyMachine'
+export * from './listeners/headlessStateNavListener'
 export * from './link-handler'

package/src/link-handler/index.ts

@@ -3,23 +3,28 @@ 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, OID4VCIMachineInterpreter, OID4VCIMachineState } from '../types/IOID4VCIHolder'
+import {
+  GetMachineArgs,
+  IOID4VCIHolder,
+  OID4VCIMachineEvents,
+  OID4VCIMachineStateNavigationListener
+} from '../types/IOID4VCIHolder'
+import { FirstPartyMachineStateNavigationListener } from '../types/FirstPartyMachine'
 
 /**
  * This handler only handles credential offer links (either by value or by reference)
  */
 export class OID4VCIHolderLinkHandler extends LinkHandlerAdapter {
   private readonly context: IAgentContext<IOID4VCIHolder & IMachineStatePersistence>
-  private readonly stateNavigationListener:
-    | ((oid4vciMachine: OID4VCIMachineInterpreter, state: OID4VCIMachineState, navigation?: any) => Promise<void>)
-    | undefined
+  private readonly stateNavigationListener?: OID4VCIMachineStateNavigationListener
+  private readonly firstPartyStateNavigationListener?: FirstPartyMachineStateNavigationListener
   private readonly noStateMachinePersistence: boolean
   private readonly authorizationRequestOpts?: AuthorizationRequestOpts
   private readonly clientOpts?: AuthorizationServerClientOpts
   private readonly trustAnchors?: Array<string>
 
   constructor(
-    args: Pick<GetMachineArgs, 'stateNavigationListener' | 'authorizationRequestOpts' | 'clientOpts' | 'trustAnchors'> & {
+    args: Pick<GetMachineArgs, 'stateNavigationListener' | 'authorizationRequestOpts' | 'clientOpts' | 'trustAnchors' | 'firstPartyStateNavigationListener'> & {
       priority?: number | DefaultLinkPriorities
       protocols?: Array<string | RegExp>
       noStateMachinePersistence?: boolean
@@ -32,6 +37,7 @@ export class OID4VCIHolderLinkHandler extends LinkHandlerAdapter {
     this.context = args.context
     this.noStateMachinePersistence = args.noStateMachinePersistence === true
     this.stateNavigationListener = args.stateNavigationListener
+    this.firstPartyStateNavigationListener = args.firstPartyStateNavigationListener
     this.trustAnchors = args.trustAnchors
   }
 
@@ -63,6 +69,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
     })
 
     const interpreter = oid4vciMachine.interpreter

package/src/localization/translations/en.json

@@ -11,5 +11,9 @@
   "oid4vci_machine_initiation_error_title": "Initiate OID4VCI provider",
   "oid4vci_machine_credential_verification_failed_message": "The credential verification resulted in an error.",
   "oid4vci_machine_credential_verification_schema_failed_message": "The credential schema verification resulted in an error.",
-  "oid4vci_machine_retrieve_federation_trust_error_title": "Retrieve federation trust"
+  "oid4vci_machine_retrieve_federation_trust_error_title": "Retrieve federation trust",
+  "oid4vci_machine_first_party_error_title": "First party flow",
+  "oid4vci_machine_send_authorization_challenge_request_error_title": "Sending authorization challenge request",
+  "oid4vci_machine_create_config_error_title": "Creating siopV2 config",
+  "oid4vci_machine_get_request_error_title": "Getting siopV2 request"
 }

package/src/localization/translations/nl.json

@@ -10,5 +10,9 @@
   "oid4vci_machine_credential_selection_error_title": "Credential selectie",
   "oid4vci_machine_initiation_error_title": "Initiëren OID4VCI provider",
   "oid4vci_machine_credential_verification_failed_message": "Verificatie van de credential leidde tot een fout.",
-  "oid4vci_machine_retrieve_federation_trust_error_title": "Ophalen federatievertrouwen"
+  "oid4vci_machine_retrieve_federation_trust_error_title": "Ophalen federatievertrouwen",
+  "oid4vci_machine_first_party_error_title": "Eerste partijstroom",
+  "oid4vci_machine_send_authorization_challenge_request_error_title": "Versturen autorisatie-uitdaging aanvraag",
+  "oid4vci_machine_create_config_error_title": "SiopV2-configuratie aanmaken",
+  "oid4vci_machine_get_request_error_title": "SiopV2-verzoek ophalen"
 }

package/src/machines/firstPartyMachine.ts

@@ -0,0 +1,287 @@
+import { assign, createMachine, DoneInvokeEvent, interpret } from 'xstate'
+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 { translate } from '../localization/Localization'
+import { ErrorDetails } from '../types/IOID4VCIHolder'
+import {
+  CreateConfigArgs,
+  CreateFirstPartyMachineOpts,
+  FirstPartyMachineContext,
+  FirstPartyMachineEvents,
+  FirstPartyMachineEventTypes,
+  FirstPartyMachineInterpreter,
+  FirstPartyMachineServices,
+  FirstPartyMachineState,
+  FirstPartyMachineStatesConfig,
+  FirstPartyMachineStateTypes,
+  FirstPartyMachineServiceDefinitions,
+  FirstPartyStateMachine,
+  GetSiopRequestArgs,
+  InstanceFirstPartyMachineOpts,
+  SiopV2AuthorizationRequestData,
+  SendAuthorizationResponseArgs,
+  FirstPartySelectCredentialsEvent
+} from '../types/FirstPartyMachine'
+
+const firstPartyMachineStates: FirstPartyMachineStatesConfig = {
+  [FirstPartyMachineStateTypes.sendAuthorizationChallengeRequest]: {
+    id: FirstPartyMachineStateTypes.sendAuthorizationChallengeRequest,
+    invoke: {
+      src: FirstPartyMachineServices.sendAuthorizationChallengeRequest,
+      onDone: {
+        target: FirstPartyMachineStateTypes.done,
+        actions: assign({
+          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,
+          actions: assign({
+            authSession: (_ctx: FirstPartyMachineContext, _event: DoneInvokeEvent<AuthorizationChallengeErrorResponse>) => _event.data.auth_session,
+            presentationUri: (_ctx: FirstPartyMachineContext, _event: DoneInvokeEvent<AuthorizationChallengeErrorResponse>) => _event.data.presentation,
+          }),
+        },
+        {
+          target: FirstPartyMachineStateTypes.error,
+          actions: assign({
+            error: (_ctx: FirstPartyMachineContext, _event: DoneInvokeEvent<Error>): ErrorDetails => ({
+              title: translate('oid4vci_machine_send_authorization_challenge_request_error_title'),
+              message: _event.data.message,
+              stack: _event.data.stack,
+            }),
+          }),
+        }
+      ],
+    }
+  },
+  [FirstPartyMachineStateTypes.createConfig]: {
+    id: FirstPartyMachineStateTypes.createConfig,
+    invoke: {
+      src: FirstPartyMachineServices.createConfig,
+      onDone: {
+        target: FirstPartyMachineStateTypes.getSiopRequest,
+        actions: assign({
+          didAuthConfig: (_ctx: FirstPartyMachineContext, _event: DoneInvokeEvent<DidAuthConfig>) => _event.data,
+        }),
+      },
+      onError: {
+        target: FirstPartyMachineStateTypes.error,
+        actions: assign({
+          error: (_ctx: FirstPartyMachineContext, _event: DoneInvokeEvent<Error>): ErrorDetails => ({
+            title: translate('oid4vci_machine_create_config_error_title'),
+            message: _event.data.message,
+            stack: _event.data.stack,
+          }),
+        }),
+      },
+    },
+  },
+  [FirstPartyMachineStateTypes.getSiopRequest]: {
+    id: FirstPartyMachineStateTypes.getSiopRequest,
+    invoke: {
+      src: FirstPartyMachineServices.getSiopRequest,
+      onDone: {
+        target: FirstPartyMachineStateTypes.selectCredentials,
+        actions: assign({
+          authorizationRequestData: (_ctx: FirstPartyMachineContext, _event: DoneInvokeEvent<SiopV2AuthorizationRequestData>) => _event.data,
+        }),
+      },
+      onError: {
+        target: FirstPartyMachineStateTypes.error,
+        actions: assign({
+          error: (_ctx: FirstPartyMachineContext, _event: DoneInvokeEvent<Error>): ErrorDetails => ({
+            title: translate('siopV2_machine_get_request_error_title'),
+            message: _event.data.message,
+            stack: _event.data.stack,
+          }),
+        }),
+      },
+    },
+  },
+  [FirstPartyMachineStateTypes.selectCredentials]: {
+    id: FirstPartyMachineStateTypes.selectCredentials,
+    on: {
+      [FirstPartyMachineEvents.SET_SELECTED_CREDENTIALS]: {
+        actions: assign({selectedCredentials: (_ctx: FirstPartyMachineContext, _event: FirstPartySelectCredentialsEvent) => _event.data}),
+      },
+      [FirstPartyMachineEvents.NEXT]: {
+        target: FirstPartyMachineStateTypes.sendAuthorizationResponse,
+      },
+      [FirstPartyMachineEvents.DECLINE]: {
+        target: FirstPartyMachineStateTypes.declined,
+      },
+      [FirstPartyMachineEvents.PREVIOUS]: {
+        target: FirstPartyMachineStateTypes.aborted,
+      },
+    },
+  },
+  [FirstPartyMachineStateTypes.sendAuthorizationResponse]: {
+    id: FirstPartyMachineStateTypes.sendAuthorizationResponse,
+    invoke: {
+      src: FirstPartyMachineServices.sendAuthorizationResponse,
+      onDone: {
+        target: FirstPartyMachineStateTypes.sendAuthorizationChallengeRequest,
+        actions: assign({
+          presentationDuringIssuanceSession: (_ctx: FirstPartyMachineContext, _event: DoneInvokeEvent<string>) => _event.data,
+        }),
+      },
+      onError: {
+        target: FirstPartyMachineStateTypes.error,
+        actions: assign({
+          error: (_ctx: FirstPartyMachineContext, _event: DoneInvokeEvent<Error>): ErrorDetails => ({
+            title: translate('oid4vci_machine_get_request_error_title'),
+            message: _event.data.message,
+            stack: _event.data.stack,
+          }),
+        }),
+      },
+    }
+  },
+  [FirstPartyMachineStateTypes.aborted]: {
+    id: FirstPartyMachineStateTypes.aborted,
+    type: 'final'
+  },
+  [FirstPartyMachineStateTypes.declined]: {
+    id: FirstPartyMachineStateTypes.declined,
+    type: 'final'
+  },
+  [FirstPartyMachineStateTypes.error]: {
+    id: FirstPartyMachineStateTypes.error,
+    type: 'final',
+  },
+  [FirstPartyMachineStateTypes.done]: {
+    id: FirstPartyMachineStateTypes.done,
+    type: 'final',
+  }
+}
+
+const createFirstPartyActivationMachine = (opts: CreateFirstPartyMachineOpts): FirstPartyStateMachine => {
+  const initialContext: FirstPartyMachineContext = {
+    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
+          }
+        }
+      }
+    }
+  );
+};
+
+export class FirstPartyMachine {
+  private static _instance: FirstPartyMachineInterpreter | undefined;
+
+  static hasInstance(): boolean {
+    return FirstPartyMachine._instance !== undefined;
+  }
+
+  static get instance(): FirstPartyMachineInterpreter {
+    if (!FirstPartyMachine._instance) {
+      throw Error('Please initialize ESIMActivation machine first');
+    }
+    return FirstPartyMachine._instance;
+  }
+
+  static clearInstance(opts: {stop: boolean}) {
+    const {stop} = opts;
+    if (FirstPartyMachine.hasInstance()) {
+      if (stop) {
+        FirstPartyMachine.stopInstance();
+      }
+    }
+    FirstPartyMachine._instance = undefined;
+  }
+
+  static stopInstance(): void {
+    if (!FirstPartyMachine.hasInstance()) {
+      return;
+    }
+    FirstPartyMachine.instance.stop();
+    FirstPartyMachine._instance = undefined;
+  }
+
+  public static newInstance(opts: InstanceFirstPartyMachineOpts): FirstPartyMachineInterpreter {
+    const { agentContext } = opts
+    const services: FirstPartyMachineServiceDefinitions = {
+      [FirstPartyMachineServices.sendAuthorizationChallengeRequest]: sendAuthorizationChallengeRequest,
+      [FirstPartyMachineServices.createConfig]: (args: CreateConfigArgs) => createConfig(args, agentContext),
+      [FirstPartyMachineServices.getSiopRequest]: (args: GetSiopRequestArgs) => getSiopRequest(args, agentContext),
+      [FirstPartyMachineServices.sendAuthorizationResponse]: (args: SendAuthorizationResponseArgs) => sendAuthorizationResponse(args, agentContext),
+    }
+
+    const newInst: FirstPartyMachineInterpreter = interpret(
+      createFirstPartyActivationMachine(opts).withConfig({
+        services: {
+          ...services,
+          ...opts?.services,
+        },
+        guards: {
+          ...opts?.guards,
+        },
+      }),
+    );
+
+    if (typeof opts?.subscription === 'function') {
+      newInst.onTransition(opts.subscription);
+    }
+
+    if (opts?.requireCustomNavigationHook !== true) {
+      newInst.onTransition((snapshot: FirstPartyMachineState): void => {
+        if (opts?.stateNavigationListener) {
+          void opts.stateNavigationListener(newInst, snapshot)
+        }
+      });
+    }
+
+    return newInst;
+  }
+
+  static getInstance(
+    opts: InstanceFirstPartyMachineOpts & {
+      requireExisting?: boolean;
+    },
+  ): FirstPartyMachineInterpreter {
+    if (!FirstPartyMachine._instance) {
+      if (opts?.requireExisting === true) {
+        throw Error(`Existing FirstPartyMachine instance requested, but none was created at this point!`);
+      }
+      FirstPartyMachine._instance = FirstPartyMachine.newInstance(opts);
+    }
+    return FirstPartyMachine._instance;
+  }
+}

package/src/{machine → machines}/oid4vciMachine.ts

@@ -1,4 +1,8 @@
-import { 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'
@@ -29,6 +33,7 @@ import {
   SetAuthorizationCodeURLEvent,
   VerificationCodeEvent,
 } from '../types/IOID4VCIHolder'
+import { FirstPartyMachineStateTypes } from '../types/FirstPartyMachine'
 
 const oid4vciHasNoContactGuard = (_ctx: OID4VCIMachineContext, _event: OID4VCIMachineEventTypes): boolean => {
   const { contact } = _ctx
@@ -117,6 +122,10 @@ const oid4vciHasAuthorizationResponse = (ctx: OID4VCIMachineContext, _event: OID
   return !!ctx.openID4VCIClientState?.authorizationCodeResponse
 }
 
+const oid4vciIsFirstPartyApplication = (ctx: OID4VCIMachineContext, _event: OID4VCIMachineEventTypes): boolean => {
+  return !!ctx.serverMetadata?.authorization_challenge_endpoint
+}
+
 const createOID4VCIMachine = (opts?: CreateOID4VCIMachineOpts): OID4VCIStateMachine => {
   const initialContext: OID4VCIMachineContext = {
     // TODO WAL-671 we need to store the data from OpenIdProvider here in the context and make sure we can restart the machine with it and init the OpenIdProvider
@@ -153,7 +162,8 @@ const createOID4VCIMachine = (opts?: CreateOID4VCIMachineOpts): OID4VCIStateMach
         | { type: OID4VCIMachineGuards.hasSelectedCredentialsGuard }
         | { type: OID4VCIMachineGuards.hasAuthorizationResponse }
         | { type: OID4VCIMachineGuards.isOIDFOriginGuard }
-        | { type: OID4VCIMachineGuards.contactHasLowTrustGuard },
+        | { type: OID4VCIMachineGuards.contactHasLowTrustGuard }
+        | { type: OID4VCIMachineGuards.isFirstPartyApplication },
       services: {} as {
         [OID4VCIMachineServices.start]: {
           data: StartResult
@@ -188,6 +198,9 @@ const createOID4VCIMachine = (opts?: CreateOID4VCIMachineOpts): OID4VCIStateMach
         [OID4VCIMachineServices.getIssuerBranding]: {
           data: Array<IIssuerLocaleBranding | IBasicIssuerLocaleBranding>
         }
+        [OID4VCIMachineServices.startFirstPartApplicationFlow]: {
+          data: void
+        }
       },
     },
     context: initialContext,
@@ -332,6 +345,10 @@ const createOID4VCIMachine = (opts?: CreateOID4VCIMachineOpts): OID4VCIStateMach
             target: OID4VCIMachineStates.selectCredentials,
             cond: OID4VCIMachineGuards.credentialsToSelectRequiredGuard,
           },
+          {
+            target: OID4VCIMachineStates.startFirstPartApplicationFlow,
+            cond: OID4VCIMachineGuards.isFirstPartyApplication,
+          },
           {
             target: OID4VCIMachineStates.initiateAuthorizationRequest,
             cond: OID4VCIMachineGuards.requireAuthorizationGuard,
@@ -422,6 +439,10 @@ const createOID4VCIMachine = (opts?: CreateOID4VCIMachineOpts): OID4VCIStateMach
             target: OID4VCIMachineStates.selectCredentials,
             cond: OID4VCIMachineGuards.credentialsToSelectRequiredGuard,
           },
+          {
+            target: OID4VCIMachineStates.startFirstPartApplicationFlow,
+            cond: OID4VCIMachineGuards.isFirstPartyApplication,
+          },
           {
             target: OID4VCIMachineStates.initiateAuthorizationRequest,
             cond: OID4VCIMachineGuards.requireAuthorizationGuard,
@@ -435,6 +456,41 @@ const createOID4VCIMachine = (opts?: CreateOID4VCIMachineOpts): OID4VCIStateMach
           },
         ],
       },
+      [OID4VCIMachineStates.startFirstPartApplicationFlow] :{
+        id: OID4VCIMachineStates.startFirstPartApplicationFlow,
+        invoke: {
+          src: OID4VCIMachineServices.startFirstPartApplicationFlow,
+          onDone: [
+            {
+              target: OID4VCIMachineStates.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,
+            },
+            {
+              target: OID4VCIMachineStates.getCredentials,
+              actions: assign({
+                openID4VCIClientState: (_ctx: OID4VCIMachineContext, _event: DoneInvokeEvent<AuthorizationChallengeCodeResponse>) => {
+                  const authorizationCodeResponse = toAuthorizationResponsePayload(_event.data)
+                  return { ..._ctx.openID4VCIClientState!, authorizationCodeResponse }
+                }
+              })
+            }
+          ],
+          onError: {
+            target: OID4VCIMachineStates.handleError,
+            actions: assign({
+              error: (_ctx: OID4VCIMachineContext, _event: DoneInvokeEvent<ErrorDetails>): ErrorDetails => ({
+                title: _event.data.title ?? translate('oid4vci_machine_first_party_error_title'),
+                message: _event.data.message,
+                stack: _event.data.stack,
+              }),
+            }),
+          },
+        },
+      },
       [OID4VCIMachineStates.selectCredentials]: {
         id: OID4VCIMachineStates.selectCredentials,
         on: {
@@ -453,6 +509,10 @@ const createOID4VCIMachine = (opts?: CreateOID4VCIMachineOpts): OID4VCIStateMach
       [OID4VCIMachineStates.transitionFromSelectingCredentials]: {
         id: OID4VCIMachineStates.transitionFromSelectingCredentials,
         always: [
+          {
+            target: OID4VCIMachineStates.startFirstPartApplicationFlow,
+            cond: OID4VCIMachineGuards.isFirstPartyApplication,
+          },
           {
             target: OID4VCIMachineStates.verifyPin,
             cond: OID4VCIMachineGuards.requirePinGuard,
@@ -726,6 +786,7 @@ export class OID4VCIMachine {
           oid4vciHasAuthorizationResponse,
           oid4vciIsOIDFOriginGuard,
           oid4vciContactHasLowTrustGuard,
+          oid4vciIsFirstPartyApplication,
           ...opts?.guards,
         },
       }),
@@ -737,7 +798,7 @@ export class OID4VCIMachine {
     if (opts?.requireCustomNavigationHook !== true) {
       if (typeof opts?.stateNavigationListener === 'function') {
         interpreter.onTransition((snapshot: OID4VCIMachineState): void => {
-          if (opts?.stateNavigationListener !== undefined) {
+          if (opts?.stateNavigationListener) {
             opts.stateNavigationListener(interpreter, snapshot)
           }
         })