@pagopa/io-react-native-cie 1.1.2 → 1.2.1

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.11"
+  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

@@ -97,21 +97,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                  |
-| `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?: 'hex' \| 'base64', timeout?: number)`                  | `Promise<void>`    | Start the CIE IAS/NIS Internal Authentication                                  |
+| `startMRTDReading(can: string, resultEncoding?: 'hex' \| 'base64', timeout?: number)`                                   | `Promise<void>`    | Start PACE MRTD reading (reads MRTD data using CAN)                            |
+| `startInternalAuthAndMRTDReading(can: string, challenge: string, resultEncoding?: 'hex' \| 'base64', 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
 
@@ -137,6 +140,18 @@ await CieUtils.isCieAuthenticationSupported();
 
 ### Reading CIE Data
 
+#### Internal Authentication
+
+Start the CIE Internal Authentication
+
+```typescript
+import { CieManager } from '@pagopa/io-react-native-cie';
+
+CieManager.startInternalAuthentication('challenge')
+  .then(() => console.log('Reading started'))
+  .catch((error) => console.error('Error:', error));
+```
+
 #### Reading Attributes
 
 Read CIE attributes (card type and base64-encoded data) with optional timeout (Android only)

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,22 +5,26 @@ 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
 
-typealias ME = IoReactNativeCieModule.Companion.ModuleException
-
 class IoReactNativeCieModule(reactContext: ReactApplicationContext) :
   ReactContextBaseJavaModule(reactContext) {
 
@@ -37,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 {
@@ -54,12 +61,11 @@ class IoReactNativeCieModule(reactContext: ReactApplicationContext) :
         promise.resolve(it)
       }
     } catch (e: Exception) {
-      ME.UNKNOWN_EXCEPTION.reject(
-        promise, Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
+      promise.reject(ModuleException.UNKNOWN_EXCEPTION, e.message, e)
     }
   }
 
+  @Suppress("unused")
   @ReactMethod
   fun isNfcEnabled(promise: Promise) {
     try {
@@ -67,12 +73,11 @@ class IoReactNativeCieModule(reactContext: ReactApplicationContext) :
         promise.resolve(it)
       }
     } catch (e: Exception) {
-      ME.UNKNOWN_EXCEPTION.reject(
-        promise, Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
+      promise.reject(ModuleException.UNKNOWN_EXCEPTION, e.message, e)
     }
   }
 
+  @Suppress("unused")
   @ReactMethod
   fun isCieAuthenticationSupported(promise: Promise) {
     cieSdk.isCieAuthenticationSupported().apply {
@@ -80,33 +85,216 @@ class IoReactNativeCieModule(reactContext: ReactApplicationContext) :
     }
   }
 
+  @Suppress("unused")
   @ReactMethod
   fun openNfcSettings(promise: Promise) {
     try {
       cieSdk.openNfcSettings()
       promise.resolve(null)
     } catch (e: Exception) {
-      ME.UNKNOWN_EXCEPTION.reject(
-        promise, Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
+      promise.reject(ModuleException.UNKNOWN_EXCEPTION, e.message, e)
     }
   }
 
+  @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,
@@ -152,12 +340,11 @@ class IoReactNativeCieModule(reactContext: ReactApplicationContext) :
       })
       promise.resolve(null)
     } catch (e: Exception) {
-      ME.UNKNOWN_EXCEPTION.reject(
-        promise, Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
+      promise.reject(ModuleException.UNKNOWN_EXCEPTION, e.message, e)
     }
   }
 
+  @Suppress("unused")
   @ReactMethod
   fun startReading(
     pin: String,
@@ -168,16 +355,14 @@ class IoReactNativeCieModule(reactContext: ReactApplicationContext) :
     try {
       cieSdk.setPin(pin)
     } catch (e: Exception) {
-      ME.PIN_REGEX_NOT_VALID.reject(
-        promise, Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
-      return;
+      promise.reject(ModuleException.PIN_REGEX_NOT_VALID, e.message, e)
+      return
     }
 
     try {
       cieSdk.withUrl(URL(authenticationUrl).toString())
     } catch (e: Exception) {
-      ME.INVALID_AUTH_URL.reject(promise, Pair(ERROR_USER_INFO_KEY, e.message.orEmpty()))
+      promise.reject(ModuleException.INVALID_AUTH_URL, e.message, e)
       return
     }
 
@@ -218,12 +403,11 @@ class IoReactNativeCieModule(reactContext: ReactApplicationContext) :
       })
       promise.resolve(null)
     } catch (e: Exception) {
-      ME.UNKNOWN_EXCEPTION.reject(
-        promise, Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
+      promise.reject(ModuleException.UNKNOWN_EXCEPTION, e.message, e)
     }
   }
 
+  @Suppress("unused")
   @ReactMethod
   fun stopReading() {
     cieSdk.stopNFCListening()
@@ -253,12 +437,34 @@ class IoReactNativeCieModule(reactContext: ReactApplicationContext) :
 
   companion object {
     const val NAME = "IoReactNativeCie"
-    const val ERROR_USER_INFO_KEY = "error"
+
+    enum class ResultEncoding(val value: String) {
+      BASE64("base64"),
+      HEX("hex");
+
+      fun encode(data: ByteArray): String = when (this) {
+        BASE64 -> Base64.encodeToString(data, Base64.URL_SAFE or Base64.NO_WRAP)
+        HEX -> data.toHex().uppercase()
+      }
+
+      companion object {
+        fun fromString(value: String?): ResultEncoding {
+          return when (value) {
+            "hex" -> HEX
+            "base64" -> BASE64
+            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")
     }
 
@@ -275,26 +481,10 @@ class IoReactNativeCieModule(reactContext: ReactApplicationContext) :
       GENERIC_ERROR,
     }
 
-    enum class ModuleException(
-      val ex: Exception
-    ) {
-      PIN_REGEX_NOT_VALID(Exception("PIN_REGEX_NOT_VALID")),
-      INVALID_AUTH_URL(Exception("INVALID_AUTH_URL")),
-      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)
-      }
+    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"
     }
   }
 }

package/ios/Data/Data+StringRepresentations.swift

@@ -0,0 +1,48 @@
+//
+//  Data+StringRepresentations.swift
+//  Pods
+//
+//  Created by Fabio Bombardi on 02/10/25.
+//
+
+import Foundation
+
+extension Data {
+  
+  /// Converts the data to an uppercase hexadecimal string.
+  func toHexString() -> String {
+    return self.map { String(format: "%02X", $0) }.joined()
+  }
+  
+  /// Converts the data to a base64url encoded string (RFC 7515), without padding.
+  /// - Replaces + with -, / with _, and removes trailing =
+  func base64UrlEncodedString() -> String {
+    return self.base64EncodedString()
+      .replacingOccurrences(of: "+", with: "-")
+      .replacingOccurrences(of: "/", with: "_")
+      .replacingOccurrences(of: "=", with: "")
+  }
+}
+
+// Convenience extension for an array of bytes ([UInt8]).
+extension Array where Element == UInt8 {
+  
+  /// Converts the byte array to a lowercase hexadecimal string.
+  func toHexString() -> String {
+    return Data(self).toHexString()
+  }
+  
+  /// Converts the byte array to a base64url encoded string.
+  func base64UrlEncodedString() -> String {
+    return Data(self).base64UrlEncodedString()
+  }
+  
+  func encodedDataString(encoding: DataEncoding) -> String {
+    switch encoding {
+    case .HEX:
+      return Data(self).toHexString()
+    case .BASE64:
+      return Data(self).base64UrlEncodedString()
+    }
+  }
+}

package/ios/Data/DataEncoding.swift

@@ -0,0 +1,15 @@
+//
+//  DataEncoding.swift
+//  Pods
+//
+//  Created by Fabio Bombardi on 02/10/25.
+//
+
+enum DataEncoding: String, Sendable {
+  case HEX = "HEX"
+  case BASE64 = "BASE64"
+  
+  static func from(string: String?) -> DataEncoding {         
+    return DataEncoding(rawValue: string?.uppercased() ?? "") ?? .BASE64
+  }
+}

package/ios/IoReactNativeCie.mm

@@ -25,6 +25,25 @@ RCT_EXTERN_METHOD(setCurrentAlertMessage:  (NSString)value)
 
 RCT_EXTERN_METHOD(setCustomIdpUrl:  (NSString)url)
 
+RCT_EXTERN_METHOD(startInternalAuthentication:  (NSString)challenge
+                  withResultEncoding:       (NSString)encodingString
+                  withTimeout:              (NSNumber)timeout
+                  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)