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

package/android/build.gradle

@@ -77,7 +77,7 @@ def kotlin_version = getExtOrDefault("kotlinVersion")
 dependencies {
   implementation "com.facebook.react:react-android"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  implementation "it.pagopa.io.wallet.proximity:proximity:2.0.0"
+  implementation "it.pagopa.io.wallet.proximity:proximity:2.1.0"
   implementation "it.pagopa.io.wallet.cbor:cbor:1.3.0"
 }
 

package/android/src/main/java/com/ioreactnativeiso18013/IoReactNativeCborModule.kt

@@ -5,10 +5,7 @@ import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReadableMap
-import com.facebook.react.bridge.WritableMap
-import com.facebook.react.bridge.WritableNativeMap
 import it.pagopa.io.wallet.cbor.cose.COSEManager
-import it.pagopa.io.wallet.cbor.cose.FailureReason
 import it.pagopa.io.wallet.cbor.cose.SignWithCOSEResult
 import it.pagopa.io.wallet.cbor.parser.CBorParser
 
@@ -21,189 +18,95 @@ class IoReactNativeCborModule(reactContext: ReactApplicationContext) :
 
   @ReactMethod
   fun decode(data: String, promise: Promise) {
-    val buffer = try {
-      Base64Utils.decodeBase64AndBase64Url(data)
-    } catch (e: Exception) {
-      ModuleException.INVALID_ENCODING.reject(
-        promise,
-        Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
-      return;
-    }
-
     try {
-      CBorParser(buffer).toJson()?.let {
-        promise.resolve(it)
-      } ?: run {
-        ModuleException.UNABLE_TO_DECODE.reject(promise)
-      }
+      val buffer = Base64Utils.decodeBase64AndBase64Url(data)
+      val result = CBorParser(buffer).toJson()
+      promise.resolve(result)
     } catch (e: Exception) {
-      ModuleException.UNKNOWN_EXCEPTION.reject(
-        promise,
-        Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
+      promise.reject(ModuleErrorCodes.DECODE_ERROR, e.message, e)
     }
   }
 
-  @ReactMethod
-  fun decodeDocuments(data: String, promise: Promise) {
-    val buffer = try {
-      Base64Utils.decodeBase64AndBase64Url(data)
-    } catch (e: Exception) {
-      ModuleException.INVALID_ENCODING.reject(
-        promise,
-        Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
-      return;
-    }
-    try {
-      CBorParser(buffer).documentsCborToJson(separateElementIdentifier = true, onComplete = {
-        promise.resolve(it)
-      }) { ex ->
-        ModuleException.UNABLE_TO_DECODE.reject(
-          promise,
-          Pair(ERROR_USER_INFO_KEY, ex.message.orEmpty())
-        )
-      }
-    } catch (e: Exception) {
-      ModuleException.UNKNOWN_EXCEPTION.reject(
-        promise,
-        Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
-    }
-  }
 
-  @ReactMethod
-  fun decodeIssuerSigned(issuerSigned: String, promise: Promise) {
-    val buffer = try {
-      Base64Utils.decodeBase64AndBase64Url(issuerSigned)
-    } catch (e: Exception) {
-      ModuleException.INVALID_ENCODING.reject(
-        promise,
-        Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
-      return;
-    }
-    try {
-      CBorParser(buffer).issuerSignedCborToJson(separateElementIdentifier = true).let {
-        if (it == null) {
-          ModuleException.UNABLE_TO_DECODE.reject(
-            promise,
-            Pair(ERROR_USER_INFO_KEY, "Unable to decode passed CBOR")
-          )
-          return
-        }
-        promise.resolve(it)
+    @ReactMethod
+    fun decodeDocuments(data: String, promise: Promise) {
+      try {
+        val buffer = Base64Utils.decodeBase64AndBase64Url(data)
+        CBorParser(buffer).documentsCborToJson(separateElementIdentifier = true, onComplete = {
+          promise.resolve(it)
+        }, onError = { e ->
+          promise.reject(ModuleErrorCodes.DECODE_DOCUMENTS_ERROR, e.message, e)
+        })
+      } catch (e: Exception) {
+        promise.reject(ModuleErrorCodes.DECODE_DOCUMENTS_ERROR, e.message, e)
       }
-    } catch (e: Exception) {
-      ModuleException.UNKNOWN_EXCEPTION.reject(
-        promise,
-        Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
     }
-  }
 
-  @ReactMethod
-  fun sign(payload: String, keyTag: String, promise: Promise) {
-    val data = try {
-      Base64Utils.decodeBase64AndBase64Url(payload)
-    } catch (e: Exception) {
-      ModuleException.INVALID_ENCODING.reject(
-        promise,
-        Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
-      return;
+    @ReactMethod
+    fun decodeIssuerSigned(issuerSigned: String, promise: Promise) {
+      try {
+        val buffer =
+          Base64Utils.decodeBase64AndBase64Url(issuerSigned)
+        val result =
+          CBorParser(buffer).issuerSignedCborToJson(separateElementIdentifier = true) ?: run {
+            // We don't have the exact error here for some reason
+            promise.reject(
+              ModuleErrorCodes.DECODE_ISSUER_SIGNED_ERROR,
+              "An error occurred while decoding the issuer signed content"
+            )
+          }
+        promise.resolve(result)
+      } catch (e: Exception) {
+        promise.reject(ModuleErrorCodes.DECODE_ISSUER_SIGNED_ERROR, e.message, e)
+      }
     }
 
+    @ReactMethod
+    fun sign(payload: String, keyTag: String, promise: Promise){
     try {
-      val result = COSEManager().signWithCOSE(
-        data = data,
-        alias = keyTag
-      )
-      when (result) {
-        is SignWithCOSEResult.Failure -> {
-          when (result.reason) {
-            FailureReason.NO_KEY -> ModuleException.PUBLIC_KEY_NOT_FOUND.reject(
-              promise,
-              Pair(ERROR_USER_INFO_KEY, result.reason.msg)
-            )
-
-            FailureReason.FAIL_TO_SIGN -> ModuleException.UNABLE_TO_SIGN.reject(
-              promise,
-              Pair(ERROR_USER_INFO_KEY, result.reason.msg)
-            )
-
-            else -> ModuleException.UNKNOWN_EXCEPTION.reject(
-              promise,
-              Pair(ERROR_USER_INFO_KEY, result.reason.msg)
-            )
+      val data = Base64Utils.decodeBase64AndBase64Url(payload)
+        val result = COSEManager().signWithCOSE(
+          data = data,
+          alias = keyTag
+        )
+        when (result) {
+          is SignWithCOSEResult.Failure -> {
+            // We don't have a throwable to pass here from the onError callback
+            promise.reject(ModuleErrorCodes.SIGN_ERROR, result.reason.msg)
+          }
+          is SignWithCOSEResult.Success -> {
+            promise.resolve(Base64Utils.encodeBase64(result.signature))
           }
         }
-
-        is SignWithCOSEResult.Success -> {
-          promise.resolve(Base64Utils.encodeBase64(result.signature))
-        }
+      } catch (e: Exception) {
+        promise.reject(ModuleErrorCodes.SIGN_ERROR, e.message, e)
       }
-    } catch (e: Exception) {
-      ModuleException.UNKNOWN_EXCEPTION.reject(
-        promise,
-        Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
-    }
-  }
-
-  @ReactMethod
-  fun verify(sign1Data: String, publicKey: ReadableMap, promise: Promise) {
-    val data = try {
-      Base64Utils.decodeBase64AndBase64Url(sign1Data)
-    } catch (e: Exception) {
-      ModuleException.INVALID_ENCODING.reject(
-        promise,
-        Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
-      return;
     }
 
-    try {
-      val result = COSEManager().verifySign1FromJWK(
-        dataSigned = data,
-        jwk = publicKey.toString()
-      )
-      promise.resolve(result)
-    } catch (e: Exception) {
-      ModuleException.UNKNOWN_EXCEPTION.reject(
-        promise,
-        Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
+    @ReactMethod
+    fun verify(sign1Data: String, publicKey: ReadableMap, promise: Promise) {
+      try {
+      val data = Base64Utils.decodeBase64AndBase64Url(sign1Data)
+        val result = COSEManager().verifySign1FromJWK(
+          dataSigned = data,
+          jwk = publicKey.toString()
+        )
+        promise.resolve(result)
+      } catch (e: Exception) {
+       promise.reject(ModuleErrorCodes.VERIFY_ERROR, e.message, e)
+      }
     }
-  }
 
   companion object {
     const val NAME = "IoReactNativeCbor"
-    const val ERROR_USER_INFO_KEY = "error"
-
-    private enum class ModuleException(
-      val ex: Exception
-    ) {
-      UNABLE_TO_DECODE(Exception("UNABLE_TO_DECODE")),
-      PUBLIC_KEY_NOT_FOUND(Exception("PUBLIC_KEY_NOT_FOUND")),
-      UNABLE_TO_SIGN(Exception("UNABLE_TO_SIGN")),
-      INVALID_ENCODING(Exception("INVALID_ENCODING")),
-      UNKNOWN_EXCEPTION(Exception("UNKNOWN_EXCEPTION"));
-
-      fun reject(
-        promise: Promise, vararg args: Pair<String, String>
-      ) {
-        exMap(*args).let {
-          promise.reject(it.first, ex.message, it.second)
-        }
-      }
 
-      private fun exMap(vararg args: Pair<String, String>): Pair<String, WritableMap> {
-        val writableMap = WritableNativeMap()
-        args.forEach { writableMap.putString(it.first, it.second) }
-        return Pair(this.ex.message ?: "UNKNOWN", writableMap)
-      }
+    // Errors which this module uses to reject a promise
+    private object ModuleErrorCodes {
+      const val DECODE_ERROR = "DECODE_ERROR"
+      const val DECODE_DOCUMENTS_ERROR = "DECODE_DOCUMENTS_ERROR"
+      const val DECODE_ISSUER_SIGNED_ERROR = "DECODE_ISSUER_SIGNED_ERROR"
+      const val SIGN_ERROR = "SIGN_ERROR"
+      const val VERIFY_ERROR = "VERIFY_ERROR"
     }
   }
 }

package/android/src/main/java/com/ioreactnativeiso18013/IoReactNativeIso18013Module.kt

@@ -9,8 +9,6 @@ import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.ReadableType
 import com.facebook.react.bridge.WritableMap
-import com.facebook.react.bridge.WritableNativeMap
-import com.ioreactnativeiso18013.IoReactNativeCborModule.Companion.ERROR_USER_INFO_KEY
 import it.pagopa.io.wallet.proximity.OpenID4VP
 import it.pagopa.io.wallet.proximity.bluetooth.BleRetrievalMethod
 import it.pagopa.io.wallet.proximity.qr_code.QrEngagement
@@ -36,7 +34,7 @@ class IoReactNativeIso18013Module(reactContext: ReactApplicationContext) :
    * @param peripheralMode - Whether the device is in peripheral mode. Defaults to true
    * @param centralClientMode - Whether the device is in central client mode. Defaults to false
    * @param clearBleCache - Whether the BLE cache should be cleared. Defaults to true
-   * @param certificates - Array of base64 representing DER encoded X.509 certificate which are used to authenticate the verifier app
+   * @param certificates - Two-dimensional array of base64 strings representing DER encoded X.509 certificate which are used to authenticate the verifier app
    * @param promise - The promise which will be resolved in case of success or rejected in case of failure.
    */
   @ReactMethod
@@ -54,41 +52,57 @@ class IoReactNativeIso18013Module(reactContext: ReactApplicationContext) :
         clearBleCache = clearBleCache
       )
 
-//      val certificatesList = parseCertificates(certificates)
+      val certificatesList = parseCertificates(certificates)
       qrEngagement = QrEngagement.build(reactApplicationContext, listOf(retrievalMethod)).apply {
-//        if (certificatesList.isNotEmpty()) {
-//          withReaderTrustStore(certificatesList)
-//        }
+        if (certificatesList.isNotEmpty()) {
+          withReaderTrustStore(certificatesList)
+        }
       }
       qrEngagement?.configure()
       setupProximityHandler()
       promise.resolve(true)
     } catch (e: Exception) {
-      print(e)
-      ModuleException.START_ERROR.reject(
-        promise,
-        Pair(ERROR_KEY, getExceptionMessageOrEmpty(e))
-      )
+      promise.reject(ModuleErrorCodes.START_ERROR, e.message, e)
     }
   }
 
   /**
    * Utility function to parse an array coming from the React Native Bridge into an ArrayList
    * of ByteArray representing DER encoded X.509 certificates.
-   * @param certificates - Array of base64 strings representing DER encoded X.509 certificate
+   * @param certificates - Two-dimensional array of base64 strings representing DER encoded X.509 certificate
    * @returns An ArrayList of ByteArray representing DER encoded X.509 certificates.
-   * @throws ClassCastException if the element in the array is not a string
+   * @throws IllegalArgumentException if an element in the array is not base64 encoded
    */
+  private fun parseCertificates(certificates: ReadableArray): List<List<ByteArray>> =
+    /** Map the chain arrays and remove null entries. On each chain call the getArray method which
+    * can throw and if it does rethrow an exception with information on its position
+    */
+    (0 until certificates.size()).mapNotNull { chainIndex ->
+      val chain = runCatching { certificates.getArray(chainIndex) }
+        .getOrElse { throw IllegalArgumentException("Certificate chain at $chainIndex is not an array", it) }
+        ?: throw IllegalArgumentException("Certificate chain at index $chainIndex is null")
+
+      /**
+       * Map each chain certificate and remove null entries. On each certificate call the getString
+       * method which can throw and if it does rethrow an exception with information on its position
+       */
+      (0 until chain.size()).mapNotNull { certIndex ->
+        val base64 = runCatching { chain.getString(certIndex) }
+          .getOrElse { throw IllegalArgumentException("Failed to get certificate string at chain $chainIndex, cert $certIndex", it) }
+          ?: throw java.lang.IllegalArgumentException("Certificate at index $certIndex is null")
+
+        /**
+         * Decode the base64 string for each mapped certificate and if an error occurs rethrow
+         * an exception with information on its position
+         */
+        runCatching {
+          Base64Utils.decodeBase64(base64)
+        }.getOrElse {
+          throw IllegalArgumentException("Certificate at index $certIndex in the chain at index $chainIndex is not a valid base64 string", it)
+        }
+      }
+    }
 
-//  private fun parseCertificates(certificates: ReadableArray): ArrayList<ByteArray> {
-//    return ArrayList(
-//      (0 until certificates.size()).mapNotNull { i ->
-//        certificates.getString(i)?.let { cert ->
-//          Base64Utils.decodeBase64(cert)
-//        }
-//      }
-//    )
-//  }
 
   /**
    * Creates a QR code to be scanned in order to initialize the presentation.
@@ -102,13 +116,10 @@ class IoReactNativeIso18013Module(reactContext: ReactApplicationContext) :
         val qrCodeString = it.getQrCodeString()
         promise.resolve(qrCodeString)
       } ?: run {
-        ModuleException.QR_ENGAGEMENT_NOT_DEFINED_ERROR.reject(promise)
+        promise.reject(ModuleErrorCodes.QR_ENGAGEMENT_NOT_DEFINED,NOT_INITIALIZED_ERROR_MESSAGE)
       }
     } catch (e: Exception) {
-      ModuleException.GET_QR_CODE_ERROR.reject(
-        promise,
-        Pair(ERROR_KEY, getExceptionMessageOrEmpty(e))
-      )
+      promise.reject(ModuleErrorCodes.GET_QR_CODE_ERROR, e.message, e)
     }
   }
 
@@ -124,10 +135,7 @@ class IoReactNativeIso18013Module(reactContext: ReactApplicationContext) :
       deviceRetrievalHelper?.disconnect()
       promise.resolve(true)
     } catch (e: Exception) {
-      ModuleException.CLOSE_ERROR.reject(
-        promise,
-        Pair(ERROR_KEY, getExceptionMessageOrEmpty(e))
-      )
+      promise.reject(ModuleErrorCodes.CLOSE_ERROR, message=e.message, e)
     }
   }
 
@@ -149,19 +157,13 @@ class IoReactNativeIso18013Module(reactContext: ReactApplicationContext) :
           it.sendErrorResponse(sessionDataStatus)
           promise.resolve(true)
         } else {
-          ModuleException.SEND_ERROR_RESPONSE_ERROR.reject(
-            promise,
-            Pair(ERROR_KEY, "Invalid status code")
-          )
+          promise.reject(ModuleErrorCodes.SEND_ERROR_RESPONSE_ERROR, message="Invalid status code")
         }
       } ?: run {
-        ModuleException.QR_ENGAGEMENT_NOT_DEFINED_ERROR.reject(promise)
+        promise.reject(ModuleErrorCodes.QR_ENGAGEMENT_NOT_DEFINED, message=NOT_INITIALIZED_ERROR_MESSAGE)
       }
     } catch (e: Exception) {
-      ModuleException.SEND_ERROR_RESPONSE_ERROR.reject(
-        promise,
-        Pair(ERROR_KEY, getExceptionMessageOrEmpty(e))
-      )
+      promise.reject(ModuleErrorCodes.SEND_ERROR_RESPONSE_ERROR, message=e.message, e)
     }
   }
 
@@ -197,20 +199,14 @@ class IoReactNativeIso18013Module(reactContext: ReactApplicationContext) :
             }
 
             override fun onError(message: String) {
-              ModuleException.GENERATE_RESPONSE_ERROR.reject(
-                promise,
-                Pair(ERROR_KEY, message)
-              )
+              promise.reject(ModuleErrorCodes.GENERATE_RESPONSE_ERROR, message)
             }
           })
       } ?: run {
-        ModuleException.DRH_NOT_DEFINED.reject(promise)
+        promise.reject(ModuleErrorCodes.DRH_NOT_DEFINED, message=NOT_INITIALIZED_ERROR_MESSAGE)
       }
     } catch (e: Exception) {
-      ModuleException.GENERATE_RESPONSE_ERROR.reject(
-        promise,
-        Pair(ERROR_KEY, getExceptionMessageOrEmpty(e))
-      )
+      promise.reject(ModuleErrorCodes.GENERATE_RESPONSE_ERROR, message=e.message, e)
     }
   }
 
@@ -230,13 +226,10 @@ class IoReactNativeIso18013Module(reactContext: ReactApplicationContext) :
         promise.resolve(true)
       }
         ?: run {
-          ModuleException.QR_ENGAGEMENT_NOT_DEFINED_ERROR.reject(promise)
+          promise.reject(ModuleErrorCodes.QR_ENGAGEMENT_NOT_DEFINED, message=NOT_INITIALIZED_ERROR_MESSAGE)
         }
     } catch (e: Exception) {
-      ModuleException.SEND_RESPONSE_ERROR.reject(
-        promise,
-        Pair(ERROR_KEY, getExceptionMessageOrEmpty(e))
-      )
+      promise.reject(ModuleErrorCodes.SEND_RESPONSE_ERROR, e.message, e)
     }
   }
 
@@ -246,32 +239,18 @@ class IoReactNativeIso18013Module(reactContext: ReactApplicationContext) :
     mdocGeneratedNonce: String, documents: ReadableArray,
     fieldRequestedAndAccepted: String, promise: Promise
   ) {
-    val sessionTranscript = try {
-      OpenID4VP(
-        clientId,
-        responseUri,
-        authorizationRequestNonce,
-        mdocGeneratedNonce
-      ).createSessionTranscript()
-    } catch (e: Exception) {
-      ModuleException.UNABLE_TO_GENERATE_TRANSCRIPT.reject(
-        promise,
-        Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
-      return
-    }
+    try {
+      val sessionTranscript =
+        OpenID4VP(
+          clientId,
+          responseUri,
+          authorizationRequestNonce,
+          mdocGeneratedNonce
+        ).createSessionTranscript()
 
-    val documentsParsed = try {
-      parseDocRequested(documents)
-    } catch (e: Exception) {
-      ModuleException.INVALID_DOC_REQUESTED.reject(
-        promise,
-        Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
-      return
-    }
+      val documentsParsed =
+        parseDocRequested(documents)
 
-    try {
       val responseGenerator = ResponseGenerator(sessionTranscript)
       responseGenerator.createResponse(
         documentsParsed,
@@ -282,18 +261,12 @@ class IoReactNativeIso18013Module(reactContext: ReactApplicationContext) :
           }
 
           override fun onError(message: String) {
-            ModuleException.UNABLE_TO_GENERATE_RESPONSE.reject(
-              promise,
-              Pair(ERROR_USER_INFO_KEY, message)
-            )
+            promise.reject(ModuleErrorCodes.GENERATE_OID4VP_RESPONSE_ERROR, message)
           }
         }
       )
     } catch (e: Exception) {
-      ModuleException.UNABLE_TO_GENERATE_RESPONSE.reject(
-        promise,
-        Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
+      promise.reject(ModuleErrorCodes.GENERATE_OID4VP_RESPONSE_ERROR, e.message, e)
     }
   }
 
@@ -349,28 +322,31 @@ class IoReactNativeIso18013Module(reactContext: ReactApplicationContext) :
    * @throws IllegalArgumentException if the provided document doesn't adhere to the expected format
    */
   private fun parseDocRequested(documents: ReadableArray): Array<DocRequested> {
-    return (0 until documents.size()).map { i ->
-      val entry = documents.getMap(i)
-        ?: throw IllegalArgumentException("Entry in ReadableArray is null")
-
-      val alias = entry.getString("alias")
-      val issuerSignedContentStr = entry.getString("issuerSignedContent")
-      val docType = entry.getString("docType")
-
-      if (
-        alias == null || entry.getType("alias") != ReadableType.String ||
-        issuerSignedContentStr == null || entry.getType("issuerSignedContent") != ReadableType.String ||
-        docType == null || entry.getType("docType") != ReadableType.String
-      ) throw IllegalArgumentException("Unable to decode the provided documents")
-
-      val issuerSignedContent = Base64Utils.decodeBase64AndBase64Url(issuerSignedContentStr)
-
-      DocRequested(
-        issuerSignedContent,
-        alias,
-        docType
-      )
-    }.toTypedArray()
+    return try {
+      (0 until documents.size()).map { i ->
+        val entry = documents.getMap(i)
+          ?: throw IllegalArgumentException("Entry at index $i in ReadableArray is null")
+        val alias = entry.getString("alias")
+        val issuerSignedContentStr = entry.getString("issuerSignedContent")
+        val docType = entry.getString("docType")
+
+        if (
+          alias == null || entry.getType("alias") != ReadableType.String ||
+          issuerSignedContentStr == null || entry.getType("issuerSignedContent") != ReadableType.String ||
+          docType == null || entry.getType("docType") != ReadableType.String
+        ) throw IllegalArgumentException("Unable to decode the provided documents at index $i")
+
+        val issuerSignedContent = Base64Utils.decodeBase64AndBase64Url(issuerSignedContentStr)
+
+        DocRequested(
+          issuerSignedContent,
+          alias,
+          docType
+        )
+      }.toTypedArray()
+    } catch (e: Exception) {
+      throw IllegalArgumentException("Failed to parse documents: ${e.message}", e)
+    }
   }
 
   /**
@@ -397,44 +373,24 @@ class IoReactNativeIso18013Module(reactContext: ReactApplicationContext) :
     */
   }
 
-  private enum class ModuleException(
-    val ex: Exception
-  ) {
-    /** ISO18013-5 related errors **/
-    DRH_NOT_DEFINED(Exception("DRH_NOT_DEFINED")),
-    QR_ENGAGEMENT_NOT_DEFINED_ERROR(Exception("QR_ENGAGEMENT_NOT_DEFINED_ERROR")),
-    START_ERROR(Exception("START_ERROR")),
-    GET_QR_CODE_ERROR(Exception("GET_QR_CODE_ERROR")),
-    GENERATE_RESPONSE_ERROR(Exception("GENERATE_RESPONSE_ERROR")),
-    SEND_RESPONSE_ERROR(Exception("SEND_RESPONSE_ERROR")),
-    SEND_ERROR_RESPONSE_ERROR(Exception("SEND_ERROR_RESPONSE_ERROR")),
-    CLOSE_ERROR(Exception("CLOSE_ERROR")),
-
-    /** ISO18013-7 related errors **/
-    UNABLE_TO_GENERATE_RESPONSE(Exception("UNABLE_TO_GENERATE_RESPONSE")),
-    UNABLE_TO_GENERATE_TRANSCRIPT(Exception("UNABLE_TO_GENERATE_TRANSCRIPT")),
-    INVALID_DOC_REQUESTED(Exception("INVALID_DOC_REQUESTED")),
-    GENERATE_OID4VP_DEVICE_RESPONSE_FAILED(Exception("GENERATE_OID4VP_DEVICE_RESPONSE_FAILED"));
-
-    fun reject(
-      promise: Promise, vararg args: Pair<String, String>
-    ) {
-      exMap(*args).let {
-        promise.reject(it.first, ex.message, it.second)
-      }
-    }
-
-    private fun exMap(vararg args: Pair<String, String>): Pair<String, WritableMap> {
-      val writableMap = WritableNativeMap()
-      args.forEach { writableMap.putString(it.first, it.second) }
-      return Pair(this.ex.message ?: "UNKNOWN", writableMap)
-    }
-  }
-
-  private fun getExceptionMessageOrEmpty(e: Exception): String = e.message ?: ""
-
   companion object {
     const val NAME = "IoReactNativeIso18013"
-    const val ERROR_KEY = "error"
+    const val NOT_INITIALIZED_ERROR_MESSAGE = "Resources not initialized properly, call the start method before this one."
+
+    // Errors which this module uses to reject a promise
+    private object ModuleErrorCodes {
+      // ISO18013-5 related errors
+      const val DRH_NOT_DEFINED = "DRH_NOT_DEFINED"
+      const val QR_ENGAGEMENT_NOT_DEFINED = "QR_ENGAGEMENT_NOT_DEFINED"
+      const val START_ERROR = "START_ERROR"
+      const val GET_QR_CODE_ERROR = "GET_QR_CODE_ERROR"
+      const val GENERATE_RESPONSE_ERROR = "GENERATE_RESPONSE_ERROR"
+      const val SEND_RESPONSE_ERROR = "SEND_RESPONSE_ERROR"
+      const val SEND_ERROR_RESPONSE_ERROR = "SEND_ERROR_RESPONSE_ERROR"
+      const val CLOSE_ERROR = "CLOSE_ERROR"
+
+      // ISO18013-7 related errors
+      const val GENERATE_OID4VP_RESPONSE_ERROR = "GENERATE_OID4VP_RESPONSE_ERROR"
+    }
   }
 }

package/ios/Base64Utils.swift

@@ -4,8 +4,15 @@ import Foundation
  * This class contains a set of utilities for encoding and decoding base64 and base64url strings.
  */
 class Base64Utils {
-  enum Base64DecodingError: Error {
-    case invalidBase64(String)
+  enum Base64DecodingError: LocalizedError {
+      case invalidBase64
+
+      var errorDescription: String? {
+          switch self {
+          case .invalidBase64:
+             return "Input is not a valid Base64 or Base64URL string"
+          }
+      }
   }
   
   /**
@@ -24,7 +31,7 @@ class Base64Utils {
     } else if let data = Data(base64Encoded: base) {
       return data
     } else {
-      throw Base64DecodingError.invalidBase64("Input is not valid Base64 or Base64URL")
+      throw Base64DecodingError.invalidBase64
     }
   }