otpless-headless-rn 2.2.0 → 3.0.0

package/README.md

@@ -44,6 +44,24 @@ useEffect(() => {
   }, []);
 ```
 
+### SSL pinning (optional)
+
+SSL pinning is **off by default**; the two-argument `initialize` call above behaves exactly as before. To opt in, pass a third `options` argument:
+
+```javascript
+headlessModule.initialize("YOUR_APPID", null, { sslPinning: 'enabled' });
+```
+
+```ts
+type OtplessSslPinning = 'enabled' | 'disabled';
+interface OtplessInitOptions { sslPinning?: OtplessSslPinning }
+initialize(appId: string, loginUri?: string | null, options?: OtplessInitOptions): void
+```
+
+When enabled, the native SDK pins the TLS certificate of `sigma.otpless.app` on both Android and iOS. If the pin does not match (for example behind an intercepting proxy such as Charles or Proxyman), the SDK **fails closed**: no request leaves the device and you receive `FAILED` with `statusCode` `5004` (see [Response Handling](#response-handling)). If your organisation runs a corporate proxy or a network allowlist, make sure `sigma.otpless.app` is reachable directly with its original certificate.
+
+Requires `io.github.otpless-tech:otpless-headless-sdk` >= 2.0.1 on Android and `OtplessBM/Core` >= 3.0.1 on iOS (both pulled in automatically by this package).
+
 # Initiate Authentication
 
 ## Phone Auth
@@ -86,8 +104,19 @@ const onHeadlessResult = (result: any) => {
       break;
     }
     case "FAILED": {
+      if (result.statusCode == 5003) {
+        // SDK initialization failed (e.g. invalid appId or network unavailable)
         console.log("SDK initialization failed");
-        // Handle SDK initialization failure
+      } else if (result.statusCode == 5004) {
+        // SSL pin validation failed. Only emitted when `initialize` was called
+        // with `{ sslPinning: 'enabled' }`. The SDK sent nothing to the server;
+        // the connection to sigma.otpless.app is being intercepted or its
+        // certificate does not match the expected pin.
+        // result.response = { errorCode: "5004", errorMessage: "SSL pin validation failed" }
+        console.log("SSL pin validation failed");
+      } else {
+        console.log("SDK failed", result.statusCode);
+      }
       break;
     }
     case "INITIATE": {

package/android/build.gradle

@@ -8,7 +8,7 @@ buildscript {
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:8.3.0"
+    classpath "com.android.tools.build:gradle:8.10.0"
     // noinspection DifferentKotlinGradleVersion
     classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
   }
@@ -37,7 +37,7 @@ def getExtOrIntegerDefault(name) {
 }
 
 android {
-  compileSdk 35
+  compileSdk 36
   namespace "com.otplessheadlessrn"
   defaultConfig {
     minSdkVersion 21
@@ -74,7 +74,7 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  implementation ("io.github.otpless-tech:otpless-headless-sdk:0.8.1")
+  implementation ("io.github.otpless-tech:otpless-headless-sdk:2.0.1")
 }
 
 if (isNewArchitectureEnabled()) {

package/android/gradle.properties

@@ -1,5 +1,5 @@
-OtplessHeadlessRN_kotlinVersion=1.9.25
+OtplessHeadlessRN_kotlinVersion=2.0.21
 OtplessHeadlessRN_minSdkVersion=24
 OtplessHeadlessRN_targetSdkVersion=35
-OtplessHeadlessRN_compileSdkVersion=35
+OtplessHeadlessRN_compileSdkVersion=36
 OtplessHeadlessRN_ndkversion=21.4.7075529

package/android/src/main/java/com/otplessheadlessrn/OtplessReactNativeModule.kt

@@ -2,30 +2,29 @@ package com.otplessheadlessrn
 
 import android.app.Activity
 import android.content.Intent
-import androidx.appcompat.app.AppCompatActivity
+import android.util.Log
 import androidx.fragment.app.FragmentActivity
-import androidx.lifecycle.lifecycleScope
 import com.facebook.react.bridge.ActivityEventListener
 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.ReadableMap
-import com.facebook.react.bridge.ReadableType
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.otpless.longclaw.tc.OTScopeRequest
-import com.otpless.v2.android.sdk.dto.AuthEvent
-import com.otpless.v2.android.sdk.dto.OtplessChannelType
-import com.otpless.v2.android.sdk.dto.ProviderType
-import com.otpless.v2.android.sdk.dto.OtplessRequest
 import com.otpless.v2.android.sdk.dto.OtplessResponse
-import com.otpless.v2.android.sdk.dto.ResponseTypes
+import com.otpless.v2.android.sdk.dto.OtplessSslKind
 import com.otpless.v2.android.sdk.main.OtplessSDK
+import com.otpless.v2.android.sdk.utils.BuildPlatform
 import com.otpless.v2.android.sdk.utils.OtplessUtils
+import kotlinx.coroutines.CoroutineExceptionHandler
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import org.json.JSONException
 import org.json.JSONObject
 
@@ -33,6 +32,10 @@ class OtplessHeadlessRNModule(private val reactContext: ReactApplicationContext)
   ReactContextBaseJavaModule(reactContext), ActivityEventListener {
 
   private var otplessJob: Job? = null
+  private val lifecycleMutex = Mutex()
+  private val ioScope = CoroutineScope(Dispatchers.IO + SupervisorJob() + CoroutineExceptionHandler { context, throwable ->
+    Log.d("OTPLESS", "Error in coroutine", throwable)
+  })
 
   init {
     reactContext.addActivityEventListener(this)
@@ -71,24 +74,28 @@ class OtplessHeadlessRNModule(private val reactContext: ReactApplicationContext)
   }
 
   @ReactMethod
-  fun initialize(appId: String, loginUri: String? = null) {
-    if (currentActivity == null) return
-    (currentActivity as? AppCompatActivity)?.lifecycleScope?.let { scope ->
-      scope.launch(Dispatchers.IO) {
+  fun initialize(appId: String, loginUri: String?, sslPinning: String?, buildPlatform: String?) {
+    val activity = currentActivity ?: return
+    val sslKind: OtplessSslKind =
+      if (sslPinning == "enabled") OtplessSslKind.SslEnabled else OtplessSslKind.SslDisabled
+    // Wrapper attribution, computed in JS (which owns the single source of
+    // truth for the package version) and arriving as
+    // "react-native-android-<packageVersion>". This bridge is a dumb forwarder;
+    // the literal fallback covers an older JS layer that does not send the
+    // argument, so the token can never be blank.
+    val buildPlatformToken = buildPlatform?.trim()?.takeIf { it.isNotEmpty() } ?: "react-native-android"
+    ioScope.launch {
+      lifecycleMutex.withLock {
+        // Tells the native SDK this session came through the React Native
+        // wrapper, so device telemetry reports
+        // platform = "otpless-headless-sdk(react-native-android-<version>)"
+        // instead of the default "otpless-headless-sdk(android)". Must be set
+        // before initialize, which is what emits the event.
+        OtplessSDK.buildPlatform = BuildPlatform(buildPlatformToken)
         OtplessSDK.initialize(
-          appId = appId,
-          activity = currentActivity!!,
-          loginUri = loginUri,
-          callback = this@OtplessHeadlessRNModule::sendHeadlessEventCallback
-        )
-      }
-    } ?: run {
-      CoroutineScope(Dispatchers.IO).launch {
-        OtplessSDK.initialize(
-          appId = appId,
-          activity = currentActivity!!,
-          loginUri = loginUri,
-          callback = this@OtplessHeadlessRNModule::sendHeadlessEventCallback
+          appId = appId, activity = activity,
+          loginUri = loginUri, callback = this@OtplessHeadlessRNModule::sendHeadlessEventCallback,
+          sslKind = sslKind
         )
       }
     }
@@ -96,11 +103,11 @@ class OtplessHeadlessRNModule(private val reactContext: ReactApplicationContext)
 
   @ReactMethod
   fun initTrueCaller(requestMap: ReadableMap, promise: Promise) {
-    if (currentActivity == null) return
+    val activity = currentActivity ?: return
     val request = parseTrueCallerRequest(requestMap)
     val scopes = parseTrueCallerScope(requestMap)
-    val result = OtplessSDK.initTrueCaller(currentActivity!!, request) {
-      OTScopeRequest.ActivityRequest(currentActivity as FragmentActivity, scopes)
+    val result = OtplessSDK.initTrueCaller(activity, request) {
+      OTScopeRequest.ActivityRequest(activity as FragmentActivity, scopes)
     }
     debugLog("init truecaller result: $result")
     promise.resolve(result)
@@ -108,100 +115,32 @@ class OtplessHeadlessRNModule(private val reactContext: ReactApplicationContext)
 
   @ReactMethod
   fun userAuthEvent(event: String, fallback: Boolean, providerType: String, providerInfo: ReadableMap?) {
-    // Defensive enum parsing — unknown values log and return rather than crashing the bridge.
-    val authEvent = runCatching { AuthEvent.valueOf(event) }.getOrElse {
+    val authEvent = parseAuthEvent(event) ?: run {
       debugLog("userAuthEvent: unknown AuthEvent '$event', ignoring call")
       return
     }
-    val provider = runCatching { ProviderType.valueOf(providerType) }.getOrElse {
+    val provider = parseProviderType(providerType) ?: run {
       debugLog("userAuthEvent: unknown ProviderType '$providerType', ignoring call")
       return
     }
-    // Defensive providerInfo parsing — JS passes `any`, so coerce each value to String:
-    // primitives via toString(), Maps/Arrays via JSON serialisation, Null skipped.
-    val infoMap = mutableMapOf<String, String>()
-    if (providerInfo != null) {
-      try {
-        val iterator = providerInfo.keySetIterator()
-        while (iterator.hasNextKey()) {
-          val key = iterator.nextKey() ?: continue
-          val value: String? = when (providerInfo.getType(key)) {
-            ReadableType.String -> providerInfo.getString(key)
-            ReadableType.Number -> providerInfo.getDouble(key).toString()
-            ReadableType.Boolean -> providerInfo.getBoolean(key).toString()
-            ReadableType.Map -> convertMapToJson(providerInfo.getMap(key))?.toString()
-            ReadableType.Array -> convertArrayToJson(providerInfo.getArray(key))?.toString()
-            else -> null  // Null — skip
-          }
-          if (value != null) infoMap[key] = value
-        }
-      } catch (_: Exception) {
-        // swallow any unexpected bridge parsing errors
-      }
-    }
+    val infoMap = parseProviderInfo(providerInfo)
     debugLog("pushing the user auth event\nauthEvent: $authEvent, providerType: $providerType")
     OtplessSDK.userAuthEvent(authEvent, fallback, provider, infoMap)
   }
 
   @ReactMethod
   fun start(data: ReadableMap) {
-    val otplessRequest = OtplessRequest()
-    val phone = data.getString("phone") ?: ""
-    var isOtpPresent = false
-
-    // phone number authentication
-    if (phone.isNotEmpty()) {
-      val countryCode = data.getString("countryCode") ?: ""
-      otplessRequest.setPhoneNumber(number = phone, countryCode = countryCode)
-      data.getString("otp")?.let {
-        otplessRequest.setOtp(it)
-        isOtpPresent = true
-      }
-    } else {
-      // email authentication
-      val email = data.getString("email") ?: ""
-      if (email.isNotEmpty()) {
-        otplessRequest.setEmail(email)
-        data.getString("otp")?.let {
-          otplessRequest.setOtp(it)
-          isOtpPresent = true
-        }
-      } else {
-        // oauth case
-        otplessRequest.setChannelType(
-          OtplessChannelType.fromString(
-            data.getString("channelType") ?: ""
-          )
-        )
-      }
-    }
-    data.getString("expiry")?.takeIf { it.isNotBlank() }?.let {
-      otplessRequest.setExpiry(it)
-    }
-
-    data.getString("otpLength")?.takeIf { it.isNotBlank() }?.let {
-      otplessRequest.setOtpLength(it)
-    }
+    val otplessRequest = parseOtplessRequest(data)
+    val isOtpVerification = !data.getString("otp").isNullOrEmpty()
 
-    data.getString("deliveryChannel")?.takeIf { it.isNotBlank() }?.let { deliveryChannel ->
-      otplessRequest.setDeliveryChannel(deliveryChannel.uppercase())
-    }
-
-    data.getString("tid")?.takeIf { it.isNotBlank() }?.let { templateId ->
-      otplessRequest.setTemplateId(templateId)
-    }
-
-    otplessJob?.cancel()
-    currentActivity?.let {
-      if (isOtpPresent) (it as AppCompatActivity).lifecycleScope.launch(Dispatchers.IO) {
+    if (isOtpVerification) {
+      // OTP submit — slot into the current auth flow; don't cancel, don't track
+      ioScope.launch {
         OtplessSDK.start(request = otplessRequest, this@OtplessHeadlessRNModule::sendHeadlessEventCallback)
-      } else {
-        otplessJob = (it as AppCompatActivity).lifecycleScope.launch {
-          OtplessSDK.start(request = otplessRequest, this@OtplessHeadlessRNModule::sendHeadlessEventCallback)
-        }
       }
-    } ?:  run {
-      CoroutineScope(Dispatchers.IO).launch {
+    } else {
+      otplessJob?.cancel()
+      otplessJob = ioScope.launch {
         OtplessSDK.start(request = otplessRequest, this@OtplessHeadlessRNModule::sendHeadlessEventCallback)
       }
     }
@@ -215,7 +154,11 @@ class OtplessHeadlessRNModule(private val reactContext: ReactApplicationContext)
   @ReactMethod
   fun cleanup() {
     otplessJob?.cancel()
-    OtplessSDK.cleanup()
+    ioScope.launch {
+      lifecycleMutex.withLock {
+        OtplessSDK.cleanup()
+      }
+    }
   }
 
   @ReactMethod
@@ -224,47 +167,82 @@ class OtplessHeadlessRNModule(private val reactContext: ReactApplicationContext)
     OtplessSDK.devLogging = devLogging
   }
 
-  companion object {
-    const val NAME = "OtplessHeadlessRN"
+  @ReactMethod
+  fun setMfaEnabled(enabled: Boolean) {
+    OtplessSDK.isMfaEnabled = enabled
+  }
+
+  @ReactMethod
+  fun setSimBindingEnabled(enabled: Boolean) {
+    OtplessSDK.isSimBindingEnabled = enabled
+  }
+
+  @ReactMethod
+  fun checkSimBindingStatus(promise: Promise) {
+    ioScope.launch {
+      try {
+        val bound = OtplessSDK.checkSimBindingStatus(reactContext.applicationContext)
+        promise.resolve(bound)
+      } catch (_: Throwable) {
+        promise.resolve(false)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun clearSimBinding(promise: Promise) {
+    ioScope.launch {
+      try {
+        OtplessSDK.clearSimBinding(reactContext.applicationContext)
+        promise.resolve(null)
+      } catch (_: Throwable) {
+        promise.resolve(null)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun startInBackground(data: ReadableMap) {
+    val otplessRequest = parseOtplessRequest(data)
+    otplessJob?.cancel()
+    otplessJob = ioScope.launch(Dispatchers.IO) {
+      OtplessSDK.startInBackground(otplessRequest, this@OtplessHeadlessRNModule::sendHeadlessEventCallback)
+    }
+  }
+
+  @ReactMethod
+  fun startBackgroundAuth(config: ReadableMap, promise: Promise) {
+    val activity = currentActivity
+    if (activity == null) {
+      promise.resolve(false)
+      return
+    }
+    val authConfig = parseOtplessAuthConfig(config)
+    ioScope.launch {
+      val result = OtplessSDK.start(authConfig)
+      promise.resolve(result)
+    }
   }
 
   override fun onActivityResult(
-    activity: Activity?,
-    requestCode: Int,
-    resultCode: Int,
-    data: Intent?
+    activity: Activity?, requestCode: Int, resultCode: Int, data: Intent?
   ) {
     OtplessSDK.onActivityResult(requestCode, resultCode, data)
   }
 
   override fun onNewIntent(intent: Intent?) {
     intent ?: return
-    (currentActivity as? AppCompatActivity)?.let { ac ->
-      ac.lifecycleScope.launch(Dispatchers.IO) {
-        OtplessSDK.onNewIntent(intent)
-      }
-    }
+    ioScope.launch { OtplessSDK.onNewIntent(intent) }
   }
 
   @ReactMethod
   fun commitResponse(data: ReadableMap?) {
-    val dataMap = data?.toHashMap() ?: return
-    val jsonResponse = JSONObject(dataMap as Map<*, *>)
-    val otplessResponse = OtplessResponse(
-      responseType = getResponseType(
-        responseTypeString = jsonResponse.optString(
-          "responseType",
-          ""
-        )
-      ),
-      jsonResponse.optJSONObject("response"),
-      jsonResponse.optInt("statusCode", 0),
-    )
+    val otplessResponse = parseOtplessResponse(data) ?: return
     OtplessSDK.commit(otplessResponse)
   }
 
-  private fun getResponseType(responseTypeString: String): ResponseTypes {
-    return ResponseTypes.valueOf(responseTypeString)
+  companion object {
+    const val NAME = "OtplessHeadlessRN"
   }
 }
 

package/android/src/main/java/com/otplessheadlessrn/utils.kt

@@ -17,6 +17,14 @@ import com.otpless.longclaw.tc.OTLoginPrefixText
 import com.otpless.longclaw.tc.OTScope
 import com.otpless.longclaw.tc.OTVerifyOption
 import com.otpless.longclaw.tc.OtplessTruecallerRequest
+import com.otpless.v2.android.sdk.dto.AuthEvent
+import com.otpless.v2.android.sdk.dto.DeviceFingerprintMode
+import com.otpless.v2.android.sdk.dto.OtplessChannelType
+import com.otpless.v2.android.sdk.dto.OtplessRequest
+import com.otpless.v2.android.sdk.dto.OtplessResponse
+import com.otpless.v2.android.sdk.dto.ProviderType
+import com.otpless.v2.android.sdk.dto.ResponseTypes
+import com.otpless.v2.android.sdk.view.models.OtplessAuthConfig
 import org.json.JSONArray
 import org.json.JSONException
 import org.json.JSONObject
@@ -131,6 +139,94 @@ internal fun convertJsonToArray(jsonArray: JSONArray): WritableArray {
   return array
 }
 
+internal fun parseOtplessRequest(data: ReadableMap): OtplessRequest {
+  val otplessRequest = OtplessRequest()
+  data.getString("phone")?.takeIf { it.isNotBlank() }?.let { phone ->
+    val countryCode = data.getString("countryCode") ?: ""
+    otplessRequest.setPhoneNumber(number = phone, countryCode = countryCode)
+  }
+  data.getString("email")?.takeIf { it.isNotBlank() }?.let { otplessRequest.setEmail(it) }
+  data.getString("channelType")?.takeIf { it.isNotBlank() }?.let {
+    otplessRequest.setChannelType(OtplessChannelType.fromString(it))
+  }
+  data.getString("otp")?.takeIf { it.isNotBlank() }?.let { otplessRequest.setOtp(it) }
+  data.getString("requestId")?.takeIf { it.isNotBlank() }?.let { otplessRequest.requestId = it }
+  data.getString("expiry")?.takeIf { it.isNotBlank() }?.let { otplessRequest.setExpiry(it) }
+  data.getString("otpLength")?.takeIf { it.isNotBlank() }?.let { otplessRequest.setOtpLength(it) }
+  data.getString("deliveryChannel")?.takeIf { it.isNotBlank() }?.let {
+    otplessRequest.setDeliveryChannel(it.uppercase())
+  }
+  data.getString("tid")?.takeIf { it.isNotBlank() }?.let { otplessRequest.setTemplateId(it) }
+  data.getString("deviceFingerprintMode")?.takeIf { it.isNotBlank() }?.let { mode ->
+    runCatching { DeviceFingerprintMode.valueOf(mode.uppercase()) }.getOrNull()?.let {
+      otplessRequest.deviceFingerprintMode = it
+    }
+  }
+  return otplessRequest
+}
+
+internal fun parseOtplessAuthConfig(config: ReadableMap): OtplessAuthConfig {
+  val isForeground = if (config.hasKey("isForeground")) config.getBoolean("isForeground") else false
+  val otp = config.getString("otp") ?: ""
+  val tid = config.getString("tid")
+  val fingerprintMode = config.getString("deviceFingerprintMode")
+    ?.takeIf { it.isNotBlank() }
+    ?.let { runCatching { DeviceFingerprintMode.valueOf(it.uppercase()) }.getOrNull() }
+    ?: DeviceFingerprintMode.NONE
+  return OtplessAuthConfig(
+    isForeground = isForeground,
+    otp = otp,
+    tid = tid,
+    deviceFingerprintMode = fingerprintMode
+  )
+}
+
+internal fun parseOtplessResponse(data: ReadableMap?): OtplessResponse? {
+  val dataMap = data?.toHashMap() ?: return null
+  val jsonResponse = JSONObject(dataMap as Map<*, *>)
+  val responseTypeString = jsonResponse.optString("responseType", "")
+  val responseType = runCatching { ResponseTypes.valueOf(responseTypeString) }.getOrElse {
+    debugLog("commitResponse: unknown ResponseType '$responseTypeString', ignoring call")
+    return null
+  }
+  return OtplessResponse(
+    responseType = responseType,
+    jsonResponse.optJSONObject("response"),
+    jsonResponse.optInt("statusCode", 0),
+  )
+}
+
+internal fun parseAuthEvent(event: String): AuthEvent? =
+  runCatching { AuthEvent.valueOf(event) }.getOrNull()
+
+internal fun parseProviderType(providerType: String): ProviderType? =
+  runCatching { ProviderType.valueOf(providerType) }.getOrNull()
+
+// Defensive providerInfo parsing — JS passes `any`, so coerce each value to String:
+// primitives via toString(), Maps/Arrays via JSON serialisation, Null skipped.
+internal fun parseProviderInfo(providerInfo: ReadableMap?): Map<String, String> {
+  val infoMap = mutableMapOf<String, String>()
+  if (providerInfo == null) return infoMap
+  try {
+    val iterator = providerInfo.keySetIterator()
+    while (iterator.hasNextKey()) {
+      val key = iterator.nextKey() ?: continue
+      val value: String? = when (providerInfo.getType(key)) {
+        ReadableType.String -> providerInfo.getString(key)
+        ReadableType.Number -> providerInfo.getDouble(key).toString()
+        ReadableType.Boolean -> providerInfo.getBoolean(key).toString()
+        ReadableType.Map -> convertMapToJson(providerInfo.getMap(key))?.toString()
+        ReadableType.Array -> convertArrayToJson(providerInfo.getArray(key))?.toString()
+        else -> null
+      }
+      if (value != null) infoMap[key] = value
+    }
+  } catch (_: Exception) {
+    // swallow any unexpected bridge parsing errors
+  }
+  return infoMap
+}
+
 internal fun parseTrueCallerRequest(requestMap: ReadableMap): OtplessTruecallerRequest {
   val trueCallerRequestMap = requestMap.getMap("trueCallerRequest") ?: return OtplessTruecallerRequest()
   // parsing footer type

package/ios/OtplessHeadlessRN.m

@@ -5,6 +5,8 @@
 
 RCT_EXTERN_METHOD(initialize:(NSString *)appId
                   loginUri: (nullable NSString *) loginUri
+                  sslPinning: (nullable NSString *) sslPinning
+                  buildPlatform: (nullable NSString *) buildPlatform
                   )
 
 RCT_EXTERN_METHOD(start:(NSDictionary *)request)
@@ -15,15 +17,22 @@ RCT_EXTERN_METHOD(cleanup)
 
 RCT_EXTERN_METHOD(decimateAll)
 
-RCT_EXTERN_METHOD(setOneTapDataCallback)
-
-RCT_EXTERN_METHOD(performOneTap: (NSDictionary *)request)
-
 RCT_EXTERN_METHOD(authorizeViaPasskey: (NSDictionary *)request)
 
 RCT_EXTERN_METHOD(setDevLogging:(BOOL)enable)
 
+RCT_EXTERN_METHOD(userAuthEvent:(NSString *)event
+                  fallback:(BOOL)fallback
+                  providerType:(NSString *)providerType
+                  providerInfo:(nullable NSDictionary *)providerInfo)
+
 RCT_EXTERN_METHOD(isSdkReady: (RCTPromiseResolveBlock*)resolve reject: (RCTPromiseRejectBlock*)reject)
 
+RCT_EXTERN_METHOD(setMfaEnabled:(BOOL)enabled)
+
+RCT_EXTERN_METHOD(startBackgroundAuth:(NSDictionary *)config
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
 @end