Split up issuance and presentation request content data models

WalletLibrary/WalletLibrary/Extensions/Entities/PresentationResponseContainer+WalletLibrary.swift

@@ -0,0 +1,53 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the MIT License. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+
+import VCEntities
+
+enum PresentationResponseError: Error, Equatable {
+    case unableToCastVCSDKPresentationRequestFromRawRequestOfType(String)
+    case unsupportedRequirementOfType(String)
+    case unableToCastVerifableCredentialFromVerifiedIdOfType(String)
+    case missingIdInVerifiedIdRequirement
+}
+
+/**
+ * An extension of the VCEntities.PresentationResponseContainer class
+ * to convert Requirements to mappings in PresentationResponseContainer.
+ */
+extension VCEntities.PresentationResponseContainer: PresentationResponse {
+
+    init(rawRequest: any OpenIdRawRequest) throws {
+
+        guard let presentationRequest = rawRequest as? VCEntities.PresentationRequest else {
+            let requestType = String(describing: type(of: rawRequest))
+            throw PresentationResponseError.unableToCastVCSDKPresentationRequestFromRawRequestOfType(requestType)
+        }
+
+        try self.init(from: presentationRequest)
+    }
+
+    mutating func add(requirement: Requirement) throws {
+        switch (requirement) {
+        case let groupRequirement as GroupRequirement:
+            try add(groupRequirement: groupRequirement)
+        case let verifiedIdRequirement as VerifiedIdRequirement:
+            try add(verifiedIdRequirement: verifiedIdRequirement)
+        default:
+            let requirementType = String(describing: type(of: requirement))
+            throw PresentationResponseError.unsupportedRequirementOfType(requirementType)
+        }
+    }
+
+    private mutating func add(groupRequirement: GroupRequirement) throws {
+        try groupRequirement.validate()
+        for requirement in groupRequirement.requirements {
+            try add(requirement: requirement)
+        }
+    }
+
+    private mutating func add(verifiedIdRequirement: VerifiedIdRequirement) throws {
+        throw VerifiedIdClientError.TODO(message: "Implement in next PR.")
+    }
+}

WalletLibrary/WalletLibrary/Extensions/Mappings/VCSDK/Issuance/IssuanceRequest+Mappable.swift

@@ -10,16 +10,16 @@ import VCEntities
  * TODO: Update Style to include VerifiedIdStyle and more requester style attributes.
  */
 extension VCEntities.IssuanceRequest: Mappable {
-    func map(using mapper: Mapping) throws -> VerifiedIdRequestContent {
+    func map(using mapper: Mapping) throws -> IssuanceRequestContent {
 
         let attestations = try getRequiredProperty(property: content.input.attestations,
                                                    propertyName: "attestations")
         let requirement = try mapper.map(attestations)
         let rootOfTrust = try mapper.map(linkedDomainResult)
         let issuerStyle = Manifest2022IssuerStyle(name: content.display.card.issuedBy)
 
-        return VerifiedIdRequestContent(style: issuerStyle,
-                                        requirement: requirement,
-                                        rootOfTrust: rootOfTrust)
+        return IssuanceRequestContent(style: issuerStyle,
+                                      requirement: requirement,
+                                      rootOfTrust: rootOfTrust)
     }
 }

WalletLibrary/WalletLibrary/Extensions/Mappings/VCSDK/Presentation/PresentationRequest+Mappable.swift

@@ -18,7 +18,7 @@ enum PresentationRequestMappingError: Error {
  */
 extension VCEntities.PresentationRequest: Mappable {
 
-    func map(using mapper: Mapping) throws -> VerifiedIdRequestContent {
+    func map(using mapper: Mapping) throws -> PresentationRequestContent {
 
         guard let presentationDefinition = content.claims?.vpToken?.presentationDefinition else {
             throw PresentationRequestMappingError.presentationDefinitionMissingInRequest
@@ -31,10 +31,10 @@ extension VCEntities.PresentationRequest: Mappable {
         let clientName = content.registration?.clientName ?? ""
         let requesterStyle = OpenIdVerifierStyle(name: clientName)
 
-        let content = VerifiedIdRequestContent(style: requesterStyle,
-                                               requirement: requirement,
-                                               rootOfTrust: rootOfTrust,
-                                               injectedIdToken: injectedIdToken)
+        let content = PresentationRequestContent(style: requesterStyle,
+                                                 requirement: requirement,
+                                                 rootOfTrust: rootOfTrust,
+                                                 injectedIdToken: injectedIdToken)
 
         return content
     }

WalletLibrary/WalletLibrary/Extensions/Services/PresentationService+OpenIdForVC.swift

@@ -6,10 +6,14 @@
 import VCEntities
 import VCServices
 
+enum PresentationServiceError: Error {
+    case unableToCastOpenIdForVCResponseToPresentationResponseContainer
+}
+
 /**
  * An extension of the VCServices.PresentationService class.
  */
-extension PresentationService: OpenIdForVCResolver, OpenIdForVCResponder {
+extension PresentationService: OpenIdForVCResolver, OpenIdResponder {
 
     /// Fetches and validates the presentation request.
     func getRequest(url: String) async throws -> any OpenIdRawRequest {
@@ -20,9 +24,14 @@ extension PresentationService: OpenIdForVCResolver, OpenIdForVCResponder {
 
     /// Sends the presentation response container and if successful, returns void,
     /// If unsuccessful, throws an error.
-    func send(response: VCEntities.PresentationResponseContainer) async throws -> Void {
+    func send(response: PresentationResponse) async throws -> Void {
+
+        guard let presentationResponseContainer = response as? PresentationResponseContainer else {
+            throw PresentationServiceError.unableToCastOpenIdForVCResponseToPresentationResponseContainer
+        }
+
         let _ = try await AsyncWrapper().wrap { () in
-            self.send(response: response)
+            self.send(response: presentationResponseContainer)
         }()
     }
 }

WalletLibrary/WalletLibrary/Protocols/Requests/RawRequests/RawManifest.swift → WalletLibrary/WalletLibrary/Protocols/Requests/Manifest/RawManifest.swift

@@ -7,5 +7,5 @@
  * Representation of a Raw Contract.
  * Object that conforms to this protocol must be able to map to VerifiedIdRequestContent.
  */
-protocol RawManifest: Mappable where T == VerifiedIdRequestContent {}
+protocol RawManifest: Mappable where T == IssuanceRequestContent {}
 

WalletLibrary/WalletLibrary/Protocols/Requests/RawRequests/OpenIdRawRequest.swift → WalletLibrary/WalletLibrary/Protocols/Requests/OpenId/OpenIdRawRequest.swift

@@ -7,9 +7,7 @@
  * Representation of a Raw Open Id Request.
  * Object that conforms to this protocol must be able to map to VerifiedIdRequestContent.
  */
-protocol OpenIdRawRequest: Mappable where T == VerifiedIdRequestContent {
+protocol OpenIdRawRequest: Mappable where T == PresentationRequestContent {
 
     var type: RequestType { get }
-
-    var raw: Data? { get }
 }

WalletLibrary/WalletLibrary/Protocols/Requests/OpenIdForVC/OpenIdForVCResponder.swift → WalletLibrary/WalletLibrary/Protocols/Requests/OpenId/OpenIdResponder.swift

@@ -8,8 +8,8 @@ import VCEntities
 /**
  * Protocol is used as a wrapper to wrap the VC SDK send presentation response method.
  */
-protocol OpenIdForVCResponder {
-    /// Sends the presentation response container and if successful, returns void,
+protocol OpenIdResponder {
+    /// Sends the presentation response and if successful, returns void,
     /// If unsuccessful, throws an error.
-    func send(response: PresentationResponseContainer) async throws -> Void
+    func send(response: PresentationResponse) async throws -> Void
 }

WalletLibrary/WalletLibrary/Protocols/Requests/PresentationResponse.swift

@@ -0,0 +1,12 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the MIT License. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+
+/**
+ * An object that describes a raw presense response and defines the behavior of adding a requirement to it.
+ * For example, a VCSDK.PresentationResponseContainer conforms to this protocol.
+ */
+protocol PresentationResponse {
+    mutating func add(requirement: Requirement) throws
+}

WalletLibrary/WalletLibrary/Requests/Handlers/OpenIdRequestHandler.swift

@@ -19,17 +19,21 @@ struct OpenIdRequestHandler: RequestHandling {
 
     private let configuration: LibraryConfiguration
 
+    private let openIdResponder: OpenIdResponder
+
     private let manifestResolver: ManifestResolver
 
-    private let verifiableCredentialRequester: VerifiedIdRequester
+    private let verifiedIdRequester: VerifiedIdRequester
 
     /// TODO: post private preview, manifest resolving and verified id requester will be handled by processors.
     init(configuration: LibraryConfiguration,
+         openIdResponder: OpenIdResponder,
          manifestResolver: ManifestResolver,
          verifiableCredentialRequester: VerifiedIdRequester) {
         self.configuration = configuration
+        self.openIdResponder = openIdResponder
         self.manifestResolver = manifestResolver
-        self.verifiableCredentialRequester = verifiableCredentialRequester
+        self.verifiedIdRequester = verifiableCredentialRequester
     }
 
     /// Create a VeriifiedIdRequest based on the Open Id raw request given.
@@ -45,10 +49,10 @@ struct OpenIdRequestHandler: RequestHandling {
             return try await handleIssuanceRequest(from: requestContent)
         }
 
-        return try handlePresentationRequest(from: requestContent)
+        return handlePresentationRequest(requestContent: requestContent, rawRequest: request)
     }
 
-    private func handleIssuanceRequest(from requestContent: VerifiedIdRequestContent) async throws -> any VerifiedIdIssuanceRequest {
+    private func handleIssuanceRequest(from requestContent: PresentationRequestContent) async throws -> any VerifiedIdIssuanceRequest {
 
         guard let verifiedIdRequirement = requestContent.requirement as? VerifiedIdRequirement else {
             throw OpenIdRequestHandlerError.unableToCastRequirementToVerifiedIdRequirement
@@ -69,11 +73,15 @@ struct OpenIdRequestHandler: RequestHandling {
 
         return ContractIssuanceRequest(content: issuanceRequestContent,
                                        issuanceResponseContainer: issuanceResponseContainer,
-                                       verifiedIdRequester: verifiableCredentialRequester,
+                                       verifiedIdRequester: verifiedIdRequester,
                                        configuration: configuration)
     }
 
-    private func handlePresentationRequest(from requestContent: VerifiedIdRequestContent) throws -> any VerifiedIdPresentationRequest {
-        return OpenIdPresentationRequest(content: requestContent, configuration: configuration)
+    private func handlePresentationRequest(requestContent: PresentationRequestContent,
+                                           rawRequest: any OpenIdRawRequest) -> any VerifiedIdPresentationRequest {
+        return OpenIdPresentationRequest(content: requestContent,
+                                         rawRequest: rawRequest,
+                                         openIdResponder: openIdResponder,
+                                         configuration: configuration)
     }
 }

WalletLibrary/WalletLibrary/Requests/VerifiedIdRequestContent.swift → WalletLibrary/WalletLibrary/Requests/IssuanceRequestContent.swift

@@ -4,50 +4,49 @@
 *--------------------------------------------------------------------------------------------*/
 
 /**
- * Contents in a Verified Id Request.
+ * Contents in a Verified Id Issuance Request.
  * This object is used to map protocol specific requests to common request object.
- * TODO: make this object extensible by separating Presentation with Issuance esp. for InjectedIdToken logic.
  * TODO: add VerifiedIdStyle to Issuance Content.
  */
-struct VerifiedIdRequestContent {
+struct IssuanceRequestContent {
+
+    private struct Constants {
+        static let IdTokenHintKey = "https://self-issued.me"
+    }
 
     let style: RequesterStyle
 
     var requirement: Requirement
 
     let rootOfTrust: RootOfTrust
 
-    let injectedIdToken: InjectedIdToken?
-
-    init(style: RequesterStyle,
-         requirement: Requirement,
-         rootOfTrust: RootOfTrust,
-         injectedIdToken: InjectedIdToken? = nil) {
-        self.style = style
-        self.requirement = requirement
-        self.rootOfTrust = rootOfTrust
-        self.injectedIdToken = injectedIdToken
-    }
-
     mutating func addRequirement(from injectedIdToken: InjectedIdToken) {
         switch (requirement) {
         case var groupRequirement as GroupRequirement:
             repopulateGroupRequirementIfInjectedIdTokenExists(injectedIdToken: injectedIdToken,
-                                                              groupRequirement: &groupRequirement)
+                                                              groupRequirement: groupRequirement)
         case let idTokenRequirement as IdTokenRequirement:
+            addInjectedIdTokenHintToIdTokenRequirement(injectedIdToken: injectedIdToken,
+                                                       idTokenRequirement: idTokenRequirement)
+        default:
+            return
+        }
+    }
+
+    private mutating func addInjectedIdTokenHintToIdTokenRequirement(injectedIdToken: InjectedIdToken,
+                                                                     idTokenRequirement: IdTokenRequirement) {
+        if idTokenRequirement.configuration.absoluteString == Constants.IdTokenHintKey {
             idTokenRequirement.fulfill(with: injectedIdToken.rawToken)
             if let pinRequirement = injectedIdToken.pin {
                 requirement = GroupRequirement(required: false,
                                                requirements: [idTokenRequirement, pinRequirement],
                                                requirementOperator: .ALL)
             }
-        default:
-            return
         }
     }
 
     private func repopulateGroupRequirementIfInjectedIdTokenExists(injectedIdToken: InjectedIdToken,
-                                                                   groupRequirement: inout GroupRequirement) {
+                                                                   groupRequirement: GroupRequirement) {
         for requirement in groupRequirement.requirements {
             if let idTokenRequirement = requirement as? IdTokenRequirement {
                 idTokenRequirement.fulfill(with: injectedIdToken.rawToken)

WalletLibrary/WalletLibrary/Requests/RequestProtocols/Manifest/ContractIssuanceRequest.swift → WalletLibrary/WalletLibrary/Requests/Manifest/ContractIssuanceRequest.swift

@@ -23,7 +23,7 @@ class ContractIssuanceRequest: VerifiedIdIssuanceRequest {
 
     private var responseContainer: IssuanceResponseContaining
 
-    init(content: VerifiedIdRequestContent,
+    init(content: IssuanceRequestContent,
          issuanceResponseContainer: IssuanceResponseContaining,
          verifiedIdRequester: VerifiedIdRequester,
          configuration: LibraryConfiguration) {

WalletLibrary/WalletLibrary/Requests/RequestProtocols/OpenId/OpenIdPresentationRequest.swift → WalletLibrary/WalletLibrary/Requests/OpenId/OpenIdPresentationRequest.swift

@@ -15,12 +15,22 @@ class OpenIdPresentationRequest: VerifiedIdPresentationRequest {
 
     let rootOfTrust: RootOfTrust
 
+    private let rawRequest: any OpenIdRawRequest
+
+    private let responder: OpenIdResponder
+
     private let configuration: LibraryConfiguration
 
-    init(content: VerifiedIdRequestContent, configuration: LibraryConfiguration) {
+    init(content: PresentationRequestContent,
+         rawRequest: any OpenIdRawRequest,
+         openIdResponder: OpenIdResponder,
+         configuration: LibraryConfiguration) {
+
         self.style = content.style
         self.requirement = content.requirement
         self.rootOfTrust = content.rootOfTrust
+        self.rawRequest = rawRequest
+        self.responder = openIdResponder
         self.configuration = configuration
     }
 

WalletLibrary/WalletLibrary/Requests/PresentationRequestContent.swift

@@ -0,0 +1,29 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the MIT License. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+
+/**
+ * Contents in a Verified Id Presentation Request.
+ * This object is used to map protocol specific requests to common request object.
+ */
+struct PresentationRequestContent {
+
+    let style: RequesterStyle
+
+    var requirement: Requirement
+
+    let rootOfTrust: RootOfTrust
+
+    let injectedIdToken: InjectedIdToken?
+
+    init(style: RequesterStyle,
+         requirement: Requirement,
+         rootOfTrust: RootOfTrust,
+         injectedIdToken: InjectedIdToken? = nil) {
+        self.style = style
+        self.requirement = requirement
+        self.rootOfTrust = rootOfTrust
+        self.injectedIdToken = injectedIdToken
+    }
+}

WalletLibrary/WalletLibrary/VerifiedIdClientBuilder.swift

@@ -51,7 +51,9 @@ public class VerifiedIdClientBuilder {
 
     private func registerSupportedRequestHandlers(with configuration: LibraryConfiguration) {
         let issuanceService = IssuanceService()
+        let presentationService = PresentationService()
         let openIdHandler = OpenIdRequestHandler(configuration: configuration,
+                                                 openIdResponder: presentationService,
                                                  manifestResolver: issuanceService,
                                                  verifiableCredentialRequester: issuanceService)
         requestHandlers.append(openIdHandler)