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

package/ios/IoReactNativeCbor.swift

@@ -4,44 +4,42 @@ import CryptoKit
 
 @objc(IoReactNativeCbor)
 class IoReactNativeCbor: NSObject {
-  private typealias ME = ModuleException
-  private let keyConfig: KeyConfig = .ec
   
   @objc func decode(
     _ cbor: String,
     resolver resolve: RCTPromiseResolveBlock,
     rejecter reject: RCTPromiseRejectBlock
   ) {
-    guard let data = try? Base64Utils.decodeBase64OrBase64URL(base: cbor) else {
-      ME.invalidEncoding.reject(reject: reject)
-      return
-    }
-    
-    guard let json = CborCose.jsonFromCBOR(data: data) else {
-      ME.unableToDecode.reject(reject: reject)
-      return
+    do{
+      let data = try Base64Utils.decodeBase64OrBase64URL(base: cbor)
+      guard let json = CborCose.jsonFromCBOR(data: data) else {
+        // We don't have the exact error here as this method returns nil upon failure
+        reject(ModuleErrorCodes.decodeError.rawValue, "Unable to decode CBOR", nil)
+        return
+      }
+      resolve(json);
+      
+    }catch{
+      reject(ModuleErrorCodes.decodeError.rawValue, error.localizedDescription, error)
     }
-    
-    resolve(json);
   }
   
-  
   @objc func decodeDocuments(
     _ mdoc: String,
     resolver resolve: RCTPromiseResolveBlock,
     rejecter reject: RCTPromiseRejectBlock
   ) {
-    guard let data = try? Base64Utils.decodeBase64OrBase64URL(base: mdoc) else {
-        ME.invalidEncoding.reject(reject: reject)
+    do{
+      let data = try Base64Utils.decodeBase64OrBase64URL(base: mdoc)
+      guard let json = CborCose.decodeCBOR(data: data, true, true) else {
+        // We don't have the exact error here as this method returns nil upon failure
+        reject(ModuleErrorCodes.decodeDocumentsError.rawValue, "Unable to decode document CBOR", nil)
         return
+      }
+      resolve(json);
+    }catch{
+      reject(ModuleErrorCodes.decodeDocumentsError.rawValue, error.localizedDescription, error)
     }
-    
-    guard let json = CborCose.decodeCBOR(data: data, true, true) else {
-      ME.unableToDecode.reject(reject: reject)
-      return
-    }
-    
-    resolve(json);
   }
   
   @objc func decodeIssuerSigned(
@@ -49,17 +47,17 @@ class IoReactNativeCbor: NSObject {
     resolver resolve: RCTPromiseResolveBlock,
     rejecter reject: RCTPromiseRejectBlock
   ) {
-    guard let data = try? Base64Utils.decodeBase64OrBase64URL(base: issuerSigned) else {
-        ME.invalidEncoding.reject(reject: reject)
+    do{
+      let data = try Base64Utils.decodeBase64OrBase64URL(base: issuerSigned)
+      guard let json = CborCose.issuerSignedCborToJson(data: data) else {
+        // We don't have the exact error here as this method returns nil upon failure
+        reject(ModuleErrorCodes.decodeIssuerSignedError.rawValue, "Unable to decode Issuer Signed CBOR", nil)
         return
+      }
+      resolve(json);
+    }catch{
+      reject(ModuleErrorCodes.decodeIssuerSignedError.rawValue, error.localizedDescription, error)
     }
-    
-    guard let json = CborCose.issuerSignedCborToJson(data: data) else {
-      ME.unableToDecode.reject(reject: reject)
-      return
-    }
-    
-    resolve(json);
   }
   
   @objc func sign(
@@ -68,24 +66,25 @@ class IoReactNativeCbor: NSObject {
     resolver resolve: @escaping RCTPromiseResolveBlock,
     rejecter reject: @escaping RCTPromiseRejectBlock
   ) {
-    DispatchQueue.global().async { [weak self] in
-      guard self != nil else {
-        ME.threadingError.reject(reject: reject)
-        return
+      DispatchQueue.global().async { [weak self] in
+        guard self != nil else {
+          reject(ModuleErrorCodes.threadingError.rawValue, "Failed to perform background operation, self was deallocated", nil)
+          return
+        }
+        
+        do{
+          let data = try Base64Utils.decodeBase64OrBase64URL(base: payloadData)
+          guard let coseKey = CoseKeyPrivate(crv: .p256, keyTag: keyTag) else {
+            // We don't have the exact error here as this method returns nil upon failure
+            reject(ModuleErrorCodes.signError.rawValue, "Unable to create a private key with the given keytag: \(keyTag)", nil)
+            return
+          }
+          let signedPayload = CborCose.sign(data: data, privateKey: coseKey)
+          resolve(signedPayload.base64EncodedString())
       }
-      
-      guard let data = try? Base64Utils.decodeBase64OrBase64URL(base: payloadData) else {
-        ME.invalidEncoding.reject(reject: reject)
-        return
+      catch{
+        reject(ModuleErrorCodes.signError.rawValue, error.localizedDescription, error)
       }
-      
-      guard let coseKey = CoseKeyPrivate(crv: .p256, keyTag: keyTag) else {
-        ME.publicKeyNotFound.reject(reject: reject)
-        return
-      }
-      
-      let signedPayload = CborCose.sign(data: data, privateKey: coseKey)
-      resolve(signedPayload.base64EncodedString())
     }
   }
   
@@ -96,93 +95,24 @@ class IoReactNativeCbor: NSObject {
     rejecter reject: RCTPromiseRejectBlock
   ) {
     do {
-      guard let data = try? Base64Utils.decodeBase64OrBase64URL(base: sign1Data) else {
-        ME.invalidEncoding.reject(reject: reject)
-        return
-      }
-      
+      let data = try Base64Utils.decodeBase64OrBase64URL(base: sign1Data)
       let publicKeyJson = try JSONSerialization.data(withJSONObject: jwk, options:[] )
       let publicKeyString = String(data: publicKeyJson, encoding: .utf8)!
       let publicKey = CoseKey(jwk: publicKeyString)!
-      
       let verified = CborCose.verify(data: data, publicKey: publicKey)
-      
       resolve(verified)
     } catch {
-      ME.unknownException.reject(reject: reject)
+      reject(ModuleErrorCodes.verifyError.rawValue, error.localizedDescription, error)
     }
   }
-    
-  private func keyExists(keyTag: String) -> (key: SecKey?, status: OSStatus) {
-    let getQuery = privateKeyKeychainQuery(keyTag: keyTag)
-    var item: CFTypeRef?
-    let status = SecItemCopyMatching(getQuery as CFDictionary, &item)
-    return (status == errSecSuccess ? (item as! SecKey) : nil, status)
-  }
   
-  private func privateKeyKeychainQuery(
-    keyTag: String
-  ) -> [String : Any] {
-    return [
-      kSecClass as String: kSecClassKey,
-      kSecAttrApplicationTag as String: keyTag,
-      kSecAttrKeyType as String: keyConfig.keyType(),
-      kSecReturnRef as String: true
-    ]
-  }
-  
-  private enum KeyConfig: Int, CaseIterable {
-    case ec
-    
-    func keyType() -> CFString {
-      switch self {
-      case .ec:
-        return kSecAttrKeyTypeECSECPrimeRandom
-      }
-    }
-    
-    func keySizeInBits() -> Int {
-      switch self {
-      case .ec:
-        return 256
-      }
-    }
-    
-    func keySignAlgorithm() -> SecKeyAlgorithm {
-      switch self {
-      case .ec:
-        return .ecdsaSignatureMessageX962SHA256
-      }
-    }
-  }
-  
-  private enum ModuleException: String, CaseIterable {
-    case unableToDecode = "UNABLE_TO_DECODE"
-    case publicKeyNotFound = "PUBLIC_KEY_NOT_FOUND"
-    case invalidEncoding = "INVALID_ENCODING"
+  // Errors which this module uses to reject a promise
+  private enum ModuleErrorCodes: String, CaseIterable {
+    case decodeError = "DECODE_ERROR"
+    case decodeDocumentsError = "DECODE_DOCUMENTS_ERROR"
+    case decodeIssuerSignedError = "DECODE_ISSUER_SIGNED_ERROR"
+    case signError = "SIGN_ERROR"
+    case verifyError = "VERIFY_ERROR"
     case threadingError = "THREADING_ERROR"
-    case unknownException = "UNKNOWN_EXCEPTION"
-    
-    func error(userInfo: [String : Any]? = nil) -> NSError {
-      switch self {
-      case .unableToDecode:
-        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
-      case .publicKeyNotFound:
-        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
-      case .invalidEncoding:
-        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
-      case .threadingError:
-        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
-      case .unknownException:
-        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
-      }
-    }
-    
-    func reject(reject: RCTPromiseRejectBlock, _ moreUserInfo: (String, Any)...) {
-      var userInfo = [String : Any]()
-      moreUserInfo.forEach { userInfo[$0.0] = $0.1 }
-      let error = error(userInfo: userInfo)
-      reject("\(error.code)", error.domain, error)
-    }
   }
 }

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
@@ -53,11 +51,15 @@ class IoReactNativeIso18013: RCTEventEmitter {
     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)
     }
   }
   
@@ -69,15 +71,17 @@ class IoReactNativeIso18013: RCTEventEmitter {
    
     - 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
     }
   }
   
@@ -97,8 +101,8 @@ class IoReactNativeIso18013: RCTEventEmitter {
     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)
     }
   }
   
@@ -113,26 +117,31 @@ class IoReactNativeIso18013: RCTEventEmitter {
          - 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
+   - 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
     }
@@ -146,26 +155,26 @@ class IoReactNativeIso18013: RCTEventEmitter {
    - 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
+   - 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"])
+      throw ParsingError.acceptedFieldsNotValid("Empty accepted fields cannot be empty")
     }
     
     return result
@@ -216,8 +225,14 @@ 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)
     }
   }
   
@@ -244,7 +259,7 @@ class IoReactNativeIso18013: RCTEventEmitter {
         resolve(true)
       }
     }catch let error {
-      ME.sendResponseError.reject(reject: reject, ("error", error.localizedDescription))
+      reject(ModuleErrorCodes.sendResponseError.rawValue, error.localizedDescription, error)
     }
   }
   
@@ -262,16 +277,16 @@ class IoReactNativeIso18013: RCTEventEmitter {
    */
   @objc(sendErrorResponse:withResolver:withRejecter:)
   func sendErrorResponse(status: UInt64, _ resolve: @escaping RCTPromiseResolveBlock,
-                               reject: @escaping RCTPromiseRejectBlock){
+                         reject: @escaping RCTPromiseRejectBlock){
     do{
       if let statusEnum = SessionDataStatus(rawValue: status) {
         try Proximity.shared.errorPresentation(statusEnum)
       } else {
-        ME.sendResponseError.reject(reject: reject, ("error", "Invalid status code"))
+        reject(ModuleErrorCodes.sendErrorResponseError.rawValue, "Invalid status code provided: \(status)", nil)
       }
       resolve(true)
     }catch let error{
-      ME.sendResponseError.reject(reject: reject, ("error", error.localizedDescription))
+      reject(ModuleErrorCodes.sendErrorResponseError.rawValue, error.localizedDescription, error)
     }
   }
   
@@ -392,102 +407,58 @@ class IoReactNativeIso18013: RCTEventEmitter {
     
     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 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 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"
-    
-    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)
-      }
-    }
+    case sendErrorResponseError = "SEND_ERROR_RESPONSE_ERROR"
+    case generateResponseError = "GENERATE_RESPONSE_ERROR"
     
-     /**
-      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"
   }
 }

package/lib/module/cbor/cbor/README.md

@@ -88,8 +88,40 @@ enum DocumentTypeEnum {
 
 ### Error Codes
 
-| Type              | Platform    | Description                                   |
-| ----------------- | ----------- | --------------------------------------------- |
-| INVALID_ENCODING  | Android/iOS | Provided payload has incorrect encoding       |
-| UNABLE_TO_DECODE  | Android/iOS | The data does not contain a valid CBOR object |
-| UNKNOWN_EXCEPTION | Android/iOS | Unexpected failure                            |
+This table contains the list of error codes that can be thrown by the `CBOR` module which are mapped via the `ModuleErrorCodes` type:
+| Type | Platform | Description |
+| -------------------------- | ----------- | ------------------------------------------------------------ |
+| DECODE_ERROR | Android/iOS | An error occurred while decoding the CBOR |
+| DECODE_DOCUMENTS_ERROR | Android/iOS | An error occurred while decoding a CBOR mDOC |
+| DECODE_ISSUER_SIGNED_ERROR | Android/iOS | An error occurred while decoding a CBOR Issuer Signed object |
+
+An error can be parsed using the `ModuleErrorSchema` with type `ModuleErrorCodes` exposed by the `ISO18013_5` module. The error can be parsed as follows:
+
+```typescript
+import { CBOR } from '@pagopa/io-react-native-iso18013';
+try {
+  await CBOR.func();
+} catch (error) {
+  const parsedError = CBOR.ModuleErrorSchema.parse(error); // Or ModuleErrorSchema.safeParse(error) for safe parsing
+  console.log(JSON.stringify(parsedError, null, 2));
+}
+```
+
+The parsed object will contain properties from both iOS and Android platforms:
+
+```typescript
+{
+  code: string; // Defined in ModuleErrorCodes
+  message: string;
+  name: string;
+  userInfo?: Record<string, any> | null;
+  nativeStackAndroid?: Array<{
+    lineNumber: number;
+    file: string;
+    methodName: string;
+    class: string;
+  }>;
+  domain?: string;
+  nativeStackIOS?: Array<string>;
+};
+```

package/lib/module/cbor/cbor/error.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import z from 'zod';
+import { GenericModuleErrorSchema } from "../../schema.js";
+
+/**
+ * Error codes which the CBOR module uses to reject a promise.
+ */
+const ModuleErrorCodesSchema = z.enum(['DECODE_ERROR', 'DECODE_DOCUMENTS_ERROR', 'DECODE_ISSUER_SIGNED_ERROR', 'EUNSPECIFIED' // Android only default when no other error is specified
+]);
+/**
+ * Schema which can be used to parse a rejected promise error by the CBOR module.
+ */
+export const ModuleErrorSchema = GenericModuleErrorSchema(ModuleErrorCodesSchema);
+//# sourceMappingURL=error.js.map

package/lib/module/cbor/cbor/error.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["z","GenericModuleErrorSchema","ModuleErrorCodesSchema","enum","ModuleErrorSchema"],"sourceRoot":"../../../../src","sources":["cbor/cbor/error.ts"],"mappings":";;AAAA,OAAOA,CAAC,MAAM,KAAK;AACnB,SAASC,wBAAwB,QAAQ,iBAAc;;AAEvD;AACA;AACA;AACA,MAAMC,sBAAsB,GAAGF,CAAC,CAACG,IAAI,CAAC,CACpC,cAAc,EACd,wBAAwB,EACxB,4BAA4B,EAC5B,cAAc,CAAE;AAAA,CACjB,CAAC;AAIF;AACA;AACA;AACA,OAAO,MAAMC,iBAAiB,GAAGH,wBAAwB,CACvDC,sBACF,CAAC","ignoreList":[]}

package/lib/module/cbor/cbor/index.js

@@ -2,4 +2,5 @@
 
 export { decode, decodeDocuments, decodeIssuerSigned } from "./decoder.js";
 export { DocumentValue, Documents, DocumentsFromString, IssuerSigned, MDOC } from "./schema.js";
+export { ModuleErrorSchema } from "./error.js";
 //# sourceMappingURL=index.js.map

package/lib/module/cbor/cbor/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["decode","decodeDocuments","decodeIssuerSigned","DocumentValue","Documents","DocumentsFromString","IssuerSigned","MDOC"],"sourceRoot":"../../../../src","sources":["cbor/cbor/index.ts"],"mappings":";;AAAA,SAASA,MAAM,EAAEC,eAAe,EAAEC,kBAAkB,QAAQ,cAAW;AACvE,SACEC,aAAa,EACbC,SAAS,EACTC,mBAAmB,EACnBC,YAAY,EACZC,IAAI,QACC,aAAU","ignoreList":[]}
+{"version":3,"names":["decode","decodeDocuments","decodeIssuerSigned","DocumentValue","Documents","DocumentsFromString","IssuerSigned","MDOC","ModuleErrorSchema"],"sourceRoot":"../../../../src","sources":["cbor/cbor/index.ts"],"mappings":";;AAAA,SAASA,MAAM,EAAEC,eAAe,EAAEC,kBAAkB,QAAQ,cAAW;AACvE,SACEC,aAAa,EACbC,SAAS,EACTC,mBAAmB,EACnBC,YAAY,EACZC,IAAI,QACC,aAAU;AACjB,SAGEC,iBAAiB,QACZ,YAAS","ignoreList":[]}