@reclaimprotocol/inapp-rn-sdk 0.1.3

package/android/gradle.properties

@@ -0,0 +1,5 @@
+InappRnSdk_kotlinVersion=2.0.21
+InappRnSdk_minSdkVersion=24
+InappRnSdk_targetSdkVersion=34
+InappRnSdk_compileSdkVersion=35
+InappRnSdk_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.reclaimprotocol.inapp_rn_sdk">
+</manifest>

package/android/src/main/AndroidManifestNew.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/reclaimprotocol/inapp_rn_sdk/InappRnSdkModule.kt

@@ -0,0 +1,327 @@
+package com.reclaimprotocol.inapp_rn_sdk
+
+import java.util.UUID
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.module.annotations.ReactModule
+import org.reclaimprotocol.inapp_sdk.ReclaimOverrides
+import org.reclaimprotocol.inapp_sdk.ReclaimSessionStatus
+import org.reclaimprotocol.inapp_sdk.ReclaimVerification
+
+@ReactModule(name = InappRnSdkModule.NAME)
+class InappRnSdkModule(private val reactContext: ReactApplicationContext) :
+  NativeInappRnSdkSpec(reactContext) {
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  companion object {
+    const val NAME = "InappRnSdk"
+  }
+
+  class ReclaimVerificationResultHandlerImpl(val promise: Promise?) :
+    ReclaimVerification.ResultHandler {
+    override fun onException(exception: ReclaimVerification.ReclaimVerificationException) {
+      Log.e(NAME, "reclaim exception", exception)
+      val userInfoMap = Arguments.createMap()
+      val errorType = when (exception) {
+        is ReclaimVerification.ReclaimVerificationException.Cancelled -> "cancelled"
+        is ReclaimVerification.ReclaimVerificationException.Dismissed -> "dismissed"
+        is ReclaimVerification.ReclaimVerificationException.Failed -> "failed"
+        is ReclaimVerification.ReclaimVerificationException.SessionExpired -> "sessionExpired"
+      }
+      userInfoMap.putString("errorType", errorType)
+      userInfoMap.putString("sessionId", exception.sessionId)
+      userInfoMap.putBoolean("didSubmitManualVerification", exception.didSubmitManualVerification)
+      userInfoMap.putString("reason", if (exception is ReclaimVerification.ReclaimVerificationException.Failed) exception.reason else null)
+      promise?.reject("VERIFICATION_ERROR", "Verification Error", exception, userInfoMap)
+    }
+
+    override fun onResponse(response: ReclaimVerification.Response) {
+      Log.d(NAME, "reclaim response")
+      val returnResponse: WritableMap = Arguments.createMap()
+      returnResponse.putString("sessionId", response.sessionId)
+      returnResponse.putBoolean("didSubmitManualVerification", response.didSubmitManualVerification)
+      val returnProofs: WritableArray = Arguments.createArray()
+      for (proof in response.proofs) {
+        val returnProof = Arguments.makeNativeMap(proof)
+        returnProofs.pushMap(returnProof)
+      }
+      returnResponse.putArray("proofs", returnProofs)
+      promise?.resolve(returnResponse)
+    }
+  }
+
+  override fun startVerification(request: ReadableMap?, promise: Promise?) {
+    Log.d(NAME, "startVerification")
+    if (request == null) {
+      Log.d(NAME, "no request. rejecting.")
+
+      promise?.reject(IllegalArgumentException("Request is null"))
+      return
+    }
+    val handler = ReclaimVerificationResultHandlerImpl(promise)
+    reactContext.runOnUiQueueThread {
+      val appId =getString(request,"appId")
+      val secret = getString(request,"secret")
+      val verificationRequest: ReclaimVerification.Request
+      val session = request.getMap("session")
+      val parametersRN = request.getMap("parameters")?.toHashMap()
+      val parameters =  mutableMapOf<String, String>()
+      if (parametersRN != null) {
+        for (key in parametersRN.keys) {
+          val value = parametersRN[key]
+          if (value is String) {
+            parameters[key] = value
+          }
+        }
+      }
+      val hideLanding = getBoolean(request, "hideLanding")
+      val autoSubmit = getBoolean(request, "autoSubmit")
+      val acceptAiProviders = getBoolean(request, "acceptAiProviders")
+      val webhookUrl = getString(request, "webhookUrl")
+      if (appId.isNullOrBlank() && secret.isNullOrBlank()) {
+        verificationRequest = ReclaimVerification.Request.fromManifestMetaData(
+          context = reactContext.applicationContext,
+          providerId = getString(request, "providerId")!!,
+          contextString = getString(request, "contextString") ?: "",
+          session = if (session == null) null else ReclaimVerification.ReclaimSessionInformation(
+            timestamp = getString(session, "timestamp") ?: "",
+            sessionId = getString(session, "sessionId") ?: "",
+            signature = getString(session, "signature") ?: "",
+          ),
+          parameters = parameters,
+          hideLanding = hideLanding ?: true,
+          autoSubmit = autoSubmit ?: false,
+          acceptAiProviders = acceptAiProviders ?: false,
+          webhookUrl = webhookUrl,
+        )
+      } else {
+        verificationRequest = ReclaimVerification.Request(
+          appId = appId!!,
+          secret = secret!!,
+          providerId = getString(request, "providerId")!!,
+          contextString = getString(request, "contextString") ?: "",
+          session = if (session == null) null else ReclaimVerification.ReclaimSessionInformation(
+            timestamp = getString(session, "timestamp") ?: "",
+            sessionId = getString(session, "sessionId") ?: "",
+            signature = getString(session, "signature") ?: "",
+          ),
+          parameters = parameters,
+          hideLanding = hideLanding ?: true,
+          autoSubmit = autoSubmit ?: false,
+          acceptAiProviders = acceptAiProviders ?: false,
+          webhookUrl = webhookUrl,
+        )
+      }
+      ReclaimVerification.startVerification(
+        context = reactContext.applicationContext,
+        request = verificationRequest,
+        handler = handler
+      )
+    }
+  }
+
+  override fun startVerificationFromUrl(requestUrl: String?, promise: Promise?) {
+    Log.d(NAME, "startVerificationFromUrl")
+    if (requestUrl == null) {
+      Log.d(NAME, "no request url. rejecting.")
+
+      promise?.reject(IllegalArgumentException("Request url is null"))
+      return
+    }
+    val handler = ReclaimVerificationResultHandlerImpl(promise)
+    reactContext.runOnUiQueueThread {
+      ReclaimVerification.startVerificationFromUrl(
+        context = reactContext.applicationContext, requestUrl = requestUrl, handler = handler
+      )
+    }
+  }
+
+  override fun setOverrides(overrides: ReadableMap?, promise: Promise?) {
+    return setOverrides(
+      provider = getMap(overrides, "provider"),
+      featureOptions = getMap(overrides, "featureOptions"),
+      logConsumer = getMap(overrides, "logConsumer"),
+      sessionManagement = getMap(overrides, "sessionManagement"),
+      appInfo = getMap(overrides, "appInfo"),
+      promise,
+    )
+  }
+
+  private val replyHandlers: MutableMap<String, (Result<Boolean>) -> Unit> = mutableMapOf()
+
+  private fun setOverrides(
+    provider: ReadableMap?,
+    featureOptions: ReadableMap?,
+    logConsumer: ReadableMap?,
+    sessionManagement: ReadableMap?,
+    appInfo: ReadableMap?,
+    promise: Promise?
+  ) {
+    reactContext.runOnUiQueueThread {
+      ReclaimVerification.setOverrides(
+        context = reactContext.applicationContext,
+        provider = if (provider == null) null else (if (provider.isNull("url")) ReclaimOverrides.ProviderInformation.FromJsonString(
+          requireString(
+            provider, "jsonString"
+          )
+        )
+        else ReclaimOverrides.ProviderInformation.FromUrl(requireString(provider, "url"))),
+        featureOptions = if (featureOptions == null) null else ReclaimOverrides.FeatureOptions(
+          cookiePersist = getBoolean(featureOptions, "cookiePersist"),
+          singleReclaimRequest = getBoolean(featureOptions, "singleReclaimRequest"),
+          idleTimeThresholdForManualVerificationTrigger = getLong(
+            featureOptions, "idleTimeThresholdForManualVerificationTrigger"
+          ),
+          sessionTimeoutForManualVerificationTrigger = getLong(
+            featureOptions, "sessionTimeoutForManualVerificationTrigger"
+          ),
+          attestorBrowserRpcUrl = getString(featureOptions, "attestorBrowserRpcUrl"),
+          isResponseRedactionRegexEscapingEnabled = getBoolean(
+            featureOptions, "isResponseRedactionRegexEscapingEnabled"
+          ),
+          isAIFlowEnabled = getBoolean(featureOptions, "isAIFlowEnabled")
+        ),
+        logConsumer = if (logConsumer == null) null else ReclaimOverrides.LogConsumer(
+          logHandler = if (getBoolean(logConsumer, "enableLogHandler") != true) null else object :
+            ReclaimOverrides.LogConsumer.LogHandler {
+            override fun onLogs(logJsonString: String) {
+              emitOnLogs(logJsonString)
+            }
+          },
+          canSdkCollectTelemetry = getBoolean(logConsumer, "canSdkCollectTelemetry") ?: true,
+          canSdkPrintLogs = getBoolean(logConsumer, "canSdkPrintLogs")
+        ),
+        sessionManagement = if (sessionManagement == null || getBoolean(
+            sessionManagement, "enableSdkSessionManagement"
+          ) != false
+        ) null else ReclaimOverrides.SessionManagement(handler = object :
+          ReclaimOverrides.SessionManagement.SessionHandler {
+          override fun createSession(
+            appId: String,
+            providerId: String,
+            sessionId: String,
+            callback: (Result<Boolean>) -> Unit
+          ) {
+            val args = Arguments.createMap()
+            args.putString("appId", appId)
+            args.putString("providerId", providerId)
+            args.putString("sessionId", sessionId)
+            val replyId = UUID.randomUUID().toString()
+            args.putString("replyId", replyId)
+            replyHandlers[replyId] = callback
+            emitOnSessionCreateRequest(args)
+          }
+
+          override fun logSession(
+            appId: String, providerId: String, sessionId: String, logType: String
+          ) {
+            val args = Arguments.createMap()
+            args.putString("appId", appId)
+            args.putString("providerId", providerId)
+            args.putString("sessionId", sessionId)
+            args.putString("logType", logType)
+            emitOnSessionLogs(args)
+          }
+
+          override fun updateSession(
+            sessionId: String, status: ReclaimSessionStatus, callback: (Result<Boolean>) -> Unit
+          ) {
+            status.name
+            val args = Arguments.createMap()
+            args.putString("sessionId", sessionId)
+            args.putString("status", status.name)
+            val replyId = UUID.randomUUID().toString()
+            args.putString("replyId", replyId)
+            replyHandlers[replyId] = callback
+            emitOnSessionUpdateRequest(args)
+          }
+        }),
+        appInfo = if (appInfo == null) null else ReclaimOverrides.ReclaimAppInfo(
+          appName = requireString(appInfo, "appName"),
+          appImageUrl = requireString(appInfo, "appImageUrl"),
+          isRecurring = getBoolean(appInfo, "isRecurring") ?: false,
+        ),
+      ) { result ->
+        result.onSuccess {
+            promise?.resolve(true)
+          }.onFailure { error ->
+            promise?.reject(error)
+          }
+      }
+    }
+  }
+
+  override fun reply(replyId: String?, reply: Boolean) {
+    if (replyId == null) {
+      Log.w(NAME, "Missing arg replyId")
+      return
+    }
+    reactContext.runOnUiQueueThread {
+      val callback = replyHandlers[replyId]
+      if (callback != null) {
+        callback(Result.success(reply))
+      } else {
+        Log.w(NAME, "Missing reply handler for id: $replyId")
+      }
+    }
+  }
+
+  private fun requireString(map: ReadableMap, key: String): String {
+    val value = getString(map, key)
+    if (value == null) {
+      Log.w(NAME, "Missing value for key: $key")
+      return ""
+    }
+    return value
+  }
+
+  private fun getMap(map: ReadableMap?, key: String): ReadableMap? {
+    return if (map == null || !map.hasKey(key) || map.isNull(key)) {
+      null
+    } else {
+      map.getMap(key)
+    }
+  }
+
+  private fun getLong(map: ReadableMap, key: String): Long? {
+    return if (!map.hasKey(key) || map.isNull(key)) {
+      null
+    } else {
+      map.getLong(key)
+    }
+  }
+
+  private fun getString(map: ReadableMap, key: String): String? {
+    return if (!map.hasKey(key) || map.isNull(key)) {
+      null
+    } else {
+      map.getString(key)
+    }
+  }
+
+  private fun getBoolean(map: ReadableMap, key: String): Boolean? {
+    return if (!map.hasKey(key) || map.isNull(key)) {
+      null
+    } else {
+      map.getBoolean(key)
+    }
+  }
+
+  override fun ping(promise: Promise?) {
+    Log.d(NAME, "startVerification")
+    fun submitPing() {
+      promise?.resolve(true)
+    }
+    reactContext.runOnUiQueueThread {
+      submitPing()
+    }
+  }
+}

package/android/src/main/java/com/reclaimprotocol/inapp_rn_sdk/InappRnSdkPackage.kt

@@ -0,0 +1,33 @@
+package com.reclaimprotocol.inapp_rn_sdk
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class InappRnSdkPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == InappRnSdkModule.NAME) {
+      InappRnSdkModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos[InappRnSdkModule.NAME] = ReactModuleInfo(
+        InappRnSdkModule.NAME,
+        InappRnSdkModule.NAME,
+        false,  // canOverrideExistingModule
+        false,  // needsEagerInit
+        false,  // isCxxModule
+        true // isTurboModule
+      )
+      moduleInfos
+    }
+  }
+}

package/ios/InappRnSdk-Bridging-Header.h

@@ -0,0 +1 @@
+

package/ios/InappRnSdk.h

@@ -0,0 +1,17 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "generated/RNInappRnSdkSpec/RNInappRnSdkSpec.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface InappRnSdk : NativeInappRnSdkSpecBase <NativeInappRnSdkSpec>
+
+NS_ASSUME_NONNULL_END
+
+#else
+#import <React/RCTBridgeModule.h>
+
+@interface InappRnSdk : NSObject <RCTBridgeModule>
+#endif
+
+
+@end

package/ios/InappRnSdk.mm

@@ -0,0 +1,215 @@
+#import "InappRnSdk.h"
+
+/*
+ This condition is needed to support use_frameworks.
+ https://github.com/callstack/react-native-builder-bob/discussions/412#discussioncomment-6352402
+ */
+#if __has_include("InappRnSdk-Swift.h")
+#import "InappRnSdk-Swift.h"
+#else
+#import "InappRnSdk/InappRnSdk-Swift.h"
+#endif
+
+@implementation InappRnSdk
+RCT_EXPORT_MODULE()
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+(const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeInappRnSdkSpecJSI>(params);
+}
+
+Api *api = [[Api alloc] init];
+
+- (void)ping:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+  
+  BOOL pingResult = [api ping];
+  if (pingResult) {
+    resolve(@true);
+  } else {
+    resolve(@false);
+  }
+}
+
+- (void)reply:(nonnull NSString *)replyId reply:(BOOL)reply {
+  [api replyWithReplyId:replyId reply:reply];
+}
+
+- (void)startVerification:(JS::NativeInappRnSdk::Request &)request resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+  NSLog(@"[InappRnSdk] starting verification");
+  
+  bool hideLanding = true;
+  if (request.hideLanding().has_value()) {
+    hideLanding = request.hideLanding().value();
+  }
+  bool autoSubmit = false;
+  if (request.autoSubmit().has_value()) {
+    autoSubmit = request.autoSubmit().value();
+  }
+  bool acceptAiProviders = false;
+  if (request.acceptAiProviders().has_value()) {
+    acceptAiProviders = request.acceptAiProviders().value();
+  }
+  
+  NSString *sessionId = nil;
+  NSString *timestamp = nil;
+  NSString *signature = nil;
+  if (request.session().has_value()) {
+    sessionId = request.session().value().sessionId();
+    timestamp = request.session().value().timestamp();
+    signature = request.session().value().signature();
+  }
+  
+  NSDictionary<NSString *, NSString *> *parameters = @{};
+  if (request.parameters() != nil) {
+    id potentialParameters = request.parameters();
+    if ([potentialParameters isKindOfClass:[NSDictionary class]]) {
+      // just verifying because cannot trust JS
+      NSDictionary *tempDictionary = (NSDictionary *)potentialParameters;
+      BOOL allStrings = YES;
+      for (id key in tempDictionary) {
+        if (![key isKindOfClass:[NSString class]] || ![tempDictionary[key] isKindOfClass:[NSString class]]) {
+          allStrings = NO;
+          break;
+        }
+      }
+      if (allStrings){
+        // should always be the case
+        parameters = (NSDictionary<NSString *, NSString *> *)potentialParameters;
+      } else {
+        NSLog(@"[InappRnSdk] request.parameters() contains non string key or value");
+      }
+    } else {
+      NSLog(@"[InappRnSdk] request.parameters() is not a dictionary.");
+    }
+  }
+  
+  NSLog(@"[InappRnSdk] starting verification now");
+  [api startVerificationWithAppId:request.appId() secret:request.secret() providerId:request.providerId() sessionTimestamp:timestamp sessionSessionId:sessionId sessionSignature:signature context:request.contextString() parameters:parameters hideLanding:hideLanding autoSubmit:autoSubmit acceptAiProviders:acceptAiProviders webhookUrl:request.webhookUrl() completionHandler:^(NSDictionary<NSString *,id> * _Nullable result, NSError * _Nullable error) {
+    if (error != nil) {
+      NSLog(@"[InappRnSdk] Api Error: %@", error);
+      reject(@"VERIFICATION_ERROR", @"Verification Error", error);
+    } else {
+      resolve(result);
+    }
+  }];
+}
+
+- (void)startVerificationFromUrl:(nonnull NSString *)requestUrl resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+  NSLog(@"[InappRnSdk] starting verification");
+  
+  NSLog(@"[InappRnSdk] starting verification now");
+  [api startVerificationFromUrlWithUrl:requestUrl completionHandler:^(NSDictionary<NSString *,id> * _Nullable result, NSError * _Nullable error) {
+    if (error != nil) {
+      NSLog(@"[InappRnSdk] Api Error: %@", error);
+      reject(@"VERIFICATION_ERROR", @"Verification Error", error);
+    } else {
+      resolve(result);
+    }
+  }];
+}
+
+- (void)setOverrides:(JS::NativeInappRnSdk::Overrides &)overrides resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+  
+  OverridenProviderInformation * _Nullable overridenProvider = nil;
+  if (overrides.provider().has_value()) {
+    JS::NativeInappRnSdk::ProviderInformation provider = overrides.provider().value();
+    if (provider.url() != nil && provider.url().length > 0) {
+      overridenProvider = [[OverridenProviderInformation alloc] initWithUrl:provider.url() jsonString:nil];
+    } else if (provider.jsonString() != nil && provider.jsonString().length > 0) {
+      overridenProvider = [[OverridenProviderInformation alloc] initWithUrl:nil jsonString:provider.jsonString()];
+    }
+  }
+  
+  OverridenFeatureOptions * _Nullable overridenFeatureOptions = nil;
+  if (overrides.featureOptions().has_value()) {
+    JS::NativeInappRnSdk::FeatureOptions featureOptions = overrides.featureOptions().value();
+    overridenFeatureOptions = [[OverridenFeatureOptions alloc] initWithCookiePersist:nil singleReclaimRequest:nil idleTimeThresholdForManualVerificationTrigger:nil sessionTimeoutForManualVerificationTrigger:nil attestorBrowserRpcUrl:nil isResponseRedactionRegexEscapingEnabled:nil isAIFlowEnabled:nil];
+    
+    if (featureOptions.cookiePersist().has_value()) {
+      overridenFeatureOptions.cookiePersist = [NSNumber numberWithBool:featureOptions.cookiePersist().value()];
+    }
+    if (featureOptions.singleReclaimRequest().has_value()) {
+      overridenFeatureOptions.singleReclaimRequest = [NSNumber numberWithBool:featureOptions.singleReclaimRequest().value()];
+    }
+    if (featureOptions.idleTimeThresholdForManualVerificationTrigger().has_value()) {
+      overridenFeatureOptions.idleTimeThresholdForManualVerificationTrigger = [NSNumber numberWithDouble:featureOptions.idleTimeThresholdForManualVerificationTrigger().value()];
+    }
+    if (featureOptions.sessionTimeoutForManualVerificationTrigger().has_value()) {
+      overridenFeatureOptions.sessionTimeoutForManualVerificationTrigger = [NSNumber numberWithDouble:featureOptions.sessionTimeoutForManualVerificationTrigger().value()];
+    }
+    if (featureOptions.attestorBrowserRpcUrl() != nil && featureOptions.attestorBrowserRpcUrl().length > 0) {
+      overridenFeatureOptions.attestorBrowserRpcUrl = featureOptions.attestorBrowserRpcUrl();
+    }
+    if (featureOptions.isResponseRedactionRegexEscapingEnabled().has_value()) {
+      overridenFeatureOptions.isResponseRedactionRegexEscapingEnabled = [NSNumber numberWithBool:featureOptions.isResponseRedactionRegexEscapingEnabled().value()];
+    }
+    if (featureOptions.isAIFlowEnabled().has_value()) {
+      overridenFeatureOptions.isAIFlowEnabled = [NSNumber numberWithBool:featureOptions.isAIFlowEnabled().value()];
+    }
+  }
+  
+  OverridenLogConsumer * _Nullable overridenLogConsumer = nil;
+  if (overrides.logConsumer().has_value()) {
+    BOOL canSDKCollectTelemetry = true;
+    if (overrides.logConsumer().value().canSdkCollectTelemetry().has_value()) {
+      canSDKCollectTelemetry =overrides.logConsumer().value().canSdkCollectTelemetry().value();
+    }
+    NSNumber  * _Nullable canSdkPrintLogs = nil;
+    if (overrides.logConsumer().value().canSdkPrintLogs().has_value()) {
+      canSdkPrintLogs = [NSNumber numberWithBool:overrides.logConsumer().value().canSdkPrintLogs().value()];
+    }
+    OverridenLogHandler * _Nullable logHandler;
+    if (overrides.logConsumer().value().enableLogHandler()) {
+      logHandler = [[OverridenLogHandler alloc] initOnLogs:^(NSString * _Nonnull logJsonString) {
+        [self emitOnLogs:logJsonString];
+      }];
+    }
+    overridenLogConsumer = [[OverridenLogConsumer alloc] initWithLogHandler: logHandler canSdkCollectTelemetry: canSDKCollectTelemetry canSdkPrintLogs: canSdkPrintLogs];
+  }
+
+  OverridenSessionManagement * _Nullable sessionManagement;
+  if (overrides.sessionManagement().has_value()) {
+    sessionManagement = [[OverridenSessionManagement alloc] initWithHandler:[[OverridenSessionHandler alloc] initWith_createSession:^(NSString * _Nonnull appId, NSString * _Nonnull providerId, NSString * _Nonnull sessionId, NSString * _Nonnull replyId) {
+      [self emitOnSessionCreateRequest:@{
+        @"appId": appId,
+        @"providerId": providerId,
+        @"sessionId": sessionId,
+        @"replyId": replyId
+      }];
+    } _updateSession:^(NSString * _Nonnull sessionId, NSString * _Nonnull status, NSString * _Nonnull replyId) {
+      [self emitOnSessionUpdateRequest:@{
+        @"sessionId": sessionId,
+        @"status": status,
+        @"replyId": replyId
+      }];
+    } _logSession:^(NSString * _Nonnull appId, NSString * _Nonnull providerId, NSString * _Nonnull sessionId, NSString * _Nonnull replyId) {
+      [self emitOnSessionLogs:@{
+        @"appId": appId,
+        @"providerId": providerId,
+        @"sessionId": sessionId,
+        @"replyId": replyId
+      }];
+    }]];
+  }
+  
+  OverridenReclaimAppInfo * _Nullable overridenAppInfo = nil;
+  if (overrides.appInfo().has_value()) {
+    JS::NativeInappRnSdk::ReclaimAppInfo appInfo = overrides.appInfo().value();
+    NSNumber  * _Nullable isRecurring = nil;
+    if (appInfo.isRecurring().has_value()) {
+      isRecurring = [NSNumber numberWithBool:appInfo.isRecurring().value()];
+    }
+    overridenAppInfo = [[OverridenReclaimAppInfo alloc] initWithAppName:appInfo.appName() appImageUrl:appInfo.appImageUrl() isRecurring:isRecurring];
+  }
+  
+  [api setOverridesWithProvider:overridenProvider featureOptions:overridenFeatureOptions logConsumer:overridenLogConsumer sessionManagement: sessionManagement appInfo:overridenAppInfo completionHandler:^(NSError * _Nullable error) {
+    if (error != nil) {
+      reject(@"OVERRIDE_ERROR", @"Error on override", error);
+    } else {
+      resolve(nil);
+    }
+  }];
+}
+
+@end