@stripe/stripe-react-native 0.52.0-crypto-onramp-2-private-beta.2 → 0.53.0

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

@@ -1,844 +0,0 @@
-package com.reactnativestripesdk
-
-import android.annotation.SuppressLint
-import android.app.Application
-import androidx.activity.ComponentActivity
-import androidx.compose.ui.graphics.Color
-import androidx.core.content.ContextCompat
-import androidx.fragment.app.FragmentActivity
-import androidx.lifecycle.SavedStateHandle
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.Promise
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.bridge.ReadableMap
-import com.facebook.react.bridge.WritableNativeMap
-import com.facebook.react.module.annotations.ReactModule
-import com.reactnativestripesdk.utils.ErrorType
-import com.reactnativestripesdk.utils.createCanceledError
-import com.reactnativestripesdk.utils.createEmptyResult
-import com.reactnativestripesdk.utils.createError
-import com.reactnativestripesdk.utils.createFailedError
-import com.reactnativestripesdk.utils.createMissingActivityError
-import com.reactnativestripesdk.utils.createMissingInitError
-import com.reactnativestripesdk.utils.createOnrampNotConfiguredError
-import com.reactnativestripesdk.utils.createResult
-import com.reactnativestripesdk.utils.getValOr
-import com.stripe.android.crypto.onramp.OnrampCoordinator
-import com.stripe.android.crypto.onramp.model.CryptoNetwork
-import com.stripe.android.crypto.onramp.model.DateOfBirth
-import com.stripe.android.crypto.onramp.model.KycInfo
-import com.stripe.android.crypto.onramp.model.LinkUserInfo
-import com.stripe.android.crypto.onramp.model.OnrampAttachKycInfoResult
-import com.stripe.android.crypto.onramp.model.OnrampAuthenticateResult
-import com.stripe.android.crypto.onramp.model.OnrampAuthorizeResult
-import com.stripe.android.crypto.onramp.model.OnrampCallbacks
-import com.stripe.android.crypto.onramp.model.OnrampCheckoutResult
-import com.stripe.android.crypto.onramp.model.OnrampCollectPaymentMethodResult
-import com.stripe.android.crypto.onramp.model.OnrampConfiguration
-import com.stripe.android.crypto.onramp.model.OnrampConfigurationResult
-import com.stripe.android.crypto.onramp.model.OnrampCreateCryptoPaymentTokenResult
-import com.stripe.android.crypto.onramp.model.OnrampHasLinkAccountResult
-import com.stripe.android.crypto.onramp.model.OnrampLogOutResult
-import com.stripe.android.crypto.onramp.model.OnrampRegisterLinkUserResult
-import com.stripe.android.crypto.onramp.model.OnrampRegisterWalletAddressResult
-import com.stripe.android.crypto.onramp.model.OnrampUpdatePhoneNumberResult
-import com.stripe.android.crypto.onramp.model.OnrampVerifyIdentityResult
-import com.stripe.android.crypto.onramp.model.PaymentMethodType
-import com.stripe.android.link.LinkAppearance
-import com.stripe.android.link.LinkAppearance.Colors
-import com.stripe.android.link.LinkAppearance.PrimaryButton
-import com.stripe.android.link.LinkAppearance.Style
-import com.stripe.android.link.LinkController.PaymentMethodPreview
-import com.stripe.android.link.PaymentMethodPreviewDetails
-import com.stripe.android.model.CardBrand
-import com.stripe.android.paymentsheet.PaymentSheet
-import kotlinx.coroutines.CompletableDeferred
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
-
-@SuppressLint("RestrictedApi")
-@ReactModule(name = NativeOnrampSdkModuleSpec.NAME)
-class OnrampSdkModule(
-  reactContext: ReactApplicationContext,
-) : NativeOnrampSdkModuleSpec(reactContext) {
-  private lateinit var publishableKey: String
-  private var stripeAccountId: String? = null
-
-  private var onrampCoordinator: OnrampCoordinator? = null
-  private var onrampPresenter: OnrampCoordinator.Presenter? = null
-
-  private var authenticateUserPromise: Promise? = null
-  private var identityVerificationPromise: Promise? = null
-  private var collectPaymentPromise: Promise? = null
-  private var authorizePromise: Promise? = null
-  private var checkoutPromise: Promise? = null
-
-  private var checkoutClientSecretDeferred: CompletableDeferred<String>? = null
-
-  @ReactMethod
-  override fun initialise(
-    params: ReadableMap,
-    promise: Promise,
-  ) {
-    // Note: This method depends on `StripeSdkModule#initialise()` being called as well.
-    val publishableKey = getValOr(params, "publishableKey", null) as String
-    this.stripeAccountId = getValOr(params, "stripeAccountId", null)
-    this.publishableKey = publishableKey
-
-    promise.resolve(null)
-  }
-
-  /**
-   * Safely get and cast the current activity as an AppCompatActivity. If that fails, the promise
-   * provided will be resolved with an error message instructing the user to retry the method.
-   */
-  private fun getCurrentActivityOrResolveWithError(promise: Promise?): FragmentActivity? {
-    (currentActivity as? FragmentActivity)?.let {
-      return it
-    }
-    promise?.resolve(createMissingActivityError())
-    return null
-  }
-
-  @ReactMethod
-  override fun configureOnramp(
-    config: ReadableMap,
-    promise: Promise,
-  ) {
-    val application =
-      currentActivity?.application ?: (reactApplicationContext.applicationContext as? Application)
-    if (application == null) {
-      promise.resolve(createMissingActivityError())
-      return
-    }
-
-    val coordinator =
-      onrampCoordinator ?: OnrampCoordinator
-        .Builder()
-        .build(application, SavedStateHandle())
-        .also { this.onrampCoordinator = it }
-
-    CoroutineScope(Dispatchers.IO).launch {
-      val appearanceMap = config.getMap("appearance")
-      val appearance =
-        if (appearanceMap != null) {
-          mapAppearance(appearanceMap)
-        } else {
-          LinkAppearance(style = Style.AUTOMATIC)
-        }
-
-      val displayName = config.getString("merchantDisplayName") ?: ""
-
-      val cryptoCustomerId = config.getString("cryptoCustomerId")
-
-      val configuration =
-        OnrampConfiguration(
-          merchantDisplayName = displayName,
-          publishableKey = publishableKey,
-          appearance = appearance,
-          cryptoCustomerId = cryptoCustomerId,
-        )
-
-      val configureResult = coordinator.configure(configuration)
-
-      CoroutineScope(Dispatchers.Main).launch {
-        when (configureResult) {
-          is OnrampConfigurationResult.Completed -> {
-            createOnrampPresenter(promise)
-          }
-          is OnrampConfigurationResult.Failed -> {
-            promise.resolve(createError(ErrorType.Failed.toString(), configureResult.error))
-          }
-        }
-      }
-    }
-  }
-
-  @ReactMethod
-  private fun createOnrampPresenter(promise: Promise) {
-    val activity = getCurrentActivityOrResolveWithError(promise) as? ComponentActivity
-    if (activity == null) {
-      promise.resolve(createMissingActivityError())
-      return
-    }
-    if (onrampCoordinator == null) {
-      promise.resolve(createMissingInitError())
-      return
-    }
-    if (onrampPresenter != null) {
-      promise.resolveVoid()
-      return
-    }
-
-    val onrampCallbacks =
-      OnrampCallbacks(
-        authenticateUserCallback = { result ->
-          handleOnrampAuthenticationResult(result, authenticateUserPromise!!)
-        },
-        verifyIdentityCallback = { result ->
-          handleOnrampIdentityVerificationResult(result, identityVerificationPromise!!)
-        },
-        collectPaymentCallback = { result ->
-          handleOnrampCollectPaymentResult(result, collectPaymentPromise!!)
-        },
-        authorizeCallback = { result ->
-          handleOnrampAuthorizationResult(result, authorizePromise!!)
-        },
-        checkoutCallback = { result ->
-          handleOnrampCheckoutResult(result, checkoutPromise!!)
-        },
-      )
-
-    try {
-      onrampPresenter = onrampCoordinator!!.createPresenter(activity, onrampCallbacks)
-      promise.resolveVoid()
-    } catch (e: Exception) {
-      promise.resolve(createFailedError(e))
-    }
-  }
-
-  @ReactMethod
-  override fun hasLinkAccount(
-    email: String,
-    promise: Promise,
-  ) {
-    val coordinator =
-      onrampCoordinator ?: run {
-        promise.resolve(createOnrampNotConfiguredError())
-        return
-      }
-    CoroutineScope(Dispatchers.IO).launch {
-      when (val result = coordinator.hasLinkAccount(email)) {
-        is OnrampHasLinkAccountResult.Completed -> {
-          promise.resolveBoolean("hasLinkAccount", result.hasLinkAccount)
-        }
-        is OnrampHasLinkAccountResult.Failed -> {
-          promise.resolve(createFailedError(result.error))
-        }
-      }
-    }
-  }
-
-  @ReactMethod
-  override fun registerLinkUser(
-    info: ReadableMap,
-    promise: Promise,
-  ) {
-    val coordinator =
-      onrampCoordinator ?: run {
-        promise.resolve(createOnrampNotConfiguredError())
-        return
-      }
-    CoroutineScope(Dispatchers.IO).launch {
-      val linkUserInfo =
-        LinkUserInfo(
-          email = info.getString("email") ?: "",
-          phone = info.getString("phone") ?: "",
-          country = info.getString("country") ?: "",
-          fullName = info.getString("fullName"),
-        )
-
-      val result = coordinator.registerLinkUser(linkUserInfo)
-      when (result) {
-        is OnrampRegisterLinkUserResult.Completed -> {
-          promise.resolveString("customerId", result.customerId)
-        }
-        is OnrampRegisterLinkUserResult.Failed -> {
-          promise.resolve(createFailedError(result.error))
-        }
-      }
-    }
-  }
-
-  @ReactMethod
-  override fun registerWalletAddress(
-    walletAddress: String,
-    network: String,
-    promise: Promise,
-  ) {
-    val coordinator =
-      onrampCoordinator ?: run {
-        promise.resolve(createOnrampNotConfiguredError())
-        return
-      }
-    CoroutineScope(Dispatchers.IO).launch {
-      val cryptoNetwork = enumValues<CryptoNetwork>().firstOrNull { it.value == network }
-      if (cryptoNetwork == null) {
-        promise.resolve(createError(ErrorType.Unknown.toString(), "Invalid network: $network"))
-        return@launch
-      }
-
-      when (val result = coordinator.registerWalletAddress(walletAddress, cryptoNetwork)) {
-        is OnrampRegisterWalletAddressResult.Completed -> {
-          promise.resolveVoid()
-        }
-        is OnrampRegisterWalletAddressResult.Failed -> {
-          promise.resolve(createFailedError(result.error))
-        }
-      }
-    }
-  }
-
-  @ReactMethod
-  override fun attachKycInfo(
-    kycInfo: ReadableMap,
-    promise: Promise,
-  ) {
-    val coordinator =
-      onrampCoordinator ?: run {
-        promise.resolve(createOnrampNotConfiguredError())
-        return
-      }
-    CoroutineScope(Dispatchers.IO).launch {
-      val firstName = kycInfo.getString("firstName")
-      if (firstName.isNullOrEmpty()) {
-        promise.resolve(
-          createError(
-            ErrorType.Unknown.toString(),
-            "Missing required field: firstName",
-          ),
-        )
-        return@launch
-      }
-      val lastName = kycInfo.getString("lastName")
-      if (lastName.isNullOrEmpty()) {
-        promise.resolve(
-          createError(
-            ErrorType.Unknown.toString(),
-            "Missing required field: lastName",
-          ),
-        )
-        return@launch
-      }
-      val idNumber = kycInfo.getString("idNumber")
-      if (idNumber.isNullOrEmpty()) {
-        promise.resolve(
-          createError(
-            ErrorType.Unknown.toString(),
-            "Missing required field: idNumber",
-          ),
-        )
-        return@launch
-      }
-
-      val dateOfBirthMap = kycInfo.getMap("dateOfBirth")
-      val dob =
-        if (
-          dateOfBirthMap != null &&
-          dateOfBirthMap.hasKey("day") &&
-          dateOfBirthMap.hasKey("month") &&
-          dateOfBirthMap.hasKey("year")
-        ) {
-          DateOfBirth(
-            day = dateOfBirthMap.getInt("day"),
-            month = dateOfBirthMap.getInt("month"),
-            year = dateOfBirthMap.getInt("year"),
-          )
-        } else {
-          promise.resolve(
-            createError(
-              ErrorType.Unknown.toString(),
-              "Missing required field: dateOfBirth",
-            ),
-          )
-          return@launch
-        }
-
-      val addressMap = kycInfo.getMap("address")
-      val addressObj =
-        addressMap?.let {
-          PaymentSheet.Address(
-            city = it.getString("city"),
-            country = it.getString("country"),
-            line1 = it.getString("line1"),
-            line2 = it.getString("line2"),
-            postalCode = it.getString("postalCode"),
-            state = it.getString("state"),
-          )
-        } ?: PaymentSheet.Address()
-
-      val kycInfoObj =
-        KycInfo(
-          firstName = firstName,
-          lastName = lastName,
-          idNumber = idNumber,
-          dateOfBirth = dob,
-          address = addressObj,
-        )
-
-      when (val result = coordinator.attachKycInfo(kycInfoObj)) {
-        is OnrampAttachKycInfoResult.Completed -> {
-          promise.resolveVoid()
-        }
-        is OnrampAttachKycInfoResult.Failed -> {
-          promise.resolve(createFailedError(result.error))
-        }
-      }
-    }
-  }
-
-  @ReactMethod
-  override fun updatePhoneNumber(
-    phone: String,
-    promise: Promise,
-  ) {
-    val coordinator =
-      onrampCoordinator ?: run {
-        promise.resolve(createOnrampNotConfiguredError())
-        return
-      }
-    CoroutineScope(Dispatchers.IO).launch {
-      when (val result = coordinator.updatePhoneNumber(phone)) {
-        OnrampUpdatePhoneNumberResult.Completed -> {
-          promise.resolveVoid()
-        }
-        is OnrampUpdatePhoneNumberResult.Failed -> {
-          promise.resolve(createFailedError(result.error))
-        }
-      }
-    }
-  }
-
-  @ReactMethod
-  override fun authenticateUser(promise: Promise) {
-    val presenter =
-      onrampPresenter ?: run {
-        promise.resolve(createOnrampNotConfiguredError())
-        return
-      }
-
-    authenticateUserPromise = promise
-
-    presenter.authenticateUser()
-  }
-
-  @ReactMethod
-  override fun verifyIdentity(promise: Promise) {
-    val presenter =
-      onrampPresenter ?: run {
-        promise.resolve(createOnrampNotConfiguredError())
-        return
-      }
-
-    identityVerificationPromise = promise
-
-    presenter.verifyIdentity()
-  }
-
-  @ReactMethod
-  override fun collectPaymentMethod(
-    paymentMethod: String,
-    platformPayParams: ReadableMap,
-    promise: Promise,
-  ) {
-    val presenter =
-      onrampPresenter ?: run {
-        promise.resolve(createOnrampNotConfiguredError())
-        return
-      }
-
-    val method =
-      when (paymentMethod) {
-        "Card" -> PaymentMethodType.Card
-        "BankAccount" -> PaymentMethodType.BankAccount
-        else -> {
-          promise.resolve(
-            createFailedError(
-              IllegalArgumentException("Unsupported payment method: $paymentMethod"),
-            ),
-          )
-          return
-        }
-      }
-
-    collectPaymentPromise = promise
-
-    presenter.collectPaymentMethod(method)
-  }
-
-  @ReactMethod
-  override fun createCryptoPaymentToken(promise: Promise) {
-    val coordinator =
-      onrampCoordinator ?: run {
-        promise.resolve(createOnrampNotConfiguredError())
-        return
-      }
-
-    CoroutineScope(Dispatchers.IO).launch {
-      val result = coordinator.createCryptoPaymentToken()
-      CoroutineScope(Dispatchers.Main).launch {
-        handleOnrampCreateCryptoPaymentTokenResult(result, promise)
-      }
-    }
-  }
-
-  @ReactMethod
-  override fun performCheckout(
-    onrampSessionId: String,
-    promise: Promise,
-  ) {
-    val presenter =
-      onrampPresenter ?: run {
-        promise.resolve(createOnrampNotConfiguredError())
-        return
-      }
-
-    val checkoutHandler: suspend () -> String = {
-      checkoutClientSecretDeferred = CompletableDeferred()
-
-      val params = Arguments.createMap()
-      params.putString("onrampSessionId", onrampSessionId)
-
-      emitOnCheckoutClientSecretRequested(params)
-
-      checkoutClientSecretDeferred!!.await()
-    }
-
-    checkoutPromise = promise
-
-    presenter.performCheckout(onrampSessionId, checkoutHandler)
-  }
-
-  @ReactMethod
-  override fun provideCheckoutClientSecret(clientSecret: String?) {
-    if (clientSecret != null) {
-      checkoutClientSecretDeferred?.complete(clientSecret)
-    } else {
-      checkoutClientSecretDeferred?.completeExceptionally(
-        RuntimeException("Failed to provide checkout client secret"),
-      )
-    }
-    checkoutClientSecretDeferred = null
-  }
-
-  @ReactMethod
-  override fun onrampAuthorize(
-    linkAuthIntentId: String,
-    promise: Promise,
-  ) {
-    val presenter =
-      onrampPresenter ?: run {
-        promise.resolve(createOnrampNotConfiguredError())
-        return
-      }
-
-    authorizePromise = promise
-
-    presenter.authorize(linkAuthIntentId)
-  }
-
-  @ReactMethod
-  override fun getCryptoTokenDisplayData(
-    token: ReadableMap,
-    promise: Promise,
-  ) {
-    val context = reactApplicationContext
-
-    val paymentDetails: PaymentMethodPreview? =
-      when {
-        token.hasKey("card") -> {
-          val cardMap = token.getMap("card")
-          if (cardMap != null) {
-            val brand = cardMap.getString("brand") ?: ""
-            val funding = cardMap.getString("funding") ?: ""
-            val last4 = cardMap.getString("last4") ?: ""
-            val cardBrand = CardBrand.fromCode(brand)
-
-            PaymentMethodPreview.create(
-              context = context,
-              details =
-                PaymentMethodPreviewDetails.Card(
-                  brand = cardBrand,
-                  funding = funding,
-                  last4 = last4,
-                ),
-            )
-          } else {
-            null
-          }
-        }
-        token.hasKey("us_bank_account") -> {
-          val bankMap = token.getMap("us_bank_account")
-          if (bankMap != null) {
-            val bankName = bankMap.getString("bank_name")
-            val last4 = bankMap.getString("last4") ?: ""
-            PaymentMethodPreview.create(
-              context = context,
-              details =
-                PaymentMethodPreviewDetails.BankAccount(
-                  bankIconCode = null,
-                  bankName = bankName,
-                  last4 = last4,
-                ),
-            )
-          } else {
-            null
-          }
-        }
-        else -> null
-      }
-
-    if (paymentDetails == null) {
-      promise.resolve(
-        createFailedError(
-          IllegalArgumentException("Unsupported payment method"),
-        ),
-      )
-      return
-    }
-
-    val icon =
-      currentActivity
-        ?.let { ContextCompat.getDrawable(it, paymentDetails.iconRes) }
-        ?.let { "data:image/png;base64," + getBase64FromBitmap(getBitmapFromDrawable(it)) }
-
-    val displayData = Arguments.createMap()
-
-    displayData.putString("icon", icon)
-    displayData.putString("label", paymentDetails.label)
-    displayData.putString("sublabel", paymentDetails.sublabel)
-
-    promise.resolve(createResult("displayData", displayData))
-  }
-
-  @ReactMethod
-  override fun logout(promise: Promise) {
-    val coordinator =
-      onrampCoordinator ?: run {
-        promise.resolve(createOnrampNotConfiguredError())
-        return
-      }
-
-    CoroutineScope(Dispatchers.IO).launch {
-      val result = coordinator.logOut()
-      CoroutineScope(Dispatchers.Main).launch {
-        handleLogOutResult(result, promise)
-      }
-    }
-  }
-
-  private fun mapAppearance(appearanceMap: ReadableMap): LinkAppearance {
-    val lightColorsMap = appearanceMap.getMap("lightColors")
-    val darkColorsMap = appearanceMap.getMap("darkColors")
-    val styleStr = appearanceMap.getString("style")
-    val primaryButtonMap = appearanceMap.getMap("primaryButton")
-
-    val lightColors =
-      if (lightColorsMap != null) {
-        val primaryColorStr = lightColorsMap.getString("primary")
-        val contentColorStr = lightColorsMap.getString("contentOnPrimary")
-        val borderSelectedColorStr = lightColorsMap.getString("borderSelected")
-
-        Colors(
-          primary = Color(android.graphics.Color.parseColor(primaryColorStr)),
-          contentOnPrimary = Color(android.graphics.Color.parseColor(contentColorStr)),
-          borderSelected = Color(android.graphics.Color.parseColor(borderSelectedColorStr)),
-        )
-      } else {
-        null
-      }
-
-    val darkColors =
-      if (darkColorsMap != null) {
-        val primaryColorStr = darkColorsMap.getString("primary")
-        val contentColorStr = darkColorsMap.getString("contentOnPrimary")
-        val borderSelectedColorStr = darkColorsMap.getString("borderSelected")
-
-        Colors(
-          primary = Color(android.graphics.Color.parseColor(primaryColorStr)),
-          contentOnPrimary = Color(android.graphics.Color.parseColor(contentColorStr)),
-          borderSelected = Color(android.graphics.Color.parseColor(borderSelectedColorStr)),
-        )
-      } else {
-        null
-      }
-
-    val style =
-      when (styleStr) {
-        "ALWAYS_LIGHT" -> Style.ALWAYS_LIGHT
-        "ALWAYS_DARK" -> Style.ALWAYS_DARK
-        else -> Style.AUTOMATIC
-      }
-
-    val primaryButton =
-      if (primaryButtonMap != null) {
-        PrimaryButton(
-          cornerRadiusDp =
-            if (primaryButtonMap.hasKey("cornerRadius")) {
-              primaryButtonMap.getDouble("cornerRadius").toFloat()
-            } else {
-              null
-            },
-          heightDp =
-            if (primaryButtonMap.hasKey("height")) {
-              primaryButtonMap.getDouble("height").toFloat()
-            } else {
-              null
-            },
-        )
-      } else {
-        null
-      }
-
-    val default = LinkAppearance(style = Style.AUTOMATIC)
-    return LinkAppearance(
-      lightColors = lightColors ?: default.lightColors,
-      darkColors = darkColors ?: default.darkColors,
-      style = style,
-      primaryButton = primaryButton ?: default.primaryButton,
-    )
-  }
-
-  private fun handleOnrampAuthenticationResult(
-    result: OnrampAuthenticateResult,
-    promise: Promise,
-  ) {
-    when (result) {
-      is OnrampAuthenticateResult.Completed -> {
-        promise.resolveString("customerId", result.customerId)
-      }
-      is OnrampAuthenticateResult.Cancelled -> {
-        promise.resolve(createCanceledError("Authentication was cancelled"))
-      }
-      is OnrampAuthenticateResult.Failed -> {
-        promise.resolve(createFailedError(result.error))
-      }
-    }
-  }
-
-  private fun handleOnrampIdentityVerificationResult(
-    result: OnrampVerifyIdentityResult,
-    promise: Promise,
-  ) {
-    when (result) {
-      is OnrampVerifyIdentityResult.Completed -> {
-        promise.resolveVoid()
-      }
-      is OnrampVerifyIdentityResult.Cancelled -> {
-        promise.resolve(createCanceledError("Identity verification was cancelled"))
-      }
-      is OnrampVerifyIdentityResult.Failed -> {
-        promise.resolve(createFailedError(result.error))
-      }
-    }
-  }
-
-  private fun handleOnrampCollectPaymentResult(
-    result: OnrampCollectPaymentMethodResult,
-    promise: Promise,
-  ) {
-    when (result) {
-      is OnrampCollectPaymentMethodResult.Completed -> {
-        val displayData = Arguments.createMap()
-        val icon =
-          currentActivity
-            ?.let { ContextCompat.getDrawable(it, result.displayData.iconRes) }
-            ?.let { "data:image/png;base64," + getBase64FromBitmap(getBitmapFromDrawable(it)) }
-        displayData.putString("icon", icon)
-        displayData.putString("label", result.displayData.label)
-        result.displayData.sublabel?.let { displayData.putString("sublabel", it) }
-        promise.resolve(createResult("displayData", displayData))
-      }
-      is OnrampCollectPaymentMethodResult.Cancelled -> {
-        promise.resolve(createCanceledError("Payment collection was cancelled"))
-      }
-      is OnrampCollectPaymentMethodResult.Failed -> {
-        promise.resolve(createFailedError(result.error))
-      }
-    }
-  }
-
-  private fun handleOnrampAuthorizationResult(
-    result: OnrampAuthorizeResult,
-    promise: Promise,
-  ) {
-    when (result) {
-      is OnrampAuthorizeResult.Consented -> {
-        promise.resolve(
-          WritableNativeMap().apply {
-            putString("status", "Consented")
-            putString("customerId", result.customerId)
-          },
-        )
-      }
-      is OnrampAuthorizeResult.Denied -> {
-        promise.resolve(
-          WritableNativeMap().apply {
-            putString("status", "Denied")
-          },
-        )
-      }
-      is OnrampAuthorizeResult.Canceled -> {
-        promise.resolve(createCanceledError("Authorization was cancelled"))
-      }
-      is OnrampAuthorizeResult.Failed -> {
-        promise.resolve(createFailedError(result.error))
-      }
-    }
-  }
-
-  private fun handleOnrampCheckoutResult(
-    result: OnrampCheckoutResult,
-    promise: Promise,
-  ) {
-    when (result) {
-      is OnrampCheckoutResult.Completed -> {
-        promise.resolveVoid()
-      }
-      is OnrampCheckoutResult.Canceled -> {
-        promise.resolve(createCanceledError("Checkout was cancelled"))
-      }
-      is OnrampCheckoutResult.Failed -> {
-        promise.resolve(createFailedError(result.error))
-      }
-    }
-  }
-
-  private fun handleOnrampCreateCryptoPaymentTokenResult(
-    result: OnrampCreateCryptoPaymentTokenResult,
-    promise: Promise,
-  ) {
-    when (result) {
-      is OnrampCreateCryptoPaymentTokenResult.Completed -> {
-        promise.resolveString("cryptoPaymentToken", result.cryptoPaymentToken)
-      }
-      is OnrampCreateCryptoPaymentTokenResult.Failed -> {
-        promise.resolve(createFailedError(result.error))
-      }
-    }
-  }
-
-  private fun handleLogOutResult(
-    result: OnrampLogOutResult,
-    promise: Promise,
-  ) {
-    when (result) {
-      is OnrampLogOutResult.Completed -> {
-        promise.resolveVoid()
-      }
-      is OnrampLogOutResult.Failed -> {
-        promise.resolve(createFailedError(result.error))
-      }
-    }
-  }
-
-  private fun Promise.resolveVoid() {
-    resolve(createEmptyResult())
-  }
-
-  private fun Promise.resolveString(
-    key: String,
-    value: String,
-  ) {
-    resolve(WritableNativeMap().apply { putString(key, value) })
-  }
-
-  private fun Promise.resolveBoolean(
-    key: String,
-    value: Boolean,
-  ) {
-    resolve(WritableNativeMap().apply { putBoolean(key, value) })
-  }
-}