@stripe/stripe-react-native 0.61.0 → 0.63.0

package/android/gradle.properties

@@ -1,6 +1,6 @@
-StripeSdk_kotlinVersion=2.3.10
+StripeSdk_kotlinVersion=2.2.21
 StripeSdk_compileSdkVersion=30
 StripeSdk_targetSdkVersion=28
 StripeSdk_minSdkVersion=21
 # Keep StripeSdk_stripeVersion in sync with https://github.com/stripe/stripe-identity-react-native/blob/main/android/gradle.properties
-StripeSdk_stripeVersion=23.1.+
+StripeSdk_stripeVersion=23.3.+

package/android/src/main/java/com/reactnativestripesdk/EventEmitterCompat.kt

@@ -99,4 +99,8 @@ class EventEmitterCompat(
   fun emitPaymentMethodMessagingElementConfigureResult(value: ReadableMap?) {
     invoke("paymentMethodMessagingElementConfigureResult", value)
   }
+
+  fun emitOnCheckoutClientSecretRequested(value: ReadableMap?) {
+    invoke("onCheckoutClientSecretRequested", value)
+  }
 }

package/android/src/main/java/com/reactnativestripesdk/FakeOnrampSdkModule.kt

@@ -137,6 +137,12 @@ class FakeOnrampSdkModule(
     promise.resolveNotImplemented()
   }
 
+  @ReactMethod
+  override fun addListener(eventType: String?) {}
+
+  @ReactMethod
+  override fun removeListeners(count: Double) {}
+
   private fun Promise.resolveNotImplemented() {
     this.resolve(
       createFailedError(

package/android/src/main/java/com/reactnativestripesdk/PaymentSheetManager.kt

@@ -86,209 +86,15 @@ class PaymentSheetManager(
   internal var paymentSheetIntentCreationCallback = CompletableDeferred<ReadableMap>()
   internal var paymentSheetConfirmationTokenCreationCallback = CompletableDeferred<ReadableMap>()
   private var keepJsAwake: KeepJsAwakeTask? = null
+  private var lastConfigureWasCustomFlow: Boolean? = null
 
   @SuppressLint("RestrictedApi")
   override fun onCreate() {
-    val activity = getCurrentActivityOrResolveWithError(initPromise) ?: return
-    val merchantDisplayName = arguments.getString("merchantDisplayName").orEmpty()
-    if (merchantDisplayName.isEmpty()) {
-      initPromise.resolve(
-        createError(ErrorType.Failed.toString(), "merchantDisplayName cannot be empty or null."),
-      )
-      return
-    }
-    paymentIntentClientSecret = arguments.getString("paymentIntentClientSecret").orEmpty()
-    setupIntentClientSecret = arguments.getString("setupIntentClientSecret").orEmpty()
-    intentConfiguration =
-      try {
-        buildIntentConfiguration(arguments.getMap("intentConfiguration"))
-      } catch (error: PaymentSheetException) {
-        initPromise.resolve(createError(ErrorType.Failed.toString(), error))
-        return
-      }
-
-    // Determine which callback type to use based on what's provided
-    val intentConfigMap = arguments.getMap("intentConfiguration")
-    val useConfirmationTokenCallback = intentConfigMap?.hasKey("confirmationTokenConfirmHandler") == true
-
-    val paymentOptionCallback =
-      PaymentOptionResultCallback { paymentOptionResult ->
-        paymentOptionResult.paymentOption?.let { paymentOption ->
-          // Convert drawable to bitmap asynchronously to avoid shared state issues
-          CoroutineScope(Dispatchers.Default).launch {
-            val imageString =
-              try {
-                convertDrawableToBase64(paymentOption.icon())
-              } catch (e: Exception) {
-                val result =
-                  createError(
-                    PaymentSheetErrorType.Failed.toString(),
-                    "Failed to process payment option image: ${e.message}",
-                  )
-                resolvePresentPromise(result)
-                return@launch
-              }
-
-            val option: WritableMap = Arguments.createMap()
-            option.putString("label", paymentOption.label)
-            option.putString("image", imageString)
-            val additionalFields: Map<String, Any> = mapOf("didCancel" to paymentOptionResult.didCancel)
-            val result = createResult("paymentOption", option, additionalFields)
-            resolvePresentPromise(result)
-          }
-        } ?: run {
-          val result =
-            if (paymentSheetTimedOut) {
-              paymentSheetTimedOut = false
-              createError(PaymentSheetErrorType.Timeout.toString(), "The payment has timed out")
-            } else {
-              createError(
-                PaymentSheetErrorType.Canceled.toString(),
-                "The payment option selection flow has been canceled",
-              )
-            }
-          resolvePresentPromise(result)
-        }
-      }
-
-    val paymentResultCallback =
-      PaymentSheetResultCallback { paymentResult ->
-        if (paymentSheetTimedOut) {
-          paymentSheetTimedOut = false
-          resolvePaymentResult(
-            createError(PaymentSheetErrorType.Timeout.toString(), "The payment has timed out"),
-          )
-        } else {
-          when (paymentResult) {
-            is PaymentSheetResult.Canceled -> {
-              resolvePaymentResult(
-                createError(
-                  PaymentSheetErrorType.Canceled.toString(),
-                  "The payment flow has been canceled",
-                ),
-              )
-            }
-
-            is PaymentSheetResult.Failed -> {
-              resolvePaymentResult(
-                createError(PaymentSheetErrorType.Failed.toString(), paymentResult.error),
-              )
-            }
-
-            is PaymentSheetResult.Completed -> {
-              resolvePaymentResult(Arguments.createMap())
-            }
-          }
-        }
-      }
-
-    val createIntentCallback =
-      CreateIntentCallback { paymentMethod, shouldSavePaymentMethod ->
-        val stripeSdkModule: StripeSdkModule? = context.getNativeModule(StripeSdkModule::class.java)
-        val params =
-          Arguments.createMap().apply {
-            putMap("paymentMethod", mapFromPaymentMethod(paymentMethod))
-            putBoolean("shouldSavePaymentMethod", shouldSavePaymentMethod)
-          }
-
-        stripeSdkModule?.eventEmitter?.emitOnConfirmHandlerCallback(params)
-
-        val resultFromJavascript = paymentSheetIntentCreationCallback.await()
-        // reset the completable
-        paymentSheetIntentCreationCallback = CompletableDeferred<ReadableMap>()
-
-        return@CreateIntentCallback resultFromJavascript.getString("clientSecret")?.let {
-          CreateIntentResult.Success(clientSecret = it)
-        }
-          ?: run {
-            val errorMap = resultFromJavascript.getMap("error")
-            CreateIntentResult.Failure(
-              cause = Exception(errorMap?.getString("message")),
-              displayMessage = errorMap?.getString("localizedMessage"),
-            )
-          }
-      }
-
-    val createConfirmationTokenCallback =
-      CreateIntentWithConfirmationTokenCallback { confirmationToken ->
-        val stripeSdkModule: StripeSdkModule? = context.getNativeModule(StripeSdkModule::class.java)
-        val params =
-          Arguments.createMap().apply {
-            putMap("confirmationToken", mapFromConfirmationToken(confirmationToken))
-          }
-
-        stripeSdkModule?.eventEmitter?.emitOnConfirmationTokenHandlerCallback(params)
-
-        val resultFromJavascript = paymentSheetConfirmationTokenCreationCallback.await()
-        // reset the completable
-        paymentSheetConfirmationTokenCreationCallback = CompletableDeferred<ReadableMap>()
-
-        return@CreateIntentWithConfirmationTokenCallback resultFromJavascript.getString("clientSecret")?.let {
-          CreateIntentResult.Success(clientSecret = it)
-        }
-          ?: run {
-            val errorMap = resultFromJavascript.getMap("error")
-            CreateIntentResult.Failure(
-              cause = Exception(errorMap?.getString("message")),
-              displayMessage = errorMap?.getString("localizedMessage"),
-            )
-          }
-      }
-
-    if (arguments.getBooleanOr("customFlow", false)) {
-      if (flowController == null) {
-        flowController =
-          if (intentConfiguration != null) {
-            val builder =
-              PaymentSheet.FlowController
-                .Builder(
-                  resultCallback = paymentResultCallback,
-                  paymentOptionResultCallback = paymentOptionCallback,
-                )
-            if (useConfirmationTokenCallback) {
-              builder.createIntentCallback(createConfirmationTokenCallback)
-            } else {
-              builder.createIntentCallback(createIntentCallback)
-            }
-            builder
-              .confirmCustomPaymentMethodCallback(this)
-              .build(activity)
-          } else {
-            PaymentSheet.FlowController
-              .Builder(
-                resultCallback = paymentResultCallback,
-                paymentOptionResultCallback = paymentOptionCallback,
-              ).confirmCustomPaymentMethodCallback(this)
-              .build(activity)
-          }
-      }
-    } else {
-      if (paymentSheet == null) {
-        paymentSheet =
-          if (intentConfiguration != null) {
-            val builder = PaymentSheet.Builder(paymentResultCallback)
-            if (useConfirmationTokenCallback) {
-              builder.createIntentCallback(createConfirmationTokenCallback)
-            } else {
-              builder.createIntentCallback(createIntentCallback)
-            }
-            @SuppressLint("RestrictedApi")
-            builder
-              .confirmCustomPaymentMethodCallback(this)
-              .build(activity, signal)
-          } else {
-            @SuppressLint("RestrictedApi")
-            PaymentSheet
-              .Builder(paymentResultCallback)
-              .confirmCustomPaymentMethodCallback(this)
-              .build(activity, signal)
-          }
-      }
-    }
     configure(arguments, initPromise)
   }
 
   override fun onDestroy() {
+    super.onDestroy()
     flowController = null
     paymentSheet = null
   }
@@ -380,15 +186,211 @@ class PaymentSheetManager(
 
     paymentSheetConfiguration = configurationBuilder.build()
     if (args.getBooleanOr("customFlow", false)) {
+      lastConfigureWasCustomFlow = true
+      if (flowController == null) {
+        initFlowController(args, promise)
+      }
       configureFlowController(promise)
     } else {
+      lastConfigureWasCustomFlow = false
+      if (paymentSheet == null) {
+        initPaymentSheet(args, promise)
+      }
       promise.resolve(Arguments.createMap())
     }
   }
 
+  private fun initPaymentSheet(
+    args: ReadableMap,
+    promise: Promise,
+  ) {
+    val activity = getCurrentActivityOrResolveWithError(promise) ?: return
+    val intentConfigMap = args.getMap("intentConfiguration")
+    val useConfirmationTokenCallback = intentConfigMap?.hasKey("confirmationTokenConfirmHandler") == true
+    paymentSheet =
+      if (intentConfiguration != null) {
+        val builder = PaymentSheet.Builder(buildPaymentSheetResultCallback())
+        if (useConfirmationTokenCallback) {
+          builder.createIntentCallback(buildCreateConfirmationTokenCallback())
+        } else {
+          builder.createIntentCallback(buildIntentCreationCallback())
+        }
+        @SuppressLint("RestrictedApi")
+        builder
+          .confirmCustomPaymentMethodCallback(this)
+          .build(activity, signal)
+      } else {
+        @SuppressLint("RestrictedApi")
+        PaymentSheet
+          .Builder(buildPaymentSheetResultCallback())
+          .confirmCustomPaymentMethodCallback(this)
+          .build(activity, signal)
+      }
+  }
+
+  private fun initFlowController(
+    args: ReadableMap,
+    promise: Promise,
+  ) {
+    val activity = getCurrentActivityOrResolveWithError(promise) ?: return
+    val intentConfigMap = args.getMap("intentConfiguration")
+    val useConfirmationTokenCallback =
+      intentConfigMap?.hasKey("confirmationTokenConfirmHandler") == true
+    flowController =
+      if (intentConfiguration != null) {
+        val builder =
+          PaymentSheet.FlowController
+            .Builder(
+              resultCallback = buildPaymentSheetResultCallback(),
+              paymentOptionResultCallback = buildPaymentOptionCallback(),
+            )
+        if (useConfirmationTokenCallback) {
+          builder.createIntentCallback(buildCreateConfirmationTokenCallback())
+        } else {
+          builder.createIntentCallback(buildIntentCreationCallback())
+        }
+        builder.confirmCustomPaymentMethodCallback(this)
+        builder.build(activity)
+      } else {
+        PaymentSheet.FlowController
+          .Builder(
+            resultCallback = buildPaymentSheetResultCallback(),
+            paymentOptionResultCallback = buildPaymentOptionCallback(),
+          ).confirmCustomPaymentMethodCallback(this)
+          .build(activity)
+      }
+  }
+
+  private fun buildCreateConfirmationTokenCallback(): CreateIntentWithConfirmationTokenCallback {
+    return CreateIntentWithConfirmationTokenCallback { confirmationToken ->
+      val stripeSdkModule: StripeSdkModule? = context.getNativeModule(StripeSdkModule::class.java)
+      val params =
+        Arguments.createMap().apply {
+          putMap("confirmationToken", mapFromConfirmationToken(confirmationToken))
+        }
+
+      stripeSdkModule?.eventEmitter?.emitOnConfirmationTokenHandlerCallback(params)
+
+      val resultFromJavascript = paymentSheetConfirmationTokenCreationCallback.await()
+      // reset the completable
+      paymentSheetConfirmationTokenCreationCallback = CompletableDeferred<ReadableMap>()
+
+      return@CreateIntentWithConfirmationTokenCallback resultFromJavascript.getString("clientSecret")?.let {
+        CreateIntentResult.Success(clientSecret = it)
+      }
+        ?: run {
+          val errorMap = resultFromJavascript.getMap("error")
+          CreateIntentResult.Failure(
+            cause = Exception(errorMap?.getString("message")),
+            displayMessage = errorMap?.getString("localizedMessage"),
+          )
+        }
+    }
+  }
+
+  private fun buildIntentCreationCallback(): CreateIntentCallback {
+    return CreateIntentCallback { paymentMethod, shouldSavePaymentMethod ->
+      val stripeSdkModule: StripeSdkModule? = context.getNativeModule(StripeSdkModule::class.java)
+      val params =
+        Arguments.createMap().apply {
+          putMap("paymentMethod", mapFromPaymentMethod(paymentMethod))
+          putBoolean("shouldSavePaymentMethod", shouldSavePaymentMethod)
+        }
+
+      stripeSdkModule?.eventEmitter?.emitOnConfirmHandlerCallback(params)
+
+      val resultFromJavascript = paymentSheetIntentCreationCallback.await()
+      // reset the completable
+      paymentSheetIntentCreationCallback = CompletableDeferred<ReadableMap>()
+
+      return@CreateIntentCallback resultFromJavascript.getString("clientSecret")?.let {
+        CreateIntentResult.Success(clientSecret = it)
+      }
+        ?: run {
+          val errorMap = resultFromJavascript.getMap("error")
+          CreateIntentResult.Failure(
+            cause = Exception(errorMap?.getString("message")),
+            displayMessage = errorMap?.getString("localizedMessage"),
+          )
+        }
+    }
+  }
+
+  private fun buildPaymentSheetResultCallback(): PaymentSheetResultCallback =
+    PaymentSheetResultCallback { paymentResult ->
+      if (paymentSheetTimedOut) {
+        paymentSheetTimedOut = false
+        resolvePaymentResult(
+          createError(PaymentSheetErrorType.Timeout.toString(), "The payment has timed out"),
+        )
+      } else {
+        when (paymentResult) {
+          is PaymentSheetResult.Canceled -> {
+            resolvePaymentResult(
+              createError(
+                PaymentSheetErrorType.Canceled.toString(),
+                "The payment flow has been canceled",
+              ),
+            )
+          }
+
+          is PaymentSheetResult.Failed -> {
+            resolvePaymentResult(
+              createError(PaymentSheetErrorType.Failed.toString(), paymentResult.error),
+            )
+          }
+
+          is PaymentSheetResult.Completed -> {
+            resolvePaymentResult(Arguments.createMap())
+          }
+        }
+      }
+    }
+
+  private fun buildPaymentOptionCallback(): PaymentOptionResultCallback {
+    return PaymentOptionResultCallback { paymentOptionResult ->
+      paymentOptionResult.paymentOption?.let { paymentOption ->
+        // Convert drawable to bitmap asynchronously to avoid shared state issues
+        CoroutineScope(Dispatchers.Default).launch {
+          val imageString =
+            try {
+              convertDrawableToBase64(paymentOption.icon())
+            } catch (e: Exception) {
+              val result =
+                createError(
+                  PaymentSheetErrorType.Failed.toString(),
+                  "Failed to process payment option image: ${e.message}",
+                )
+              resolvePresentPromise(result)
+              return@launch
+            }
+
+          val option: WritableMap = Arguments.createMap()
+          option.putString("label", paymentOption.label)
+          option.putString("image", imageString)
+          val additionalFields: Map<String, Any> = mapOf("didCancel" to paymentOptionResult.didCancel)
+          val result = createResult("paymentOption", option, additionalFields)
+          resolvePresentPromise(result)
+        }
+      } ?: run {
+        val result =
+          if (paymentSheetTimedOut) {
+            paymentSheetTimedOut = false
+            createError(PaymentSheetErrorType.Timeout.toString(), "The payment has timed out")
+          } else {
+            createError(
+              PaymentSheetErrorType.Canceled.toString(),
+              "The payment option selection flow has been canceled",
+            )
+          }
+        resolvePresentPromise(result)
+      }
+    }
+  }
+
   override fun onPresent() {
     keepJsAwake = KeepJsAwakeTask(context).apply { start() }
-    if (paymentSheet != null) {
+    if (lastConfigureWasCustomFlow == false) {
       if (!paymentIntentClientSecret.isNullOrEmpty()) {
         paymentSheet?.presentWithPaymentIntent(
           paymentIntentClientSecret!!,
@@ -402,7 +404,7 @@ class PaymentSheetManager(
           configuration = paymentSheetConfiguration,
         )
       }
-    } else if (flowController != null) {
+    } else if (lastConfigureWasCustomFlow == true && flowController != null) {
       flowController?.presentPaymentOptions()
     } else {
       promise?.resolve(createMissingInitError())

package/android/src/main/java/com/reactnativestripesdk/StripeSdkModule.kt

@@ -258,7 +258,9 @@ class StripeSdkModule(
     promise: Promise,
   ) {
     if (paymentSheetManager != null) {
-      paymentSheetManager?.configure(params, promise)
+      UiThreadUtil.runOnUiThread {
+        paymentSheetManager?.configure(params, promise)
+      }
     } else {
       paymentSheetManager =
         PaymentSheetManager(reactApplicationContext, params, promise).also {

package/android/src/main/java/com/reactnativestripesdk/pushprovisioning/AddToWalletButtonView.kt

@@ -2,6 +2,7 @@ package com.reactnativestripesdk.pushprovisioning
 
 import android.annotation.SuppressLint
 import android.content.res.ColorStateList
+import android.graphics.Bitmap
 import android.graphics.drawable.Drawable
 import android.graphics.drawable.RippleDrawable
 import android.view.MotionEvent
@@ -12,10 +13,9 @@ import androidx.core.graphics.toColorInt
 import androidx.core.net.toUri
 import com.facebook.common.executors.UiThreadImmediateExecutorService
 import com.facebook.common.references.CloseableReference
-import com.facebook.datasource.BaseDataSubscriber
 import com.facebook.datasource.DataSource
 import com.facebook.drawee.backends.pipeline.Fresco
-import com.facebook.imagepipeline.image.CloseableBitmap
+import com.facebook.imagepipeline.datasource.BaseBitmapReferenceDataSubscriber
 import com.facebook.imagepipeline.image.CloseableImage
 import com.facebook.imagepipeline.request.ImageRequestBuilder
 import com.facebook.react.bridge.ReadableMap
@@ -36,6 +36,7 @@ class AddToWalletButtonView(
 
   private var loadedSource: String? = null
   private var currentDataSource: DataSource<CloseableReference<CloseableImage>>? = null
+  private var currentBitmapReference: CloseableReference<Bitmap>? = null
 
   init {
     scaleType = ScaleType.CENTER_CROP
@@ -118,20 +119,14 @@ class AddToWalletButtonView(
     currentDataSource = dataSource
 
     dataSource.subscribe(
-      object : BaseDataSubscriber<CloseableReference<CloseableImage>>() {
-        override fun onNewResultImpl(dataSource: DataSource<CloseableReference<CloseableImage>>) {
-          if (!dataSource.isFinished) return
-          val imageRef = dataSource.result ?: return
-
-          try {
-            val image = imageRef.get()
-            if (image is CloseableBitmap) {
-              val drawable = image.underlyingBitmap.toDrawable(resources)
-              setImageWithRipple(drawable)
-            }
-          } finally {
-            CloseableReference.closeSafely(imageRef)
-          }
+      object : BaseBitmapReferenceDataSubscriber() {
+        override fun onNewResultImpl(bitmapReference: CloseableReference<Bitmap>?) {
+          val image = bitmapReference?.get() ?: return
+
+          currentBitmapReference = bitmapReference.cloneOrNull()
+
+          val drawable = image.toDrawable(resources)
+          setImageWithRipple(drawable)
         }
 
         override fun onFailureImpl(dataSource: DataSource<CloseableReference<CloseableImage>>) {
@@ -165,6 +160,12 @@ class AddToWalletButtonView(
 
   private fun cancelCurrentRequest() {
     currentDataSource?.close()
+
+    currentBitmapReference?.let {
+      CloseableReference.closeSafely(it)
+    }
+
+    currentBitmapReference = null
     currentDataSource = null
   }
 

package/android/src/oldarch/java/com/reactnativestripesdk/NativeOnrampSdkModuleSpec.java

@@ -18,7 +18,6 @@ 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.modules.core.DeviceEventManagerModule;
 import com.facebook.react.turbomodule.core.interfaces.TurboModule;
 import javax.annotation.Nonnull;
 
@@ -34,16 +33,6 @@ public abstract class NativeOnrampSdkModuleSpec extends ReactContextBaseJavaModu
     return NAME;
   }
 
-  private void invoke(String eventName, Object params) {
-    getReactApplicationContext()
-      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-      .emit(eventName, params);
-  }
-
-  protected final void emitOnCheckoutClientSecretRequested(ReadableMap value) {
-    invoke("onCheckoutClientSecretRequested", value);
-  }
-
   @ReactMethod
   @DoNotStrip
   public abstract void initialise(ReadableMap params, Promise promise);
@@ -111,4 +100,12 @@ public abstract class NativeOnrampSdkModuleSpec extends ReactContextBaseJavaModu
   @ReactMethod
   @DoNotStrip
   public abstract void logout(Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void addListener(String eventType);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void removeListeners(double count);
 }

package/android/src/onramp/java/com/reactnativestripesdk/OnrampMappers.kt

@@ -1,8 +1,11 @@
+@file:OptIn(ExperimentalCryptoOnramp::class)
+
 package com.reactnativestripesdk
 
 import android.annotation.SuppressLint
 import androidx.compose.ui.graphics.Color
 import com.facebook.react.bridge.ReadableMap
+import com.stripe.android.crypto.onramp.ExperimentalCryptoOnramp
 import com.stripe.android.crypto.onramp.model.OnrampConfiguration
 import com.stripe.android.crypto.onramp.model.PaymentMethodDisplayData
 import com.stripe.android.googlepaylauncher.GooglePayEnvironment
@@ -148,6 +151,7 @@ internal fun mapAppearance(appearanceMap: ReadableMap): LinkAppearance {
     .primaryButton(primaryButton)
 }
 
+@OptIn(ExperimentalCryptoOnramp::class)
 @SuppressLint("RestrictedApi")
 internal fun mapPaymentDetailsType(type: PaymentMethodDisplayData.Type): String =
   when (type) {

package/android/src/onramp/java/com/reactnativestripesdk/OnrampSdkModule.kt

@@ -1,3 +1,5 @@
+@file:OptIn(ExperimentalCryptoOnramp::class)
+
 package com.reactnativestripesdk
 
 import android.annotation.SuppressLint
@@ -23,6 +25,7 @@ import com.reactnativestripesdk.utils.createOnrampNotConfiguredError
 import com.reactnativestripesdk.utils.createResult
 import com.reactnativestripesdk.utils.getValOr
 import com.reactnativestripesdk.utils.mapToPaymentSheetAddress
+import com.stripe.android.crypto.onramp.ExperimentalCryptoOnramp
 import com.stripe.android.crypto.onramp.OnrampCoordinator
 import com.stripe.android.crypto.onramp.model.CryptoNetwork
 import com.stripe.android.crypto.onramp.model.KycInfo
@@ -57,10 +60,12 @@ import kotlinx.coroutines.withContext
 import kotlinx.coroutines.withTimeout
 
 @SuppressLint("RestrictedApi")
+@OptIn(ExperimentalCryptoOnramp::class)
 @ReactModule(name = NativeOnrampSdkModuleSpec.NAME)
 class OnrampSdkModule(
   reactContext: ReactApplicationContext,
 ) : NativeOnrampSdkModuleSpec(reactContext) {
+  private val eventEmitterCompat = EventEmitterCompat(reactContext)
   private lateinit var publishableKey: String
   private var stripeAccountId: String? = null
 
@@ -142,7 +147,7 @@ class OnrampSdkModule(
           val params = Arguments.createMap()
           params.putString("onrampSessionId", sessionId)
 
-          emitOnCheckoutClientSecretRequested(params)
+          eventEmitterCompat.emitOnCheckoutClientSecretRequested(params)
 
           checkoutClientSecretDeferred!!.await()
         }
@@ -632,6 +637,16 @@ class OnrampSdkModule(
     }
   }
 
+  @ReactMethod
+  override fun addListener(eventType: String?) {
+    // noop, iOS only
+  }
+
+  @ReactMethod
+  override fun removeListeners(count: Double) {
+    // noop, iOS only
+  }
+
   private fun handleOnrampIdentityVerificationResult(
     result: OnrampVerifyIdentityResult,
     promise: Promise,

package/android/src/test/java/com/reactnativestripesdk/mappers/OnrampMappersTest.kt

@@ -1,3 +1,5 @@
+@file:OptIn(ExperimentalCryptoOnramp::class)
+
 package com.reactnativestripesdk.mappers
 
 import android.annotation.SuppressLint
@@ -5,6 +7,7 @@ import androidx.compose.ui.graphics.toArgb
 import com.reactnativestripesdk.mapAppearance
 import com.reactnativestripesdk.mapConfig
 import com.reactnativestripesdk.utils.readableMapOf
+import com.stripe.android.crypto.onramp.ExperimentalCryptoOnramp
 import com.stripe.android.link.LinkAppearance.Style
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNotNull