@pagopa/io-react-native-iso18013 0.3.0 → 0.5.0

package/ios/IoReactNativeIso18013.swift

@@ -5,8 +5,6 @@ import React
 @objc(IoReactNativeIso18013)
 class IoReactNativeIso18013: RCTEventEmitter {
   
-  private typealias ME = ModuleException
-  
   @objc
   override static func requiresMainQueueSetup() -> Bool {
     return true
@@ -39,8 +37,7 @@ class IoReactNativeIso18013: RCTEventEmitter {
   
   /**
    Starts the proximity flow by allocating the necessary resources and initializing the Bluetooth stack.
-   Resolves to true or rejects if an error occurs.
-    
+   Resolves to true or rejects with an error code defined in ``ModuleErrorCodes``.
    - Parameters:
       - certificates: Two-dimensional array of base64 strings representing DER encoded X.509 certificate which are used to authenticate the verifier app
       - resolve: The promise to be resolved
@@ -49,56 +46,60 @@ class IoReactNativeIso18013: RCTEventEmitter {
   @objc(start:withResolver:withRejecter:)
   func start(
     certificates: [Any],
-    _ resolve: @escaping RCTPromiseResolveBlock,
+    resolve: @escaping RCTPromiseResolveBlock,
     reject: @escaping RCTPromiseRejectBlock
   ){
     do {
-      let certsData = parseCertificates(certificates)
+      let certsData = try parseCertificates(certificates)
       try Proximity.shared.start(certsData)
       resolve(true)
-    } catch let error {
-      ME.startError.reject(reject: reject, ("error", error.localizedDescription))
+    } catch let proximityError as ProximityError {
+      reject(ModuleErrorCodes.generateResponseError.rawValue, proximityError.description, proximityError)
+    } catch let parsingError as ParsingError{
+      reject(ModuleErrorCodes.generateResponseError.rawValue, parsingError.description, parsingError)
+    } catch {
+      reject(ModuleErrorCodes.generateResponseError.rawValue, error.localizedDescription, error)
     }
   }
   
   /**
    Utility function to parse an array coming from the React Native Bridge into an array of Data representing DER encoded X.509 certificates.
-   
    - Parameters:
-      - certificates:Two-dimensional array of base64 strings representing DER encoded X.509 certificate
-   
+      - certificates: Two-dimensional array of base64 strings representing DER encoded X.509 certificate
+    - Throws: `ParsingError` if the provided certificate is not a valid base64 encoded string.
     - Returns: A two-dimensional array of Data containing DER encoded X.509 certificates.
   */
-  private func parseCertificates(_ certificates: Array<Any>) -> [[Data]] {
-    return certificates.compactMap { item in
+  private func parseCertificates(_ certificates: [Any]) throws -> [[Data]] {
+    return try certificates.enumerated().compactMap { (chainIndex, item) in
       guard let certStrings = item as? [String] else {
-        return nil
+        throw ParsingError.certificatesNotValid("Certificate chain at index \(chainIndex) is not an array of strings.")
       }
-      let dataArray = certStrings.compactMap { certString in
-          Data(base64Encoded: certString)
+      return try certStrings.enumerated().map { (certIndex, certString) in
+        guard let data = Data(base64Encoded: certString) else {
+          throw ParsingError.certificatesNotValid("Certificate at index \(certIndex) in the chain at index \(chainIndex) is not a valid base64 string.")
+        }
+        return data
       }
-      return dataArray.isEmpty ? nil : dataArray
     }
   }
   
   /**
    Creates a QR code to be scanned in order to initialize the presentation.
-   Resolves with the QR code strings.
-
+   Resolves with a string containing the QR code or rejects with an error code defined in ``ModuleErrorCodes``.
    - Parameters:
       - resolve: The promise to be resolved
       - reject: The promise to be rejected
-  */
+   */
   @objc(getQrCodeString:withRejecter:)
   func getQrCodeString(
-    _ resolve: @escaping RCTPromiseResolveBlock,
+    resolve: @escaping RCTPromiseResolveBlock,
     reject: @escaping RCTPromiseRejectBlock
   ) {
     do{
       let qrCodeString = try Proximity.shared.getQrCode()
       resolve(qrCodeString)
-    } catch let error {
-      ME.qrCodeError.reject(reject: reject, ("error", error.localizedDescription))
+    } catch {
+      reject(ModuleErrorCodes.getQrCodeError.rawValue, error.localizedDescription, error)
     }
   }
   
@@ -106,33 +107,35 @@ class IoReactNativeIso18013: RCTEventEmitter {
    Parses an array of documents from the React Native bridge which doesn't have any typing to an array of ``IOWalletProximity.ProximityDocument``.
    It checks if each element in the array has  `issuerSignedContent`, `alias` and `docType` properties in order to build a ``IOWalletProximity.ProximityDocument``, then it appens it to the array.
    The result can be fed to ``IOWalletProximity.generateResponse``.
-   
    - Parameters:
       - documents: An array containing documents. Each document is defined as a map containing:
          - issuerSignedContent which is a base64 or base64url encoded string representing the credential;
          - alias which is the alias of the key used to sign the credential;
          - docType which is the document type.
-   
-   - Throws: `ModuleException.invalidDocRequested.error()` and `ModuleException.invalidDocRequested.error()` iif an error occurs while parsing the document
-   
-   - Returns: An array of `ProximityDocument` containg the documents to be presented
+   - Throws: `ParsingError`:
+      - If the provided documents array do not contain a dictionary;
+      - If the provided dictionary doesn't adhere to the structure we expect;
+      - If the issuerSignedContent is not a valid base64 or base64url encoded string;
+      - If the creation of a ProximityDdocument fails.
+   - Returns: An array of `ProximityDocument` containg the documents to be presented.
    */
   private func parseDocuments(documents: [Any]) throws -> [ProximityDocument] {
-    return try documents.compactMap{ (element) -> ProximityDocument in
-      guard let dict : [String: Any] = element as? [String: Any] else { throw ModuleException.unableToDecode.error() }
+    return try documents.map{ (element) -> ProximityDocument in
+      guard let dict : [String: Any] = element as? [String: Any] else { throw ParsingError.documentsNotValid("The provided documents array element can't be parsed as a dictionary") }
       guard
         let issuerSignedContent = dict["issuerSignedContent"] as? String,
         let alias = dict["alias"] as? String,
         let docType = dict["docType"] as? String,
         let decodedIssuerSignedContent = try? Base64Utils.decodeBase64OrBase64URL(base: issuerSignedContent)
-      else { throw ModuleException.invalidDocRequested.error() }
-      
+      else {
+        throw ParsingError.documentsNotValid ("The provided issuerSignedContent is not a valid base64 or base64url or don't contain the required fields alas, doctype and issuerSignedContent")
+      }
       guard let document = ProximityDocument(
         docType: docType,
         issuerSigned: [UInt8](decodedIssuerSignedContent),
         deviceKeyTag: alias
       ) else {
-        throw ModuleException.invalidDocRequested.error()
+        throw ParsingError.documentsNotValid("The parsing for the document with docType \(docType) failed")
       }
       return document
     }
@@ -142,72 +145,58 @@ class IoReactNativeIso18013: RCTEventEmitter {
    Parses a dictionary of accepted fields for the presentation from the React Native bridge which doesn't have any typing to a ``AcceptedFieldsDict`` dictionary.
    It checks if each element in the array is a dictionary where the key is a string, and the value is another dictionary. This nested dictionary has a string as its key and a boolean as its value, then it appens it to the array.
    The result can be fed to ``IOWalletProximity.generateResponse``.
-   
    - Parameters:
-      - acceptedFields: A dictionary of any elements. In order to be added to the result dictionary each element must be shaped as ``AcceptedFieldsDict`` thus as [String: [String: [String: Bool]]]
-   
-   - Throws: `NSError` if a value doesn't has the ``AcceptedFieldsDict`` shape or the result dictionary is empty
-   
-   - Returns: An ``AcceptedFieldsDict`` containg the accepted fields to be presented
-   
+      - acceptedFields: A dictionary of any elements. In order to be added to the result dictionary each element must be shaped as ``AcceptedFieldsDict`` thus as [String: [String: [String: Bool]]].
+   - Throws: `ParsingError` if a value doesn't has the ``AcceptedFieldsDict`` shape or the result dictionary is empty.
+   - Returns: An ``AcceptedFieldsDict`` containg the accepted fields to be presented.
    */
-  private func parseAcceptedFields(acceptedFields: [AnyHashable: Any]) throws -> AcceptedFieldsDict {
+  private func parseAcceptedFields(acceptedFields: [AnyHashable: Any]) throws(ParsingError) -> AcceptedFieldsDict {
     var result: AcceptedFieldsDict = [:]
     
     for (key, value) in acceptedFields {
       guard let keyString = key as? String else {
-        throw NSError(domain: "ParseAcceptedFields", code: -1, userInfo: [NSLocalizedDescriptionKey: "Key must be a String."])
+        throw ParsingError.acceptedFieldsNotValid("The accepted fields keys must be a String")
       }
       guard let valueDict = value as? [String: [String: Bool]] else {
-        throw NSError(domain: "ParseAcceptedFields", code: -1, userInfo: [NSLocalizedDescriptionKey: "Value must be of type [String: [String: Bool]]."])
+        throw ParsingError.acceptedFieldsNotValid("The accepted fields values must be of type [String: [String: Bool]]")
       }
       result[keyString] = valueDict
     }
     
-    if(result.isEmpty){
-      throw NSError(domain: "ParseAcceptedFields", code: -1, userInfo: [NSLocalizedDescriptionKey: "Error parsing documents"])
-    }
-    
     return result
   }
   
   /**
-     Generates a response containing the documents and the fields which the user decided to present.
-     It parses the untyped ``documents`` and ``acceptedFields`` parameters and feeds them to the ``IOWalletProximity.generateDeviceResponse`` function.
-     It resolves the promise with the response as a base64 encoded string.
-     It rejects the promise if an error occurs during the parameters parsing or while generating the device response.
-     
-     - Parameters:
-       - documents: An array containing documents. Each document is defined as a map containing:
-           - issuerSignedContent which is a base64 or base64url encoded string representing the credential;
-           - alias which is the alias of the key used to sign the credential;
-           - docType which is the document type.
-       - issuerSignedContent which is a base64 or base64url encoded string representing the credential;
-       - alias which is the alias of the key used to sign the credential;
-       - docType which is the document type.
-       - acceptedFields: A dictionary of elements, where each element must adhere to the structure of AcceptedFieldsDict—specifically, a [String: [String: [String: Bool]]]. The outermost key represents the credentia doctypel. The inner dictionary contains namespaces, and for each namespace, there is another dictionary mapping requested claims to a boolean value, which indicates whether the user is willing to present the corresponding claim. Example:
+   Generates a response containing the documents and the fields which the user decided to present.
+   It parses the untyped ``documents`` and ``acceptedFields`` parameters and feeds them to the ``IOWalletProximity.generateDeviceResponse`` function.
+   Resolves with a base64 encoded response or rejects with an error code defined in ``ModuleErrorCodes``.
+   - Parameters:
+     - documents: An array containing documents. Each document is defined as a map containing:
+         - issuerSignedContent which is a base64 or base64url encoded string representing the credential;
+         - alias which is the alias of the key used to sign the credential;
+         - docType which is the document type.
+     - acceptedFields: A dictionary of elements, where each element must adhere to the structure of AcceptedFieldsDict—specifically, a [String: [String: [String: Bool]]]. The outermost key represents the credential doctype. The inner dictionary contains namespaces, and for each namespace, there is another dictionary mapping requested claims to a boolean value, which indicates whether the user is willing to present the corresponding claim. Example:
         
          
-             {
-                "org.iso.18013.5.1.mDL": {
-                  "org.iso.18013.5.1": {
-                    "hair_colour": true,
-                    "given_name_national_character": true,
-                    "family_name_national_character": true,
-                    "given_name": true,
-                  }
+           {
+              "org.iso.18013.5.1.mDL": {
+                "org.iso.18013.5.1": {
+                  "hair_colour": true,
+                  "given_name_national_character": true,
+                  "family_name_national_character": true,
+                  "given_name": true,
                 }
-             }
-    
-       - resolve: The promise to be resolved
-       - reject: The promise to be rejected
-     
-     */
+              }
+           }
+  
+     - resolve: The promise to be resolved.
+     - reject: The promise to be rejected.
+   */
   @objc(generateResponse:withAcceptedFields:withResolver:withRejecter:)
   func generateResponse(
     documents: Array<Any>,
     acceptedFields: [AnyHashable: Any],
-    _ resolve: @escaping RCTPromiseResolveBlock,
+    resolve: @escaping RCTPromiseResolveBlock,
     reject: @escaping RCTPromiseRejectBlock
   ){
     do {
@@ -216,16 +205,21 @@ class IoReactNativeIso18013: RCTEventEmitter {
       let deviceResponse = try Proximity.shared.generateDeviceResponse(items: items, documents: parsedDocuments, sessionTranscript: nil)
       let strDeviceResponse = Data(deviceResponse).base64EncodedString()
       resolve(strDeviceResponse)
-    }catch{
-      ME.generateDeviceResponseError.reject(reject: reject, ("error", error.localizedDescription))
+    }
+    catch let proximityError as ProximityError {
+      reject(ModuleErrorCodes.generateResponseError.rawValue, proximityError.description, proximityError)
+    }
+    catch let parsingError as ParsingError {
+      reject(ModuleErrorCodes.generateResponseError.rawValue, parsingError.description, parsingError)
+    } catch {
+      reject(ModuleErrorCodes.generateResponseError.rawValue, error.localizedDescription, error)
     }
   }
   
   /**
    Sends a response containing the documents and the fields which the user decided to present generated by ``generateResponse``.
-   It resolves to true after sending the response, otherwise it rejects if an error occurs while decoding the response.
    Currently there's not evidence of the verifier app responding to this request, thus we don't handle the response.
-   
+   Resolves with a true boolean in case of success or rejects with an error code defined in ``ModuleErrorCodes``.
    - Parameters:
      - response: A base64 encoded string containing the response generated by ``generateResponse``
      - resolve: The promise to be resolved
@@ -234,7 +228,7 @@ class IoReactNativeIso18013: RCTEventEmitter {
   @objc(sendResponse:withResolver:withRejecter:)
   func sendResponse(
     response: String,
-    _ resolve: @escaping RCTPromiseResolveBlock,
+    resolve: @escaping RCTPromiseResolveBlock,
     reject: @escaping RCTPromiseRejectBlock
   ){
     do{
@@ -244,50 +238,49 @@ class IoReactNativeIso18013: RCTEventEmitter {
         resolve(true)
       }
     }catch let error {
-      ME.sendResponseError.reject(reject: reject, ("error", error.localizedDescription))
+      reject(ModuleErrorCodes.sendResponseError.rawValue, error.localizedDescription, error)
     }
   }
   
   /**
    Sends an error response during the presentation according to the SessionData status codes defined in table 20 of the ISO18013-5 standard.
+   Resolves to true or rejects with an error code defined in ``ModuleErrorCodes``.
    - Parameters:
-     - status: The status error to be sent is an integer of type ``SessionDataStatus``:
+     - code: The status error to be sent is an integer of type ``SessionDataStatus``:
        ```
          10 -> Error: session encryption
          11 -> Error: CBOR decoding
          20 -> Session termination
        ```
-     - resolve: The promise to be resolved
-     - reject: The promise to be rejected
+     - resolve: The promise to be resolved.
+     - reject: The promise to be rejected.
    */
   @objc(sendErrorResponse:withResolver:withRejecter:)
-  func sendErrorResponse(status: UInt64, _ resolve: @escaping RCTPromiseResolveBlock,
-                               reject: @escaping RCTPromiseRejectBlock){
+  func sendErrorResponse(code: UInt64, _ resolve: @escaping RCTPromiseResolveBlock,
+                           reject: @escaping RCTPromiseRejectBlock){
     do{
-      if let statusEnum = SessionDataStatus(rawValue: status) {
+      if let statusEnum = SessionDataStatus(rawValue: code) {
         try Proximity.shared.errorPresentation(statusEnum)
       } else {
-        ME.sendResponseError.reject(reject: reject, ("error", "Invalid status code"))
+        reject(ModuleErrorCodes.sendErrorResponseError.rawValue, "Invalid status code provided: \(code)", nil)
       }
       resolve(true)
     }catch let error{
-      ME.sendResponseError.reject(reject: reject, ("error", error.localizedDescription))
+      reject(ModuleErrorCodes.sendErrorResponseError.rawValue, error.localizedDescription, error)
     }
   }
   
   
   /**
    Closes the bluetooth connection and clears any resource.
-   It resolves to true after closing the connection.
-   
+   Resolves to true after closing the connection or rejects with an error code defined in ``ModuleErrorCodes``.
    - Parameters:
-     - resolve: The promise to be resolved
-     - reject:  The promise to be rejected
-   
+     - resolve: The promise to be resolved.
+     - reject:  The promise to be rejected.
    */
   @objc(close:withRejecter:)
   func close(
-    _ resolve: @escaping RCTPromiseResolveBlock,
+    resolve: @escaping RCTPromiseResolveBlock,
     reject: @escaping RCTPromiseRejectBlock
   ) {
     Proximity.shared.stop()
@@ -295,13 +288,11 @@ class IoReactNativeIso18013: RCTEventEmitter {
   }
   
   /**
-     Converts a device requested from the `onDocumentRequestReceived` callback into a serializable JSON.
-     
-     - Parameters:
-        - request: The request returned from `onDocumentRequestReceived` which contains an array of tuples consists of a doctype, namespaces and the requested claims with a boolean value indicating wether or not the device which is making the request has an intent to retain the dataß
-     
-     - Returns: A JSON string representing the device request or nil if an error occurs
-    */
+   Converts a device requested from the `onDocumentRequestReceived` callback into a serializable JSON.
+   - Parameters:
+      - request: The request returned from `onDocumentRequestReceived` which contains an array of tuples consists of a doctype, namespaces and the requested claims with a boolean value indicating wether or not the device which is making the request has an intent to retain the data.
+   - Returns: A JSON string representing the device request or nil if an error occurs.
+   */
   private func deviceRequestToJson(request: [(docType: String, nameSpaces: [String: [String: Bool]], isAuthenticated: Bool)]?) -> String? {
     var jsonRequest : [String: AnyHashable] = [:]
     request?.forEach({
@@ -379,115 +370,103 @@ class IoReactNativeIso18013: RCTEventEmitter {
     }
   }
   
-  @objc func generateOID4VPDeviceResponse(
-    _ clientId: String,
+  /**
+   Generates a CBOR encoded device response for ISO 18013-7 mDL remote presentation using OID4VP.
+   Resolves with the base64 encoded device response or rejects with an error code defined in ``ModuleErrorCodes``.
+   - Parameters:
+      - clientId: The client id extracted from OID4VP session.
+      - responseUri: The response URI extracted from OID4VP session.
+      - authorizationRequestNonce - The authorization request nonce extracted from OID4VP session.
+      - mdocGeneratedNonce - the mdoc generated nonce to be generated.
+      - documents: An array containing documents. Each document is defined as a map containing:
+           - issuerSignedContent which is a base64 or base64url encoded string representing the credential;
+           - alias which is the alias of the key used to sign the credential;
+           - docType which is the document type.
+      - acceptedFields: A dictionary of elements, where each element must adhere to the structure of AcceptedFieldsDict—specifically, a `[String: [String: [String: Bool]]]`. The outermost key represents the credential doctype. The inner dictionary contains namespaces, and for each namespace, there is another dictionary mapping requested claims to a boolean value, which indicates whether the user is willing to present the corresponding claim. Example:
+          
+           
+             {
+                "org.iso.18013.5.1.mDL": {
+                  "org.iso.18013.5.1": {
+                    "hair_colour": true,
+                    "given_name_national_character": true,
+                    "family_name_national_character": true,
+                    "given_name": true,
+                  },
+                  {...}
+                },
+                {...}
+             }
+
+       - resolve: The promise to be resolved.
+       - reject: The promise to be rejected.
+   */
+  @objc(generateOID4VPDeviceResponse:withResponseUri:withAuthorizationRequestNonce:withMdocGeneratedNonce:withDocuments:withAcceptedFields:withResolver:withRejecter:)
+  func generateOID4VPDeviceResponse(
+    clientId: String,
     responseUri: String,
     authorizationRequestNonce: String,
     mdocGeneratedNonce: String,
     documents: [Any],
-    fieldRequestedAndAccepted: String,
+    acceptedFields: [AnyHashable: Any],
     resolver resolve: RCTPromiseResolveBlock,
     rejecter reject: RCTPromiseRejectBlock
   ) {
     
     do {
       let sessionTranscript = Proximity.shared.generateOID4VPSessionTranscriptCBOR(
-          clientId: clientId,
-          responseUri: responseUri,
-          authorizationRequestNonce: authorizationRequestNonce,
-          mdocGeneratedNonce: mdocGeneratedNonce
+        clientId: clientId,
+        responseUri: responseUri,
+        authorizationRequestNonce: authorizationRequestNonce,
+        mdocGeneratedNonce: mdocGeneratedNonce
       )
-
-      let documentsAsProximityDocument = try parseDocuments(documents: documents)
-      
-      let items = try JSONDecoder().decode([String : [String : [String : Bool]]].self, from: Data(fieldRequestedAndAccepted.utf8))
       
-      do {
-        let response = try Proximity.shared.generateDeviceResponse(items: items, documents: documentsAsProximityDocument, sessionTranscript: sessionTranscript)
-        resolve(Data(response).base64EncodedString())
-      } catch {
-        ME.unableToGenerateResponse.reject(reject: reject)
-        return
-      }
-    } catch let error as NSError where error.domain == ME.invalidDocRequested.rawValue {
-      ME.invalidDocRequested.reject(reject: reject)
-    } catch _ as DecodingError {
-      ME.invalidItems.reject(reject: reject)
-    } catch {
-      ME.unexpected.reject(reject: reject)
+      let documentsAsProximityDocument = try parseDocuments(documents: documents)
+      let items = try parseAcceptedFields(acceptedFields: acceptedFields)
+      let response = try Proximity.shared.generateDeviceResponse(items: items, documents: documentsAsProximityDocument, sessionTranscript: sessionTranscript)
+      resolve(Data(response).base64EncodedString())
+    } catch let parsingError as ParsingError{
+      reject(ModuleErrorCodes.generateOID4VPResponseError.rawValue, parsingError.description, parsingError)
+    } catch let proximityError as ProximityError{
+      reject(ModuleErrorCodes.generateOID4VPResponseError.rawValue, proximityError.description, proximityError)
     }
-  }
-  
-  private class DocRequested {
-    var issuerSignedContent : [UInt8]
-    var alias : String
-    var docType : String
-    
-    public init(issuerSignedContent: [UInt8], alias: String, docType: String) {
-      self.issuerSignedContent = issuerSignedContent
-      self.alias = alias
-      self.docType = docType
+    catch {
+      reject(ModuleErrorCodes.generateOID4VPResponseError.rawValue, error.localizedDescription, error)
     }
   }
-  
+    
   /**
-   Wrapper for rejecting with an error.
-   Add a new case in order to extend the possible errors.
+   Custom Error which is thrown when a parsing error occurs in our utility functions which converts data from the bridge to what
+   our underlying functions expect.
+   This is needed in order to provide a customized description which can include more debug information.
    */
-  private enum ModuleException: String, CaseIterable {
+  enum ParsingError : Error, CustomStringConvertible {
+      case documentsNotValid(String)
+      case certificatesNotValid(String)
+      case acceptedFieldsNotValid(String)
+      
+      public var description: String {
+          switch(self) {
+            case .documentsNotValid(let message):
+                return message
+            case .certificatesNotValid(let message):
+              return message
+            case .acceptedFieldsNotValid(let message):
+              return message
+          }
+      }
+  }
+  
+  // Errors which this module uses to reject a promise
+  private enum ModuleErrorCodes: String, CaseIterable {
+    // ISO18013-5 related errors
     case startError = "START_ERROR"
-    case qrCodeError = "QR_CODE_ERROR"
-    case generateDeviceResponseError = "GENERATE_DEVICE_RESPONSE_ERROR"
+    case getQrCodeError = "GET_QR_CODE_ERROR"
     case sendResponseError = "SEND_RESPONSE_ERROR"
-    case sendErrorResponse = "SEND_ERROR_RESPONSE_ERROR"
-    case invalidDocRequested = "DOC_REQUESTED_PARSING_ERROR"
-    case unableToGenerateResponse = "UNABLE_TO_GENERATE_RESPONSE_ERROR"
-    case invalidItems = "REQUESTED_ITEMS_PARSING_ERROR"
-    case unexpected = "UNEXPECTED_ERROR"
-    case unableToDecode = "UNABLE_TO_DECODE"
+    case sendErrorResponseError = "SEND_ERROR_RESPONSE_ERROR"
+    case generateResponseError = "GENERATE_RESPONSE_ERROR"
     
-    func error(
-      userInfo: [String : Any]? = nil
-    ) -> NSError {
-      switch self {
-      case .startError:
-        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
-      case .qrCodeError:
-        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
-      case .generateDeviceResponseError:
-        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
-      case .sendResponseError:
-        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
-      case .sendErrorResponse:
-        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
-      case .invalidDocRequested:
-        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
-      case .unableToGenerateResponse:
-        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
-      case .invalidItems:
-        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
-      case .unexpected:
-        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
-      case .unableToDecode:
-        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
-      }
-    }
-    
-     /**
-      Rejects the provided promise with the appropriate error message and additional data.
-      
-      - Parameters:
-        - reject:  the promise to be rejected.
-        - moreUserInfo: additional key-value pairs of data to be passed along with the error.
-      
-      */
-    func reject(
-      reject: RCTPromiseRejectBlock,
-      _ moreUserInfo: (String, Any)...
-    ) {
-      let userInfo = [String: Any](uniqueKeysWithValues: moreUserInfo)
-      let error = error(userInfo: userInfo)
-      reject("\(error.code)", error.domain, error)
-    }
+    // ISO18013-7 related errors
+    case generateOID4VPResponseError = "GENERATE_OID4VP_RESPONSE_ERROR"
   }
 }