@pagopa/io-react-native-cie 1.2.0 → 1.2.2

package/IoReactNativeCie.podspec

@@ -16,7 +16,7 @@ Pod::Spec.new do |s|
   s.source_files = "ios/**/*.{h,m,mm,swift}"
 
   # CieSDK dependency
-  s.dependency "CieSDK", "~> 0.1.12"
+  s.dependency "CieSDK", "~> 0.1.13"
 
 # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
 # See https://github.com/facebook/react-native/blob/febf6b7f33fdb4904669f99d795eba4c0f95d7bf/scripts/cocoapods/new_architecture.rb#L79.

package/README.md

@@ -73,14 +73,15 @@ More info in the [official Android documentation](https://developer.android.com/
    <string>We need to use NFC</string>
    ```
    [More info on Apple's doc](https://developer.apple.com/documentation/bundleresources/information-property-list/nfcreaderusagedescription?language=objc)
-3. Add the required ISO7816 identifiers into your `info.plist`
+3. Add the required ISO7816 identifiers into your `info.plist`. **IMPORTART**: the NFC tags order is important!
    ```xml
    <key>com.apple.developer.nfc.readersession.iso7816.select-identifiers</key>
    <array>
-     <string>A0000000308000000009816001</string>
-     <string>A00000000039</string>
-     <string>A0000002471001</string>
-     <string>00000000000000</string>
+   	<string>A0000002471001</string>
+   	<string>A0000000308000000009816001</string>
+   	<string>A00000000039</string>
+   	<string>A0000002472001</string>
+   	<string>00000000000000</string>
    </array>
    ```
    [More info on Apple's doc](https://developer.apple.com/documentation/corenfc/nfciso7816tag).
@@ -97,22 +98,24 @@ To run the example app, follow the instructions in [example/README.md](./example
 
 List of available functions
 
-| Function                                                                | Return             | Description                                                                    |
-| :---------------------------------------------------------------------- | :----------------- | :----------------------------------------------------------------------------- |
-| `hasNFCFeature()`                                                       | `Promise<boolean>` | (Android) Checks if the device supports NFC feature                            |
-| `isNfcEnabled()`                                                        | `Promise<boolean>` | (Android) Checks if the NFC is currently enabled                               |
-| `isCieAuthenticationSupported()`                                        | `Promise<boolean>` | (Android) Checks if the device supports CIE autentication                      |
-| `openNfcSettings()`                                                     | `Promise<void>`    | (Android) Opens NFC system settings page                                       |
-| `addListener(event: CieEvent, listener: CieEventHandlers)`              | `() => void`       | Adds a NFC event listener and returns a function to unsubscribe from the event |
-| `removeListener(event: CieEvent)`                                       | `void`             | Removes all listeners for the specified event                                  |
-| `removeAllListeners()`                                                  | `void`             | Removes all registered listeners                                               |
-| `setCustomIdpUrl(url?: string)`                                         | `void`             | Updates IDP url, if `undefined` will use the default IDP url                   |
-| `setAlertMessage(key: AlertMessageKey, value: string)`                  | `void`             | (iOS) Updates iOS NFC modal alert message                                      |
-| `setCurrentAlertMessage(value: string)`                                 | `void`             | (iOS) Updates currently displayed iOS NFC modal alert message                  |
-| `startInternalAuthentication(challenge: string)`                        | `Promise<void>`    | Start the CIE IAS/NIS Internal Authentication                                  |
-| `startReadingAttributes(timeout: number)`                               | `Promise<void>`    | Start the CIE attributes reading process                                       |
-| `startReading(pin: string, authenticationUrl: string, timeout: number)` | `Promise<void>`    | Start the CIE reading process fro authentication                               |
-| `stopReading()`                                                         | `Promise<void>`    | (Android) Stops all reading process                                            |
+| Function                                                                                                             | Return             | Description                                                                    |
+| :------------------------------------------------------------------------------------------------------------------- | :----------------- | :----------------------------------------------------------------------------- |
+| `hasNFCFeature()`                                                                                                    | `Promise<boolean>` | (Android) Checks if the device supports NFC feature                            |
+| `isNfcEnabled()`                                                                                                     | `Promise<boolean>` | (Android) Checks if the NFC is currently enabled                               |
+| `isCieAuthenticationSupported()`                                                                                     | `Promise<boolean>` | (Android) Checks if the device supports CIE autentication                      |
+| `openNfcSettings()`                                                                                                  | `Promise<void>`    | (Android) Opens NFC system settings page                                       |
+| `addListener(event: CieEvent, listener: CieEventHandlers)`                                                           | `() => void`       | Adds a NFC event listener and returns a function to unsubscribe from the event |
+| `removeListener(event: CieEvent)`                                                                                    | `void`             | Removes all listeners for the specified event                                  |
+| `removeAllListeners()`                                                                                               | `void`             | Removes all registered listeners                                               |
+| `setCustomIdpUrl(url?: string)`                                                                                      | `void`             | Updates IDP url, if `undefined` will use the default IDP url                   |
+| `setAlertMessage(key: AlertMessageKey, value: string)`                                                               | `void`             | (iOS) Updates iOS NFC modal alert message                                      |
+| `setCurrentAlertMessage(value: string)`                                                                              | `void`             | (iOS) Updates currently displayed iOS NFC modal alert message                  |
+| `startInternalAuthentication(challenge: string, resultEncoding?: ResultEncoding, timeout?: number)`                  | `Promise<void>`    | Start the CIE IAS/NIS Internal Authentication                                  |
+| `startMRTDReading(can: string, resultEncoding?: ResultEncoding, timeout?: number)`                                   | `Promise<void>`    | Start PACE MRTD reading (reads MRTD data using CAN)                            |
+| `startInternalAuthAndMRTDReading(can: string, challenge: string, resultEncoding?: ResultEncoding, timeout?: number)` | `Promise<void>`    | Start combined Internal Authentication + PACE MRTD reading                     |
+| `startReadingAttributes(timeout: number)`                                                                            | `Promise<void>`    | Start the CIE attributes reading process                                       |
+| `startReading(pin: string, authenticationUrl: string, timeout: number)`                                              | `Promise<void>`    | Start the CIE reading process fro authentication                               |
+| `stopReading()`                                                                                                      | `Promise<void>`    | (Android) Stops all reading process                                            |
 
 ## Usage
 
@@ -394,6 +397,54 @@ type NfcError = {
 
 Error event that may be sent during the CIE reading process. Contains the name of the error and an optional message. Error names and order may vary based on the platform.
 
+```typescript
+type InternalAuthResponse = {
+  nis: string,
+  publicKey: string,
+  sod: string,
+  signedChallenge: string,
+});
+```
+
+Represent the CIE response coming from NIS Internal Auth.
+All string value are Hex, Base64 or Base64 url encoded
+
+```typescript
+type MrtdResponse = {
+  dg1: string,
+  dg11: string,
+  sod: string,
+});
+```
+
+Represent the CIE response coming from MRTD with PACE reading
+All string value are Hex, Base64 or Base64 url encoded.
+
+```typescript
+type InternalAuthAndMrtdResponse = {
+  nis_data: {
+    nis: string,
+    publicKey: string,
+    sod: string,
+    signedChallenge: string,
+  },
+  mrtd_data: {
+    dg1: string,
+    dg11: string,
+    sod: string,
+  },
+});
+```
+
+Represent the CIE response coming from NIS Internal Auth and MRTD with PACE reading during the same NFC session.
+All string value are Hex, Base64 or Base64 url encoded.
+
+```typescript
+type ResultEncoding = 'hex' | 'base64' | 'base64url';
+```
+
+Supported types of encoding for Internal Auth and Mrtd reponse payloads.
+
 ## Errors
 
 The CIE reading function may throw exceptions if the reading process cannot be initiated. These exceptions indicate issues with input validation or system compatibility.

package/android/build.gradle

@@ -78,6 +78,6 @@ dependencies {
   implementation "com.facebook.react:react-android"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
   // CIE SDK
-  implementation "it.pagopa.io.app.cie:cie:0.1.5"
+  implementation "it.pagopa.io.app.cie:cie:0.1.7"
 }
 

package/android/src/main/java/com/pagopa/ioreactnativecie/IoReactNativeCieModule.kt

@@ -5,18 +5,24 @@ import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.bridge.WritableMap
 import com.facebook.react.bridge.WritableNativeMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.pagopa.ioreactnativecie.cie.Atr
 import it.pagopa.io.app.cie.CieLogger
 import it.pagopa.io.app.cie.CieSDK
+import it.pagopa.io.app.cie.IntAuthMRTDResponse
+import it.pagopa.io.app.cie.NisAndPaceCallback
 import it.pagopa.io.app.cie.cie.CieAtrCallback
 import it.pagopa.io.app.cie.cie.NfcError
 import it.pagopa.io.app.cie.cie.NfcEvent
 import it.pagopa.io.app.cie.network.NetworkCallback
 import it.pagopa.io.app.cie.network.NetworkError
 import it.pagopa.io.app.cie.nfc.NfcEvents
+import it.pagopa.io.app.cie.nis.InternalAuthenticationResponse
+import it.pagopa.io.app.cie.nis.NisCallback
+import it.pagopa.io.app.cie.pace.MRTDResponse
+import it.pagopa.io.app.cie.pace.PaceCallback
+import it.pagopa.io.app.cie.toHex
 import java.net.URL
 
 class IoReactNativeCieModule(reactContext: ReactApplicationContext) :
@@ -35,16 +41,19 @@ class IoReactNativeCieModule(reactContext: ReactApplicationContext) :
    */
   val cieSdk: CieSDK by lazy {
     CieSDK.withContext(currentActivity)
-  };
+  }
 
+  @Suppress("unused")
   @ReactMethod
   fun addListener(eventName: String) {
   }
 
+  @Suppress("unused")
   @ReactMethod
   fun removeListeners(count: Int) {
   }
 
+  @Suppress("unused")
   @ReactMethod
   fun hasNfcFeature(promise: Promise) {
     try {
@@ -56,6 +65,7 @@ class IoReactNativeCieModule(reactContext: ReactApplicationContext) :
     }
   }
 
+  @Suppress("unused")
   @ReactMethod
   fun isNfcEnabled(promise: Promise) {
     try {
@@ -67,6 +77,7 @@ class IoReactNativeCieModule(reactContext: ReactApplicationContext) :
     }
   }
 
+  @Suppress("unused")
   @ReactMethod
   fun isCieAuthenticationSupported(promise: Promise) {
     cieSdk.isCieAuthenticationSupported().apply {
@@ -74,6 +85,7 @@ class IoReactNativeCieModule(reactContext: ReactApplicationContext) :
     }
   }
 
+  @Suppress("unused")
   @ReactMethod
   fun openNfcSettings(promise: Promise) {
     try {
@@ -84,21 +96,205 @@ class IoReactNativeCieModule(reactContext: ReactApplicationContext) :
     }
   }
 
+  @Suppress("unused")
   @ReactMethod
   fun setAlertMessage(key: String, value: String) {
     // Android does not support alert messages for NFC reading
   }
 
+  @Suppress("unused")
   @ReactMethod
   fun setCurrentAlertMessage(value: String) {
     // Android does not support alert messages for NFC reading
   }
 
+  @Suppress("unused")
   @ReactMethod
   fun setCustomIdpUrl(url: String) {
     cieSdk.withCustomIdpUrl(url)
   }
 
+  @Suppress("unused")
+  @ReactMethod
+  fun startInternalAuthentication(
+    challenge: String,
+    resultEncoding: String,
+    timeout: Int = 10000,
+    promise: Promise,
+  ) {
+    val encoding: ResultEncoding = ResultEncoding.fromString(resultEncoding)
+    try {
+      cieSdk.startReadingNis(challenge, timeout, object : NfcEvents {
+        override fun event(event: NfcEvent) {
+          this@IoReactNativeCieModule.reactApplicationContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(EventType.EVENT.value, WritableNativeMap().apply {
+              putString("name", event.name)
+              putDouble(
+                "progress",
+                (event.numeratorForNis.toDouble() / NfcEvent.totalNisOfNumeratorEvent.toDouble())
+              )
+            })
+        }
+
+        override fun error(error: NfcError) {
+          this@IoReactNativeCieModule.reactApplicationContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(EventType.ERROR.value, WritableNativeMap().apply {
+              putString("name", mapNfcError(error).name)
+              error.msg?.let { putString("message", it) }
+            })
+
+        }
+      }, object : NisCallback {
+        override fun onSuccess(nisAuth: InternalAuthenticationResponse) {
+          this@IoReactNativeCieModule.reactApplicationContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(EventType.INTERNAL_AUTHENTICATION_SUCCESS.value, WritableNativeMap().apply {
+              putString("nis", encoding.encode(nisAuth.nis))
+              putString("publicKey", encoding.encode(nisAuth.kpubIntServ))
+              putString("sod", encoding.encode(nisAuth.sod))
+              putString("signedChallenge", encoding.encode(nisAuth.challengeSigned))
+            })
+        }
+
+        override fun onError(error: NfcError) {
+          this@IoReactNativeCieModule.reactApplicationContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(EventType.ERROR.value, WritableNativeMap().apply {
+              putString("name", mapNfcError(error).name)
+              error.msg?.let { putString("message", it) }
+            })
+        }
+      })
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject(ModuleException.UNKNOWN_EXCEPTION, e.message, e)
+    }
+  }
+
+  @Suppress("unused")
+  @ReactMethod
+  fun startMRTDReading(
+    can: String,
+    resultEncoding: String,
+    timeout: Int = 10000,
+    promise: Promise,
+  ) {
+    val encoding: ResultEncoding = ResultEncoding.fromString(resultEncoding)
+    try {
+      cieSdk.startDoPace(can, timeout, object : NfcEvents {
+        override fun event(event: NfcEvent) {
+          this@IoReactNativeCieModule.reactApplicationContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(EventType.EVENT.value, WritableNativeMap().apply {
+              putString("name", event.name)
+              putDouble(
+                "progress",
+                (event.numeratorForPace.toDouble() / NfcEvent.totalPaceOfNumeratorEvent.toDouble())
+              )
+            })
+        }
+
+        override fun error(error: NfcError) {
+          this@IoReactNativeCieModule.reactApplicationContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(EventType.ERROR.value, WritableNativeMap().apply {
+              putString("name", mapNfcError(error).name)
+              error.msg?.let { putString("message", it) }
+            })
+
+        }
+      }, object : PaceCallback {
+        override fun onSuccess(eMRTDResponse: MRTDResponse) {
+          this@IoReactNativeCieModule.reactApplicationContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(EventType.MRTD_WITH_PACE_SUCCESS.value, WritableNativeMap().apply {
+              putString("dg1", encoding.encode(eMRTDResponse.dg1))
+              putString("dg11", encoding.encode(eMRTDResponse.dg11))
+              putString("sod", encoding.encode(eMRTDResponse.sod))
+            })
+        }
+
+        override fun onError(error: NfcError) {
+          this@IoReactNativeCieModule.reactApplicationContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(EventType.ERROR.value, WritableNativeMap().apply {
+              putString("name", mapNfcError(error).name)
+              error.msg?.let { putString("message", it) }
+            })
+        }
+      })
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject(ModuleException.UNKNOWN_EXCEPTION, e.message, e)
+    }
+  }
+
+  @Suppress("unused")
+  @ReactMethod
+  fun startInternalAuthAndMRTDReading(
+    can: String,
+    challenge: String,
+    resultEncoding: String,
+    timeout: Int = 10000,
+    promise: Promise,
+  ) {
+    val encoding: ResultEncoding = ResultEncoding.fromString(resultEncoding)
+    try {
+      cieSdk.startNisAndPace(challenge, can, timeout, object : NfcEvents {
+        override fun event(event: NfcEvent) {
+          this@IoReactNativeCieModule.reactApplicationContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(EventType.EVENT.value, WritableNativeMap().apply {
+              putString("name", event.name)
+              putDouble(
+                "progress",
+                (event.numeratorForNisAndPace.toDouble() / NfcEvent.totalNisAndPaceOfNumeratorEvent.toDouble())
+              )
+            })
+        }
+
+        override fun error(error: NfcError) {
+          this@IoReactNativeCieModule.reactApplicationContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(EventType.ERROR.value, WritableNativeMap().apply {
+              putString("name", mapNfcError(error).name)
+              error.msg?.let { putString("message", it) }
+            })
+
+        }
+      }, object : NisAndPaceCallback {
+        override fun onSuccess(intAuthMRTDResponse: IntAuthMRTDResponse) {
+          this@IoReactNativeCieModule.reactApplicationContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(
+              EventType.INTERNAL_AUTH_AND_MRTD_WITH_PACE_SUCCESS.value,
+              WritableNativeMap().apply {
+                putMap("nis_data", WritableNativeMap().apply {
+                  putString("nis", encoding.encode(intAuthMRTDResponse.internalAuthentication.nis))
+                  putString(
+                    "publicKey",
+                    encoding.encode(intAuthMRTDResponse.internalAuthentication.kpubIntServ)
+                  )
+                  putString("sod", encoding.encode(intAuthMRTDResponse.internalAuthentication.sod))
+                  putString(
+                    "signedChallenge",
+                    encoding.encode(intAuthMRTDResponse.internalAuthentication.challengeSigned)
+                  )
+                })
+                putMap("mrtd_data", WritableNativeMap().apply {
+                  putString("dg1", encoding.encode(intAuthMRTDResponse.mrtd.dg1))
+                  putString("dg11", encoding.encode(intAuthMRTDResponse.mrtd.dg11))
+                  putString("sod", encoding.encode(intAuthMRTDResponse.mrtd.sod))
+                })
+              })
+        }
+
+        override fun onError(error: NfcError) {
+          this@IoReactNativeCieModule.reactApplicationContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(EventType.ERROR.value, WritableNativeMap().apply {
+              putString("name", mapNfcError(error).name)
+              error.msg?.let { putString("message", it) }
+            })
+        }
+      })
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject(ModuleException.UNKNOWN_EXCEPTION, e.message, e)
+    }
+  }
+
+  @Suppress("unused")
   @ReactMethod
   fun startReadingAttributes(
     timeout: Int = 10000,
@@ -148,6 +344,7 @@ class IoReactNativeCieModule(reactContext: ReactApplicationContext) :
     }
   }
 
+  @Suppress("unused")
   @ReactMethod
   fun startReading(
     pin: String,
@@ -159,7 +356,7 @@ class IoReactNativeCieModule(reactContext: ReactApplicationContext) :
       cieSdk.setPin(pin)
     } catch (e: Exception) {
       promise.reject(ModuleException.PIN_REGEX_NOT_VALID, e.message, e)
-      return;
+      return
     }
 
     try {
@@ -210,6 +407,7 @@ class IoReactNativeCieModule(reactContext: ReactApplicationContext) :
     }
   }
 
+  @Suppress("unused")
   @ReactMethod
   fun stopReading() {
     cieSdk.stopNFCListening()
@@ -239,12 +437,37 @@ class IoReactNativeCieModule(reactContext: ReactApplicationContext) :
 
   companion object {
     const val NAME = "IoReactNativeCie"
-    const val ERROR_USER_INFO_KEY = "error"
+
+    enum class ResultEncoding(val value: String) {
+      HEX("hex"),
+      BASE64("base64"),
+      BASE64URL("base64url");
+
+      fun encode(data: ByteArray): String = when (this) {
+        HEX -> data.toHex().uppercase()
+        BASE64 -> Base64.encodeToString(data, Base64.DEFAULT or Base64.NO_WRAP)
+        BASE64URL -> Base64.encodeToString(data, Base64.URL_SAFE or Base64.NO_WRAP)
+      }
+
+      companion object {
+        fun fromString(value: String?): ResultEncoding {
+          return when (value) {
+            "hex" -> HEX
+            "base64" -> BASE64
+            "base64url" -> BASE64URL
+            else -> BASE64 // Default
+          }
+        }
+      }
+    }
 
     enum class EventType(val value: String) {
       EVENT("onEvent"),
       ERROR("onError"),
       ATTRIBUTES_SUCCESS("onAttributesSuccess"),
+      INTERNAL_AUTHENTICATION_SUCCESS("onInternalAuthenticationSuccess"),
+      MRTD_WITH_PACE_SUCCESS("onMRTDWithPaceSuccess"),
+      INTERNAL_AUTH_AND_MRTD_WITH_PACE_SUCCESS("onInternalAuthAndMRTDWithPaceSuccess"),
       SUCCESS("onSuccess")
     }
 
@@ -262,9 +485,9 @@ class IoReactNativeCieModule(reactContext: ReactApplicationContext) :
     }
 
     private object ModuleException {
-      const val PIN_REGEX_NOT_VALID = "PIN_REGEX_NOT_VALID";
-      const val INVALID_AUTH_URL = "INVALID_AUTH_URL";
-      const val UNKNOWN_EXCEPTION = "UNKNOWN_EXCEPTION";
+      const val PIN_REGEX_NOT_VALID = "PIN_REGEX_NOT_VALID"
+      const val INVALID_AUTH_URL = "INVALID_AUTH_URL"
+      const val UNKNOWN_EXCEPTION = "UNKNOWN_EXCEPTION"
     }
   }
 }

package/ios/Data/Data+StringRepresentations.swift

@@ -9,9 +9,9 @@ import Foundation
 
 extension Data {
   
-  /// Converts the data to a lowercase hexadecimal string.
+  /// Converts the data to an uppercase hexadecimal string.
   func toHexString() -> String {
-    return self.map { String(format: "%02x", $0) }.joined()
+    return self.map { String(format: "%02X", $0) }.joined()
   }
   
   /// Converts the data to a base64url encoded string (RFC 7515), without padding.
@@ -32,6 +32,11 @@ extension Array where Element == UInt8 {
     return Data(self).toHexString()
   }
   
+  /// Converts the byte array to a base64 encoded string.
+  func base64EncodedString() -> String {
+    return Data(self).base64EncodedString()
+  }
+  
   /// Converts the byte array to a base64url encoded string.
   func base64UrlEncodedString() -> String {
     return Data(self).base64UrlEncodedString()
@@ -42,6 +47,8 @@ extension Array where Element == UInt8 {
     case .HEX:
       return Data(self).toHexString()
     case .BASE64:
+      return Data(self).base64EncodedString()
+    case .BASE64URL:
       return Data(self).base64UrlEncodedString()
     }
   }

package/ios/Data/DataEncoding.swift

@@ -8,6 +8,7 @@
 enum DataEncoding: String, Sendable {
   case HEX = "HEX"
   case BASE64 = "BASE64"
+  case BASE64URL = "BASE64URL"
   
   static func from(string: String?) -> DataEncoding {         
     return DataEncoding(rawValue: string?.uppercased() ?? "") ?? .BASE64

package/ios/IoReactNativeCie.mm

@@ -31,6 +31,19 @@ RCT_EXTERN_METHOD(startInternalAuthentication:  (NSString)challenge
                   withResolver:             (RCTPromiseResolveBlock)resolve
                   withRejecter:             (RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(startMRTDReading:         (NSString)can
+                  withResultEncoding:       (NSString)encodingString
+                  withTimeout:              (NSNumber)timeout
+                  withResolver:             (RCTPromiseResolveBlock)resolve
+                  withRejecter:             (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(startInternalAuthAndMRTDReading:  (NSString)can
+                  withChallenge:            (NSString)challenge
+                  withResultEncoding:       (NSString)encodingString
+                  withTimeout:              (NSNumber)timeout
+                  withResolver:             (RCTPromiseResolveBlock)resolve
+                  withRejecter:             (RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(startReadingAttributes:   (NSNumber)timeout
                   withResolver:             (RCTPromiseResolveBlock)resolve
                   withRejecter:             (RCTPromiseRejectBlock)reject)

package/ios/IoReactNativeCie.swift

@@ -85,15 +85,99 @@ class IoReactNativeCie: RCTEventEmitter {
         )
         let encoding = DataEncoding.from(string: encodingString)
         let payload: NSDictionary = [
-          "response": [
+          "nis": internalAuthResponse.nis.encodedDataString(encoding: encoding),
+          "publicKey": internalAuthResponse.publicKey.encodedDataString(encoding: encoding),
+          "sod": internalAuthResponse.sod.encodedDataString(encoding: encoding),
+          "signedChallenge": internalAuthResponse.signedChallenge.encodedDataString(encoding: encoding)
+        ]
+        self.sendEvent(
+          withName: EventType.onInternalAuthenticationSuccess.rawValue, body: payload)
+        resolve(nil)
+      } catch {
+        guard let nfcDigitalIdError = error as? NfcDigitalIdError else {
+          reject(ModuleException.unexpected.rawValue, error.localizedDescription, error)
+          return
+        }
+        handleReadError(nfcDigitalIdError)
+        resolve(nil)
+      }
+    }
+  }
+  
+  @objc func startMRTDReading(
+    _ can: String,
+    withResultEncoding encodingString: String,
+    withTimeout timeout: Int,
+    withResolver resolve: @escaping RCTPromiseResolveBlock,
+    withRejecter reject: @escaping RCTPromiseRejectBlock
+  ) {
+    Task { [weak self] in
+      guard let self = self else {
+        reject(ModuleException.threadingError.rawValue, "Failed to perform background operation, self was deallocated", nil)
+        return
+      }
+      
+      do {
+        let mrtdResponse = try await self.cieSdk.performMtrd(
+          can: can,
+          handleReadEvent
+        )
+        let encoding = DataEncoding.from(string: encodingString)
+        let payload: NSDictionary = [
+          "dg1": mrtdResponse.dg1.encodedDataString(encoding: encoding),
+          "dg11": mrtdResponse.dg11.encodedDataString(encoding: encoding),
+          "sod": mrtdResponse.sod.encodedDataString(encoding: encoding)
+        ]
+        self.sendEvent(
+          withName: EventType.onMRTDWithPaceSuccess.rawValue, body: payload)
+        resolve(nil)
+      } catch {
+        guard let nfcDigitalIdError = error as? NfcDigitalIdError else {
+          reject(ModuleException.unexpected.rawValue, error.localizedDescription, error)
+          return
+        }
+        handleReadError(nfcDigitalIdError)
+        resolve(nil)
+      }
+    }
+  }
+  
+  @objc func startInternalAuthAndMRTDReading(
+    _ can: String,
+    withChallenge challenge: String,
+    withResultEncoding encodingString: String,
+    withTimeout timeout: Int,
+    withResolver resolve: @escaping RCTPromiseResolveBlock,
+    withRejecter reject: @escaping RCTPromiseRejectBlock
+  ) {
+    Task { [weak self] in
+      guard let self = self else {
+        reject(ModuleException.threadingError.rawValue, "Failed to perform background operation, self was deallocated", nil)
+        return
+      }
+      
+      do {
+        let (mrtdResponse, internalAuthResponse) = try await self.cieSdk.performMRTDAndInternalAuthentication(
+          challenge: Array(challenge.utf8),
+          can: can,
+          handleReadEvent
+        )
+        let encoding = DataEncoding.from(string: encodingString)
+        let payload: NSDictionary = [
+          "nis_data": [
             "nis": internalAuthResponse.nis.encodedDataString(encoding: encoding),
             "publicKey": internalAuthResponse.publicKey.encodedDataString(encoding: encoding),
             "sod": internalAuthResponse.sod.encodedDataString(encoding: encoding),
             "signedChallenge": internalAuthResponse.signedChallenge.encodedDataString(encoding: encoding)
+          ],
+          "mrtd_data": [
+            "dg1": mrtdResponse.dg1.encodedDataString(encoding: encoding),
+            "dg11": mrtdResponse.dg11.encodedDataString(encoding: encoding),
+            "sod": mrtdResponse.sod.encodedDataString(encoding: encoding)
           ]
         ]
         self.sendEvent(
-          withName: EventType.onInternalAuthenticationSuccess.rawValue, body: payload)
+          withName: EventType.onInternalAuthAndMRTDWithPaceSuccess.rawValue, body: payload)
         resolve(nil)
       } catch {
         guard let nfcDigitalIdError = error as? NfcDigitalIdError else {
@@ -216,6 +300,8 @@ class IoReactNativeCie: RCTEventEmitter {
     case onError
     case onAttributesSuccess
     case onInternalAuthenticationSuccess
+    case onMRTDWithPaceSuccess
+    case onInternalAuthAndMRTDWithPaceSuccess
     case onSuccess
   }