Learn how to build an application that can claim an mDoc via OID4VCI

• As part of your onboarding process you should have been provided with access to the following assets (Contact us if you are interested in trialing the SDK):
  • ZIP file which includes the required framework: (MobileCredentialHolderSDK-*version*.xcframework.zip).
  • Sample Wallet app: You can use this app for reference as you work through this tutorial.

• Xcode setup with either:
  • Local build settings if you are developing locally.
  • iOS developer account if you intend to publish your app.

• Supported iOS device to run the built application on, setup with:
  • Biometric authentication (Face ID, Touch ID).
  • Available internet connection.

Step 1: Create a new project

Please follow the detailed instructions to Create a new Xcode project and add your organization’s identifier.

Step 2: Unzip the dependencies file

1. Unzip the MobileCredentialHolderSDK-*version*.xcframework.zip file.
2. Drag the MobileCredentialHolderSDK-*version*.xcframework folder into your project.
3. Configure MobileCredentialHolderSDK.xcframework to Embed & sign.

See Add existing files and folders for detailed instructions.

This should result in the the following framework being added to your project:

Step 3: Configure required resources

1. Create a new file named Constants.swift within your project.

2. Add the following string resources to represent the Authentication provider you will use for this tutorial:

   enum Constants {
   	static let redirectUri: String = "io.mattrlabs.sample.mobilecredentialholderapp://credentials/callback"
   	static let clientId: String = "ios-sample-mobile-credential-holder-app"
   }

   • redirectUri : This is the path the SDK will redirect to once the user completes Authentication with the issuer. Our best practice recommendation is to configure this to be {redirect.scheme}://credentials/callback as shown in the example above. However, it can be any path as long as it is handled by your application and registered with the issuer against the corresponding clientId.
   • clientId : This is the identifier that is used by the issuer to recognize the wallet application. This is only used internally in the interaction between the wallet and the issuer and can be any string as long as it is registered with the issuer as a trusted wallet application.

Step 4: Add Bluetooth and biometric permissions

The SDK requires access to the mobile device Bluetooth and biometric capabilities for the different workflows built in this tutorial. Configure these permissions in the Info tab of the Application target:

Step 5: Run the application

Select Run and make sure the application launches with a “Hello, world!” text in the middle of the display, as shown in the following image:

The first capability you will build into your app is to initialize the SDK so that your app can use SDK methods and classes. To achieve this, you need to import the MobilecredentialHolderSDK framework and then initialize the MobileCredentialHolder class:

1. Open the ContentView class in your new app project and replace any existing code with the following:

import SwiftUI
// Claim Credential - Step 1.2: Import MobileCredentialHolderSDK

struct ContentView: View {
   @State var viewModel: ViewModel = ViewModel()
   var body: some View {
       NavigationStack(path: $viewModel.navigationPath) {
           VStack {
               Button("Claim Credential") {
                   viewModel.navigationPath.append(NavigationState.qrScan)

               }
               .padding()
               createQRCodeButton
               if viewModel.shouldDisplayOnlinePresentation {
                   Button("View Online Presentation Session") {
                       viewModel.navigationPath.append(NavigationState.onlinePresentation)
                   }
                   .padding()

               }
               Spacer()
           }
           .padding()
           .navigationDestination(for: NavigationState.self) { destination in
               switch destination {
               case .qrScan:
                   codeScannerView
               case .credentialOffer:
                   credentialOfferView
               case .transactionCodeInput:
                   transactionCodeInputView
               case .retrievedCredentials:
                   retrievedCredentialsView
               case .onlinePresentation:
                   // Online Presentation - Step 3.3: Display online presentation view
                   EmptyView()
               case .presentCredentials:
                   qrCodeView
               case .proximityPresentation:
                   // Proximity Presentation - Step 2.5: Display proximity presentation view
                   EmptyView()
               }
           }
           // Online Presentation - Step 2.4: Create session from request URI
       }
       // Claim Credential - Step 1.4: Initialize the SDK when the view appears
       .task {
           await viewModel.initialize()
       }
   }

   // MARK: - Credential Retrieval Views

   var codeScannerView: some View {
       // Claim Credential - Step 2.4 Create QRScannerView
       EmptyView()
   }

   var credentialOfferView: some View {
       // Claim Credential - Step 3.5: Display Credential offer
       EmptyView()
   }

   var transactionCodeInputView: some View {
       // Claim Credential - Step: 3.4 Display transaction code input view.
       EmptyView()
   }


   var retrievedCredentialsView: some View {
       // Claim Credential - Step 4.4: Display retrieved credentials
       EmptyView()
   }

   // MARK: - Proximity Presentation Views

   var createQRCodeButton: some View {
       // Proximity Presentation - Step 1.5: Add button to generate QR code
       EmptyView()
   }

   func generateQRCode(data: Data) -> Data? {
       // Proximity Presentation - Step 1.6: Generate QR code
       return nil
   }

   var qrCodeView: some View {
       // Proximity Presentation - Step 1.7: Create QR code view
       EmptyView()
   }
}

@Observable class ViewModel {
   var navigationPath = NavigationPath()
   // Claim Credential - Step 1.3: Add MobileCredentialHolder var

   // Claim Credential - Step 3.1: Add DiscoveredCredentialOffer and discoveredCredentialOfferURL vars

   // Claim Credential - Step 4.1: Add retrievedCredentials var


   // Proximity Presentation - Step 1.2: Create deviceEngagementString and proximityPresentationSession variables


   // Proximity and Online Presentation: Create variables for credential presentations


   // Online Presentation - Step 2.1: Create a variable to hold the online presentation session object


   var shouldDisplayOnlinePresentation: Bool {
       // Online Presentation - Step 3.4: View Online Presentation
       return false
   }

   // Claim Credential - Step 1.4: Initialize MobileCredentialHolder SDK

   @MainActor
   func getCredential(id: String) {
       // Proximity and Online Presentation: Retrieve a credential from storage
       print("This method will get a credential from storage and update the viewModel")
   }
}

// MARK: - Credential Retrieval

extension ViewModel {
   @MainActor
   func discoverCredentialOffer(_ offer: String) {
       // Claim Credential - Step 3.2: Add discover credential offer logic
       print("This method will discover a credentials offer and update viewModel")
   }

   @MainActor
   func retrieveCredential(transactionCode: String?) {
       // Claim Credential - Step 4.2: Call retrieveCredential method
       print("This method will save a credential from offer and store it in the application's storage ")
   }
}

// MARK: - Online Presentation

extension ViewModel {
   @MainActor
   func createOnlinePresentationSession(authorizationRequestURI: String) async {
       // Online Presentation - Step 2.3: Create online presentation session
       print("This method will create an online presentation session and update viewModel")
   }

   @MainActor
   func sendOnlinePresentationSessionResponse(id: String) {
       // Online Presentation - Step 4.1: Send online presentation response
       print("This method will be passed to a view and send a response with selected credentials")
   }
}

// MARK: - Proximity Presentation

extension ViewModel {
   func createDeviceEngagementString() {
       // Proximity Presentation - Step 1.3: Create function to create a proximity presentation session and generate QR code
       print("This method will create a device engagement string that will be converted to a QR code")
   }

   // Proximity Presentation - Step 1.4: Update function signature
   func onRequestReceived() {
       // Proximity Presentation - Step 2.2: Store credential requests and matched credentials
       print("The signature of this method will need to be updated to include the correct parameters")
       print("This is a method that will be called when a proximity presentation request is received")
   }

   @MainActor
   func sendProximityPresentationResponse(id: String) {
       // Proximity Presentation - Step 3.1: Send a credential response
       print("This method will be passed to a view and send a response with selected credentials")

   }
}

// MARK: - Navigation

enum NavigationState: Hashable {
   case qrScan
   case credentialOffer
   case transactionCodeInput
   case retrievedCredentials
   case onlinePresentation
   case presentCredentials
   case proximityPresentation
}

2. Add the following code after the // Claim Credential - Step 1.2: Import MobileCredentialHolderSDK comment to import MobileCredentialHolderSDK and enable using its capabilities in your application:

    import MobileCredentialHolderSDK

3. Add the following code after the // Claim Credential - Step 1.3: Add MobileCredentialHolder var comment to create a variable that holds the mobileCredentialHolder instance:

       var mobileCredentialHolder: MobileCredentialHolder

4. Add the following code after the // Claim Credential - Step 1.4: Initialize MobileCredentialHolder SDK comment. As of iOS Holder SDK v6.0.0, initialize is asynchronous, so we keep the init() synchronous (assigning the shared instance only) and perform initialization in an async method. We call this method from a .task modifier on the view in the next step, so it runs once when the view appears:

   init() {
       mobileCredentialHolder = MobileCredentialHolder.shared
   }
   
   @MainActor
   func initialize() async {
       do {
           try await mobileCredentialHolder.initialize(
               userAuthenticationConfiguration: UserAuthenticationConfiguration(userAuthenticationBehavior: .onDeviceKeyAccess),
               credentialIssuanceConfiguration: CredentialIssuanceConfiguration(
                   redirectUri: Constants.redirectUri,
                   autoTrustMobileCredentialIaca: true
               )
           )
       } catch {
           print(error)
       }
   }

   Let's review the parameters that are passed into initialize:

• userAuthenticationConfiguration: Defines when is user authentication required. In this example, authentication will only be required when a credential is issued and/or presented. Refer to the SDK Docs to see all options.
• CredentialIssuanceConfiguration :
  • redirectUri: This is the URI that the SDK uses to redirect the user back to your wallet application after authentication is complete. It must match the value you configured earlier in the development environment setup. This value is only used and required in the Authorization Code flow.
  • autoTrustMobileCredentialIaca: Controls how the SDK handles issuer IACA certificates during credential issuance.
    • If set to true, the SDK will automatically download and trust the issuer’s IACA certificate(s) when claiming a credential. This allows credentials to be claimed from any issuer.
    • If set to false, the SDK will only accept credentials from issuers whose IACA certificates have already been manually added to the SDK’s trusted issuers list (see addTrustedIssuerCertificates). This requires the application to manually manage IACA certificates.

5. Run the app to make sure it compiles properly.

For ease of implementation, you will use a third party framework to achieve this:

1. Add camera usage permissions to the app target:

2. Add the CodeScanner library via Swift Package Manager.

3. Create a new swift file named QRScannerView and add the following code into it to implement the QR scanning capability:

       import SwiftUI
       import CodeScanner
       import AVFoundation
   
       struct QRScannerView: View {
   
           private let completionHandler: (String) -> Void
   
           init(completion: @escaping (String) -> Void) {
               completionHandler = completion
           }
   
           var body: some View {
               CodeScannerView(codeTypes: [.qr]) { result in
                   switch result {
                   case .failure(let error):
                       print(error.localizedDescription)
                   case .success(let result):
                       print(result.string)
                       completionHandler(result.string)
                   }
               }
           }
   }

4. Return to the ContentView file and replace the EmptyView() under the // Claim Credential - Step 2.4 Create QRScannerView comment with the following code to create a new QRScannerView view in the application for scanning QR codes:

           QRScannerView(
               completion: { credentialOffer in
                   viewModel.discoverCredentialOffer(credentialOffer)
               }
           )

5. Run the app and tap the Claim Credential button. When prompted, grant camera access to allow QR code scanning.

You should see a result similar to the following:

As the user selects the Claim Credential button, the app launches the device camera to enable the user to scan a QR code.

You might notice that nothing happens after scanning a QR code - this is expected. In the next step you will implement the logic that retrieves the credential offer details from the QR code and presents them to the user.

To display this information to the user, your application should call the SDK's discoverCredentialOffer method. We are going to implement this within the ViewModel class.

1. Add the following code under the // Claim Credential - Step 3.1: Add DiscoveredCredentialOffer and discoveredCredentialOfferURL vars comment to add new variables that will hold the credential offer details:

   var discoveredCredentialOffer: DiscoveredCredentialOffer?
   var discoveredCredentialOfferURL = ""

2. Replace the print statement under the // Claim Credential - Step 3.2: Add discover credential offer logic comment with the following code to create a function that calls the SDK's discoverCredentialOffer method:

       Task {
           do {
               discoveredCredentialOffer = try await mobileCredentialHolder.discoverCredentialOffer(offer)
               // save the url to use for credential retrieval
               discoveredCredentialOfferURL = offer
               // present credential offer screen, as soon as credential offer is discovered
               navigationPath.append(NavigationState.credentialOffer)
           } catch {
               print(error)
           }
       }

   This function is called from our QRScannerView callback, so that when the user scans a QR Code that includes a credential offer, the discoverCredentialOffer method is called and accepts the returned credentialOffer string as its offer parameter.

   This is a URL-encoded Credential offer which in our example is embedded in a QR code. In other implementations you might have to retrieve this parameter from a deep-link.

   The discoverCredentialOffer method makes a request to the offer URL to retrieve the offer details and returns it as a DiscoveredCredentialOffer object:

   struct DiscoveredCredentialOffer {
       let issuer: URL
       let credentials: [OfferedCredential]
       let transactionCode: TransactionCode?
   }

   The application can now use the issuer and credentials properties and present this information for the user to review. Once an application has discovered a credential offer, the user is navigated to the credentialOfferView view, which you are going to implement next.

   Next you will use the transactionCode property to inspect whether or not the issuer requires a transaction code to claim the credential. This will enable the app to handle offers with and without a transaction code.

3. Create a new file named transactionCodeInputView and paste the following code to create a view that allows the user to input a transaction code when it is required by the issuer:

   import SwiftUI
   
   struct TransactionCodeInputView: View {
       var viewModel: ViewModel
       @State private var transactionCode = ""
       @Environment(\.dismiss) private var dismiss
   
       var body: some View {
           VStack(spacing: 20) {
               Text("Transaction Code Required")
                   .font(.title2)
                   .fontWeight(.bold)
   
               Text("Please enter the transaction code to proceed with credential retrieval.")
                   .multilineTextAlignment(.center)
                   .foregroundColor(.secondary)
   
               TextField("Enter transaction code", text: $transactionCode)
                   .textFieldStyle(RoundedBorderTextFieldStyle())
                   .padding(.horizontal)
   
               HStack(spacing: 20) {
                   Button("Cancel") {
                       dismiss()
                   }
                   .buttonStyle(.bordered)
   
                   Button("Retrieve Credentials") {
                       viewModel.retrieveCredential(transactionCode: transactionCode)
                   }
                   .buttonStyle(.borderedProminent)
                   .disabled(transactionCode.isEmpty)
               }
   
               Spacer()
           }
           .padding()
           .navigationTitle("Transaction Code")
           .navigationBarBackButtonHidden(false)
       }
   }

   The application will only show this view when the credential offer indicates a transaction code is required. The user will then be able to input a transaction code they had received separately from the issuer.

4. Return to ContentView file and replace the EmptyView under the // Claim Credential - Step: 3.4 Display transaction code input view comment with the following code to make use of the new view:

   TransactionCodeInputView(viewModel: viewModel)

5. Replace the EmptyView under the // Claim Credential - Step 3.5: Display Credential offer comment with the following code to navigate the user to the credentialOfferView view when a credential offer is discovered:

       VStack {
           Text("Received \(viewModel.discoveredCredentialOffer?.credentials.count ?? 0) Credential Offer(s)")
               .font(.headline)
           Text("from \(viewModel.discoveredCredentialOffer?.issuer.absoluteString ?? "unknown issuer")")
               .font(.subheadline)
           List(viewModel.discoveredCredentialOffer?.credentials ?? [], id: \.docType) { credential in
               Section {
                   HStack {
                       Text("Name:")
                           .bold()
                       Spacer()
                       Text("\(credential.name ?? "")")
                   }
                   HStack {
                       Text("Doctype:")
                           .bold()
                       Spacer()
                       Text("\(credential.docType)")
                   }
                   HStack {
                       Text("No. of claims:")
                           .bold()
                       Spacer()
                       Text("\(credential.claims?.count ?? 0)")
                   }
               }
           }
           Button {
               if viewModel.discoveredCredentialOffer?.transactionCode != nil {
                   viewModel.navigationPath.append(NavigationState.transactionCodeInput)
                   return
               }
               viewModel.retrieveCredential(transactionCode: nil)
           } label: {
               Text("Consent and retrieve Credential(s)")
                   .font(.title3)
           }
           .buttonStyle(.borderedProminent)
           .clipShape(Capsule())
       }

   The app now handles selection of the Consent and retrieve Credential(s) button based on the retrieved offer details:

   • For Pre-authorized Code offers:
     • If a transaction code is required, it will navigate the user to the TransactionCodeInputView view.
     • If no transaction code is required, it will call viewModel.retrieveCredential(transactionCode: nil) to retrieve the credential.
   • For Authorization Code offers:
     • The SDK will automatically redirect the user to a web browser to authenticate with issuer before continuing to retrieve the credential.

6. Run the app, select the Claim Credential button and scan the following QR code:

You should see a result similar to the following:

As the user scans the QR code, the application displays the credential offer details.

You might notice that nothing happens if you select the Consent and retrieve Credential(s) button. This is expected - in the next step you will implement the logic that initiates the credential issuance once the user provides their consent.

Once the user provides their consent by selecting the Consent and retrieve Credential(s) button, your application must call the SDK's retrieveCredentials function to trigger the credential issuance and store the issued credential in the application storage.

• For Pre-authorized Code offers, this will happen within the application and after the user provided a transaction code (when required by the issuer).
• For Authorization Code offers, this will happen after the user had completed authentication with the issuer and was redirected back to the application.

1. Add the following code under the // Claim Credential - Step 4.1: Add retrievedCredentials var comment to add a new variable that will hold the result returned by the SDK's retrieveCredentials method:

   var retrievedCredentials: [MobileCredential] = []

2. Replace the print statement under the // Claim Credential - Step 4.2: Call retrieveCredential method comment with the following code to create a new function that will call the SDK's retrieveCredentials method:

       Task {
           do {
               let retrievedCredentialResults = try await mobileCredentialHolder.retrieveCredentials(
                   credentialOffer: discoveredCredentialOfferURL,
                   clientId: Constants.clientId,
                   transactionCode: transactionCode
               )
               Task {
                   var credentials: [MobileCredential] = []
                   for result in retrievedCredentialResults {
                       switch result {
                       case .success(_, let credentialId):
                           if let credential = try? await mobileCredentialHolder.getCredential(credentialId: credentialId) {
                               credentials.append(credential)
                           }
                       case .failure(let docType, let error):
                           print("Failed to retrieve \(docType): \(error)")
                       }
                   }
                   self.retrievedCredentials = credentials
                   // Clear navigation stack and display retrievedCredentials view
                   navigationPath = NavigationPath()
                   navigationPath.append(NavigationState.retrievedCredentials)
               }
           } catch {
               print(error.localizedDescription)
           }
       }

Let’s review the parameters passed to the retrieveCredentials function:

• credentialOffer: This is the same credential offer string from the QR Code that we used to call discoverCredentialOffer with.
• clientId: This was configured when setting up your development environment. It is used by the issuer to identify the wallet application that is making a request to claim credentials.
• transactionCode: This is only required for Pre-authorized Code credential offers. If your application is only using Authorization Code flows offers, you should set it to nil.

The retrieveCredentials function returns an array of RetrieveCredentialResult objects. Each object contains metadata about a credential that was retrieved:

enum RetrieveCredentialResult {
    case success(docType: String, credentialId: String)
    case failure(docType: String, error: RetrieveCredentialError)
}

[
   {
      "docType":"org.iso.18013.5.1.mDL",
      "credentialId":"F52084CF-8270-4577-8EDD-23149639D985"
   }
]

RetrieveCredentialResult is an enum with two cases, each carrying guaranteed values:

• .success : Carries the docType and the credentialId (the internally unique identifier) of a successfully retrieved credential.
• .failure : Carries the docType and the error describing why retrieval failed.

After the result is received, your application can retrieve specific credentials by calling the SDK's getCredential method with the credentialId of any retrieved credential.

The SDK's getCredential method returns a MobileCredential object which can be used to display the retrieved credential, its claims and verification status to the user.

Since this object can be used across multiple views, it will make sense to create one view that will represent it. We will use this view in both the Proximity and Online presentation tutorials.

3. Create a new file named DocumentView and add the following content:

   import MobileCredentialHolderSDK
   import SwiftUI
   
       struct DocumentView: View {
   
           var viewModel: DocumentViewModel
   
           var body: some View {
               VStack(alignment: .leading, spacing: 10) {
                   Text(viewModel.docType)
                       .font(.title)
                       .fontWeight(.bold)
                       .padding(.bottom, 5)
   
                   ForEach(viewModel.namespacesAndClaims.keys.sorted(), id: \.self) { key in
                       VStack(alignment: .leading, spacing: 5) {
                           Text(key)
                               .font(.headline)
                               .padding(.vertical, 5)
                               .padding(.horizontal, 10)
                               .background(Color.gray.opacity(0.2))
                               .cornerRadius(5)
   
                           ForEach(viewModel.namespacesAndClaims[key]!.keys.sorted(), id: \.self) { claim in
                               HStack {
                                   Text(claim)
                                       .fontWeight(.semibold)
                                   Spacer()
                                   Text(viewModel.namespacesAndClaims[key]![claim]! ?? "")
                                       .fontWeight(.regular)
                               }
                               .padding(.vertical, 5)
                               .padding(.horizontal, 10)
                               .background(Color.white)
                               .cornerRadius(5)
                               .shadow(radius: 1)
                           }
                       }
                       .padding(.vertical, 5)
                   }
               }
               .padding()
               .background(RoundedRectangle(cornerRadius: 10).fill(Color.white).shadow(radius: 5))
               .padding(.horizontal)
           }
       }
   
       // MARK: DocumentViewModel
   
       class DocumentViewModel {
           var docType: String
   
           var namespacesAndClaims: [String: [String: String?]]
   
           init(from credential: MobileCredential) {
               self.docType = credential.docType
               self.namespacesAndClaims = credential.claims.reduce(into: [String: [String: String]]()) { result, outerElement in
                   let (outerKey, innerDict) = outerElement
                   result[outerKey] = innerDict.mapValues { $0.textRepresentation }
               }
           }
   
           init(from credentialMetadata: MobileCredentialMetadata) {
               self.docType = credentialMetadata.docType
               var result: [String: [String: String?]] = [:]
               credentialMetadata.claims.forEach { namespace, claimIDs in
                   var transformedClaims: [String: String?] = [:]
                   claimIDs.forEach { claimID in
                       transformedClaims[claimID] = Optional<String>.none
                   }
                   result[namespace] = transformedClaims
               }
               self.namespacesAndClaims = result
           }
   
           init(from request: MobileCredentialRequest) {
               self.docType = request.docType
               self.namespacesAndClaims = request.namespaces.reduce(into: [String: [String: String?]]()) { result, outerElement in
                   let (outerKey, innerDict) = outerElement
                   result[outerKey] = innerDict.mapValues { _ in nil }
               }
           }
       }
   
       // MARK: Helper
       extension MobileCredentialElementValue {
           var textRepresentation: String {
               switch self {
               case .bool(let bool):
                   return "\(bool)"
               case .string(let string):
                   return string
               case .int(let int):
                   return "\(int)"
               case .unsigned(let uInt):
                   return "\(uInt)"
               case .float(let float):
                   return "\(float)"
               case .double(let double):
                   return "\(double)"
               case let .date(date):
                   let dateFormatter = DateFormatter()
                   dateFormatter.dateStyle = .short
                   dateFormatter.timeStyle = .none
                   return dateFormatter.string(from: date)
               case let .dateTime(date):
                   let dateFormatter = DateFormatter()
                   dateFormatter.dateStyle = .short
                   dateFormatter.timeStyle = .short
                   return dateFormatter.string(from: date)
               case .data(let data):
                   return "Data \(data.count) bytes"
               case .map(let dictionary):
                   let result = dictionary.mapValues { value in
                       value.textRepresentation
                   }
                   return "\(result)"
               case .array(let array):
                   return array.reduce("") { partialResult, element in
                       partialResult + element.textRepresentation
                   }
                   .appending("")
               @unknown default:
                   return "Unknown type"
               }
           }
       }

   The file comprises the following components:

   • DocumentViewModel: This class stores the credentials' docType and claim values.
   • DocumentView: This view takes DocumentViewModel as a parameter and displays its content in a human-readable format.
   • MobileCredentialElementValue : This helper extension allows retrieving a MobileCredentialElementValue from a MobileCredential's claims and present it in a human-readable format.

4. Return to ContentView and replace EmptyView under the // Claim Credential - Step 4.4: Display retrieved credentials comment with the following code to use the DocumentView structure to display retrieved credentials to the user:

       ScrollView {
           VStack {
               Text("Retrieved Credentials")
                   .font(.title)
               ForEach(viewModel.retrievedCredentials, id: \.id) { credential in
                   DocumentView(viewModel: DocumentViewModel(from: credential))
               }
           }
       }

Once the app calls the retrieveCredentials function, the SDK processes the response based on the type of credential offer retrieved:

• In the Authorization Code flow:
  • The user is redirected to authenticate with the configured Authentication provider defined in the authorizeEndpoint element of the DiscoveredCredentialOffer object.
  • Upon successful authentication, the user can proceed to complete the OID4VCI workflow configured by the issuer. This workflow can include different steps based on the issuer’s configuration, but eventually the user is redirected to the configured redirectUri which should be handled by your application.
• In the Pre-authorized Code flow the user is not redirected out of the application, but rather provides a transaction code (when required by the issuer) and the immediately proceeds to claiming the credential. If no transaction code is required, the user can claim the credential immediately after selecting the Consent and retrieve Credential(s) button.

The issuer then sends the issued mDocs to your application, and the SDK processes and validates them against the ISO/IEC 18013-5:2021 standard. Credentials who meet validation rules are stored in the application internal data storage.