@stripe/stripe-react-native 0.5.0 → 0.8.0

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

@@ -3,12 +3,16 @@ package com.reactnativestripesdk
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.bridge.WritableNativeMap
 import com.stripe.android.core.exception.APIException
+import com.stripe.android.core.exception.AuthenticationException
 import com.stripe.android.core.exception.InvalidRequestException
-import com.stripe.android.exception.AuthenticationException
 import com.stripe.android.exception.CardException
 import com.stripe.android.model.PaymentIntent
 import com.stripe.android.model.SetupIntent
 
+enum class ErrorType {
+  Failed, Canceled, Unknown
+}
+
 enum class ConfirmPaymentErrorType {
   Failed, Canceled, Unknown
 }
@@ -17,12 +21,8 @@ enum class CreateTokenErrorType {
   Failed
 }
 
-enum class NextPaymentActionErrorType {
-  Failed, Canceled, Unknown
-}
-
 enum class ConfirmSetupIntentErrorType {
-  Failed, Canceled
+  Failed, Canceled, Unknown
 }
 
 enum class RetrievePaymentIntentErrorType {
@@ -59,6 +59,16 @@ internal fun createError(code: String, message: String?): WritableMap {
   return mapError(code, message, message, null, null, null)
 }
 
+internal fun createMissingActivityError(): WritableMap {
+  return mapError(
+    "Failed",
+    "Activity doesn't exist yet. You can safely retry this method.",
+    null,
+    null,
+    null,
+    null)
+}
+
 internal fun createError(code: String, error: PaymentIntent.Error?): WritableMap {
   return mapError(code, error?.message, error?.message, error?.declineCode, error?.type?.code, error?.code)
 }

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

@@ -16,7 +16,6 @@ class GooglePayButtonManager : SimpleViewManager<GooglePayButtonView?>() {
   }
 
   @ReactProp(name = "buttonType")
-  @SuppressWarnings("unused")
   fun buttonType(view: GooglePayButtonView, buttonType: String) {
     view.setType(buttonType)
   }

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

@@ -87,9 +87,6 @@ class GooglePayFragment : Fragment() {
       readyCallback = ::onGooglePayLauncherReady,
       resultCallback = ::onGooglePayResult
     )
-
-    val intent = Intent(ON_GOOGLE_PAY_FRAGMENT_CREATED)
-    localBroadcastManager.sendBroadcast(intent)
   }
 
   fun presentForPaymentIntent(clientSecret: String) {

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

@@ -8,11 +8,12 @@ import android.widget.FrameLayout
 import androidx.appcompat.app.AppCompatActivity
 import androidx.fragment.app.Fragment
 import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
 import com.stripe.android.googlepaylauncher.GooglePayEnvironment
 import com.stripe.android.googlepaylauncher.GooglePayPaymentMethodLauncher
 
 class GooglePayPaymentMethodLauncherFragment(
-  private val activity: AppCompatActivity,
+  private val context: ReactApplicationContext,
   private val isTestEnv: Boolean,
   private val paymentMethodRequired: Boolean,
   private val promise: Promise
@@ -36,7 +37,7 @@ class GooglePayPaymentMethodLauncherFragment(
       ),
       readyCallback = {
         promise.resolve(it)
-        activity.supportFragmentManager.beginTransaction().remove(this).commit()
+        (context.currentActivity as? AppCompatActivity)?.supportFragmentManager?.beginTransaction()?.remove(this)?.commit()
       },
       resultCallback = {}
     )

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

@@ -5,6 +5,8 @@ import android.util.Log
 import com.facebook.react.bridge.*
 import com.stripe.android.PaymentAuthConfig
 import com.stripe.android.model.*
+import com.stripe.android.model.StripeIntent.NextActionType
+import com.stripe.android.model.StripeIntent.NextActionData
 
 internal fun createResult(key: String, value: WritableMap): WritableMap {
   val map = WritableNativeMap()
@@ -104,6 +106,7 @@ internal fun mapPaymentMethodType(type: PaymentMethod.Type?): String {
     PaymentMethod.Type.Upi -> "Upi"
     PaymentMethod.Type.WeChatPay -> "WeChatPay"
     PaymentMethod.Type.Klarna -> "Klarna"
+    PaymentMethod.Type.USBankAccount -> "USBankAccount"
     else -> "Unknown"
   }
 }
@@ -130,6 +133,7 @@ internal fun mapToPaymentMethodType(type: String?): PaymentMethod.Type? {
     "Upi" -> PaymentMethod.Type.Upi
     "WeChatPay" -> PaymentMethod.Type.WeChatPay
     "Klarna" -> PaymentMethod.Type.Klarna
+    "USBankAccount" -> PaymentMethod.Type.USBankAccount
     else -> null
   }
 }
@@ -211,6 +215,38 @@ internal fun mapFromBankAccount(bankAccount: BankAccount?): WritableMap? {
   return bankAccountMap
 }
 
+internal fun mapToUSBankAccountHolderType(type: String?): PaymentMethod.USBankAccount.USBankAccountHolderType {
+  return when (type) {
+    "Company" -> PaymentMethod.USBankAccount.USBankAccountHolderType.COMPANY
+    "Individual" -> PaymentMethod.USBankAccount.USBankAccountHolderType.INDIVIDUAL
+    else -> PaymentMethod.USBankAccount.USBankAccountHolderType.INDIVIDUAL
+  }
+}
+
+internal fun mapFromUSBankAccountHolderType(type: PaymentMethod.USBankAccount.USBankAccountHolderType?): String {
+  return when (type) {
+    PaymentMethod.USBankAccount.USBankAccountHolderType.COMPANY -> "Company"
+    PaymentMethod.USBankAccount.USBankAccountHolderType.INDIVIDUAL -> "Individual"
+    else -> "Unknown"
+  }
+}
+
+internal fun mapToUSBankAccountType(type: String?): PaymentMethod.USBankAccount.USBankAccountType {
+  return when (type) {
+    "Savings" -> PaymentMethod.USBankAccount.USBankAccountType.SAVINGS
+    "Checking" -> PaymentMethod.USBankAccount.USBankAccountType.CHECKING
+    else -> PaymentMethod.USBankAccount.USBankAccountType.CHECKING
+  }
+}
+
+internal fun mapFromUSBankAccountType(type: PaymentMethod.USBankAccount.USBankAccountType?): String {
+  return when (type) {
+    PaymentMethod.USBankAccount.USBankAccountType.CHECKING -> "Checking"
+    PaymentMethod.USBankAccount.USBankAccountType.SAVINGS -> "Savings"
+    else -> "Unknown"
+  }
+}
+
 internal fun mapFromCard(card: Card?): WritableMap? {
   val cardMap: WritableMap = WritableNativeMap()
 
@@ -277,6 +313,7 @@ internal fun mapFromPaymentMethod(paymentMethod: PaymentMethod): WritableMap {
   val ideal: WritableMap = WritableNativeMap()
   val fpx: WritableMap = WritableNativeMap()
   val upi: WritableMap = WritableNativeMap()
+  val usBankAccount: WritableMap = WritableNativeMap()
 
   card.putString("brand", mapCardBrand(paymentMethod.card?.brand))
   card.putString("country", paymentMethod.card?.country)
@@ -313,8 +350,18 @@ internal fun mapFromPaymentMethod(paymentMethod: PaymentMethod): WritableMap {
 
   upi.putString("vpa", paymentMethod.upi?.vpa)
 
+  usBankAccount.putString("routingNumber", paymentMethod.usBankAccount?.routingNumber)
+  usBankAccount.putString("accountType", mapFromUSBankAccountType(paymentMethod.usBankAccount?.accountType))
+  usBankAccount.putString("accountHolderType", mapFromUSBankAccountHolderType(paymentMethod.usBankAccount?.accountHolderType))
+  usBankAccount.putString("last4", paymentMethod.usBankAccount?.last4)
+  usBankAccount.putString("bankName", paymentMethod.usBankAccount?.bankName)
+  usBankAccount.putString("linkedAccount", paymentMethod.usBankAccount?.linkedAccount)
+  usBankAccount.putString("fingerprint", paymentMethod.usBankAccount?.fingerprint)
+  usBankAccount.putString("preferredNetworks", paymentMethod.usBankAccount?.networks?.preferred)
+  usBankAccount.putArray("supportedNetworks", paymentMethod.usBankAccount?.networks?.supported as? ReadableArray)
+
   pm.putString("id", paymentMethod.id)
-  pm.putString("type", mapPaymentMethodType(paymentMethod.type))
+  pm.putString("paymentMethodType", mapPaymentMethodType(paymentMethod.type))
   pm.putBoolean("livemode", paymentMethod.liveMode)
   pm.putString("customerId", paymentMethod.customerId)
   pm.putMap("billingDetails", mapFromBillingDetails(paymentMethod.billingDetails))
@@ -326,6 +373,7 @@ internal fun mapFromPaymentMethod(paymentMethod: PaymentMethod): WritableMap {
   pm.putMap("Ideal", ideal)
   pm.putMap("Fpx", fpx)
   pm.putMap("Upi", upi)
+  pm.putMap("USBankAccount", usBankAccount)
 
   return pm
 }
@@ -344,6 +392,7 @@ internal fun mapFromPaymentIntentResult(paymentIntent: PaymentIntent): WritableM
   map.putString("created", convertToUnixTimestamp(paymentIntent.created))
   map.putString("captureMethod", mapCaptureMethod(paymentIntent.captureMethod))
   map.putString("confirmationMethod", mapConfirmationMethod(paymentIntent.confirmationMethod))
+  map.putMap("nextAction", mapNextAction(paymentIntent.nextActionType, paymentIntent.nextActionData))
   map.putNull("lastPaymentError")
   map.putNull("shipping")
   map.putNull("amount")
@@ -374,6 +423,55 @@ internal fun mapFromPaymentIntentResult(paymentIntent: PaymentIntent): WritableM
   return map
 }
 
+internal fun mapFromMicrodepositType(type: MicrodepositType): String {
+  return when (type) {
+    MicrodepositType.AMOUNTS -> "amounts"
+    MicrodepositType.DESCRIPTOR_CODE -> "descriptorCode"
+    else -> "unknown"
+  }
+}
+
+internal fun mapNextAction(type: NextActionType?, data: NextActionData?): WritableNativeMap? {
+  val nextActionMap = WritableNativeMap()
+  when (type) {
+    NextActionType.RedirectToUrl -> {
+      (data as? NextActionData.RedirectToUrl)?.let {
+        nextActionMap.putString("type", "urlRedirect")
+        nextActionMap.putString("redirectUrl", it.url.toString())
+      }
+    }
+    NextActionType.VerifyWithMicrodeposits -> {
+      (data as? NextActionData.VerifyWithMicrodeposits)?.let {
+        nextActionMap.putString("type", "verifyWithMicrodeposits")
+        nextActionMap.putString("arrivalDate", it.arrivalDate.toString())
+        nextActionMap.putString("redirectUrl", it.hostedVerificationUrl)
+        nextActionMap.putString("microdepositType", mapFromMicrodepositType(it.microdepositType))
+      }
+    }
+    NextActionType.DisplayOxxoDetails -> {
+      (data as? NextActionData.DisplayOxxoDetails)?.let {
+        nextActionMap.putString("type", "oxxoVoucher")
+        nextActionMap.putInt("expiration", it.expiresAfter)
+        nextActionMap.putString("voucherURL", it.hostedVoucherUrl)
+        nextActionMap.putString("voucherNumber", it.number)
+      }
+    }
+    NextActionType.WeChatPayRedirect -> {
+      (data as? NextActionData.WeChatPayRedirect)?.let {
+        nextActionMap.putString("type", "weChatRedirect")
+        nextActionMap.putString("redirectUrl", it.weChat.qrCodeUrl)
+      }
+    }
+    NextActionType.AlipayRedirect -> { // TODO: Can't access, private
+      return null
+    }
+    NextActionType.BlikAuthorize, NextActionType.UseStripeSdk, null -> {
+      return null
+    }
+  }
+  return nextActionMap
+}
+
 internal fun mapFromPaymentIntentLastErrorType(errorType: PaymentIntent.Error.Type?): String? {
   return when (errorType) {
     PaymentIntent.Error.Type.ApiConnectionError -> "api_connection_error"
@@ -400,8 +498,10 @@ internal fun mapFromSetupIntentLastErrorType(errorType: SetupIntent.Error.Type?)
   }
 }
 
-fun getValOr(map: ReadableMap, key: String, default: String? = ""): String? {
-  return if (map.hasKey(key)) map.getString(key) else default
+fun getValOr(map: ReadableMap?, key: String, default: String? = ""): String? {
+  return map?.let {
+    if (it.hasKey(key)) it.getString(key) else default
+  } ?: default
 }
 
 internal fun mapToAddress(addressMap: ReadableMap?, cardAddress: Address?): Address? {
@@ -416,14 +516,14 @@ internal fun mapToAddress(addressMap: ReadableMap?, cardAddress: Address?): Addr
     .setLine2(getValOr(addressMap, "line2"))
     .setState(getValOr(addressMap, "state"))
 
-    cardAddress?.let { ca ->
-      ca.postalCode?.let {
-        address.setPostalCode(it)
-      }
-      ca.country?.let {
-        address.setCountry(it)
-      }
+  cardAddress?.let { ca ->
+    ca.postalCode?.let {
+      address.setPostalCode(it)
+    }
+    ca.country?.let {
+      address.setCountry(it)
     }
+  }
 
   return address.build()
 }
@@ -432,31 +532,19 @@ internal fun mapToBillingDetails(billingDetails: ReadableMap?, cardAddress: Addr
   if (billingDetails == null && cardAddress == null) {
     return null
   }
-  val addressBuilder = Address.Builder()
+  var address: Address? = null
   val paymentMethodBillingDetailsBuilder =  PaymentMethod.BillingDetails.Builder()
 
   if (billingDetails != null) {
-    addressBuilder
-      .setPostalCode(getValOr(billingDetails, "addressPostalCode"))
-      .setCity(getValOr(billingDetails, "addressCity"))
-      .setCountry(getValOr(billingDetails, "addressCountry"))
-      .setLine1(getValOr(billingDetails, "addressLine1"))
-      .setLine2(getValOr(billingDetails, "addressLine2"))
-      .setState(getValOr(billingDetails, "addressState"))
+    address = mapToAddress(getMapOrNull(billingDetails, "address"), cardAddress)
+
     paymentMethodBillingDetailsBuilder
       .setName(getValOr(billingDetails, "name"))
       .setPhone(getValOr(billingDetails, "phone"))
       .setEmail(getValOr(billingDetails, "email"))
   }
 
-  if (cardAddress?.postalCode?.isNotEmpty() == true) {
-    addressBuilder.setPostalCode(cardAddress.postalCode)
-  }
-  if (cardAddress?.country?.isNotEmpty() == true) {
-    addressBuilder.setCountry(cardAddress.country)
-  }
-
-  paymentMethodBillingDetailsBuilder.setAddress(addressBuilder.build())
+  paymentMethodBillingDetailsBuilder.setAddress(address ?: Address.Builder().build())
   return paymentMethodBillingDetailsBuilder.build()
 }
 
@@ -465,16 +553,12 @@ internal fun mapToShippingDetails(shippingDetails: ReadableMap?): ConfirmPayment
     return null
   }
 
+  val address = mapToAddress(getMapOrNull(shippingDetails, "address"), null)
+    ?: Address.Builder().build()
+
   return ConfirmPaymentIntentParams.Shipping(
     name = getValOr(shippingDetails, "name") ?: "",
-    address = Address.Builder()
-      .setLine1(getValOr(shippingDetails, "addressLine1"))
-      .setLine2(getValOr(shippingDetails, "addressLine2"))
-      .setCity(getValOr(shippingDetails, "addressCity"))
-      .setState(getValOr(shippingDetails, "addressState"))
-      .setCountry(getValOr(shippingDetails, "addressCountry"))
-      .setPostalCode(getValOr(shippingDetails, "addressPostalCode"))
-      .build()
+    address = address
   )
 }
 
@@ -684,6 +768,7 @@ internal fun mapFromSetupIntentResult(setupIntent: SetupIntent): WritableMap {
   map.putString("paymentMethodId", setupIntent.paymentMethodId)
   map.putString("usage", mapSetupIntentUsage(setupIntent.usage))
   map.putString("created", convertToUnixTimestamp(setupIntent.created))
+  map.putMap("nextAction", mapNextAction(setupIntent.nextActionType, setupIntent.nextActionData))
 
   setupIntent.lastSetupError?.let {
     val setupError: WritableMap = WritableNativeMap()

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

@@ -9,8 +9,7 @@ import androidx.fragment.app.Fragment
 import com.facebook.react.bridge.Promise
 import com.stripe.android.ApiResultCallback
 import com.stripe.android.Stripe
-import com.stripe.android.model.PaymentIntent
-import com.stripe.android.model.StripeIntent
+import com.stripe.android.model.*
 import com.stripe.android.payments.paymentlauncher.PaymentLauncher
 import com.stripe.android.payments.paymentlauncher.PaymentResult
 
@@ -19,10 +18,10 @@ class PaymentLauncherFragment(
   private val publishableKey: String,
   private val stripeAccountId: String?,
 ) : Fragment() {
-  lateinit var paymentLauncher: PaymentLauncher
-
-  var clientSecret: String? = null
-  var promise: Promise? = null
+  private lateinit var paymentLauncher: PaymentLauncher
+  private var clientSecret: String? = null
+  private var promise: Promise? = null
+  private var isPaymentIntent: Boolean = true
 
   override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?,
                             savedInstanceState: Bundle?): View {
@@ -32,14 +31,38 @@ class PaymentLauncherFragment(
     }
   }
 
+  fun handleNextActionForPaymentIntent(clientSecret: String, promise: Promise) {
+    this.clientSecret = clientSecret
+    this.promise = promise
+    paymentLauncher.handleNextActionForPaymentIntent(clientSecret)
+  }
+
+  fun confirm(params: ConfirmPaymentIntentParams, clientSecret: String, promise: Promise) {
+    this.clientSecret = clientSecret
+    this.promise = promise
+    this.isPaymentIntent = true
+    paymentLauncher.confirm(params)
+  }
+
+  fun confirm(params: ConfirmSetupIntentParams, clientSecret: String, promise: Promise) {
+    this.clientSecret = clientSecret
+    this.promise = promise
+    this.isPaymentIntent = false
+    paymentLauncher.confirm(params)
+  }
+
   private fun createPaymentLauncher(): PaymentLauncher {
     return PaymentLauncher.create(this, publishableKey, stripeAccountId) { paymentResult ->
       when (paymentResult) {
         is PaymentResult.Completed -> {
           clientSecret?.let {
-            retrievePaymentIntent(it, stripeAccountId)
+            if (isPaymentIntent) retrievePaymentIntent(it, stripeAccountId)
+            else retrieveSetupIntent(it, stripeAccountId)
           } ?: run {
-            throw Exception("Client secret must be set before responding to payment results.")
+            promise?.resolve(
+              createError(ConfirmPaymentErrorType.Failed.toString(), "Client secret must be set before responding to payment results.")
+            )
+              ?: throw Exception("Client secret must be set before responding to payment results.")
           }
         }
         is PaymentResult.Canceled -> {
@@ -54,6 +77,46 @@ class PaymentLauncherFragment(
     }
   }
 
+  private fun retrieveSetupIntent(clientSecret: String, stripeAccountId: String?) {
+    val promise = promise ?: throw Exception("No promise is set to handle payment results.")
+    stripe.retrieveSetupIntent(clientSecret, stripeAccountId, object : ApiResultCallback<SetupIntent> {
+      override fun onError(e: Exception) {
+        promise.resolve(createError(ConfirmSetupIntentErrorType.Failed.toString(), e))
+      }
+
+      override fun onSuccess(result: SetupIntent) {
+        when (result.status) {
+          StripeIntent.Status.Succeeded,
+          StripeIntent.Status.Processing,
+          StripeIntent.Status.RequiresConfirmation,
+          StripeIntent.Status.RequiresCapture -> {
+            promise.resolve(createResult("setupIntent", mapFromSetupIntentResult(result)))
+          }
+          StripeIntent.Status.RequiresAction -> {
+            if (isNextActionSuccessState(result.nextActionType)) {
+              promise.resolve(createResult("setupIntent", mapFromSetupIntentResult(result)))
+            } else {
+              (result.lastSetupError)?.let {
+                promise.resolve(createError(ConfirmSetupIntentErrorType.Canceled.toString(), it))
+              } ?: run {
+                promise.resolve(createError(ConfirmSetupIntentErrorType.Canceled.toString(), "Setup has been canceled"))
+              }
+            }
+          }
+          StripeIntent.Status.RequiresPaymentMethod -> {
+            promise.resolve(createError(ConfirmSetupIntentErrorType.Failed.toString(), result.lastSetupError))
+          }
+          StripeIntent.Status.Canceled -> {
+            promise.resolve(createError(ConfirmSetupIntentErrorType.Canceled.toString(), result.lastSetupError))
+          }
+          else -> {
+            promise.resolve(createError(ConfirmSetupIntentErrorType.Unknown.toString(), "unhandled error: ${result.status}"))
+          }
+        }
+      }
+    })
+  }
+
   private fun retrievePaymentIntent(clientSecret: String, stripeAccountId: String?) {
     val promise = promise ?: throw Exception("No promise is set to handle payment results.")
     stripe.retrievePaymentIntent(clientSecret, stripeAccountId, object : ApiResultCallback<PaymentIntent> {
@@ -65,14 +128,13 @@ class PaymentLauncherFragment(
         when (result.status) {
           StripeIntent.Status.Succeeded,
           StripeIntent.Status.Processing,
+          StripeIntent.Status.RequiresConfirmation,
           StripeIntent.Status.RequiresCapture -> {
-            val paymentIntent = createResult("paymentIntent", mapFromPaymentIntentResult(result))
-            promise.resolve(paymentIntent)
+            promise.resolve(createResult("paymentIntent", mapFromPaymentIntentResult(result)))
           }
           StripeIntent.Status.RequiresAction -> {
-            if (isPaymentIntentNextActionVoucherBased(result.nextActionType)) {
-              val paymentIntent = createResult("paymentIntent", mapFromPaymentIntentResult(result))
-              promise.resolve(paymentIntent)
+            if (isNextActionSuccessState(result.nextActionType)) {
+              promise.resolve(createResult("paymentIntent", mapFromPaymentIntentResult(result)))
             } else {
               (result.lastPaymentError)?.let {
                 promise.resolve(createError(ConfirmPaymentErrorType.Canceled.toString(), it))
@@ -82,34 +144,34 @@ class PaymentLauncherFragment(
             }
           }
           StripeIntent.Status.RequiresPaymentMethod -> {
-            val error = result.lastPaymentError
-            promise.resolve(createError(ConfirmPaymentErrorType.Failed.toString(), error))
-          }
-          StripeIntent.Status.RequiresConfirmation -> {
-            val paymentIntent = createResult("paymentIntent", mapFromPaymentIntentResult(result))
-            promise.resolve(paymentIntent)
+            promise.resolve(createError(ConfirmPaymentErrorType.Failed.toString(), result.lastPaymentError))
           }
           StripeIntent.Status.Canceled -> {
-            val error = result.lastPaymentError
-            promise.resolve(createError(ConfirmPaymentErrorType.Canceled.toString(), error))
+            promise.resolve(createError(ConfirmPaymentErrorType.Canceled.toString(), result.lastPaymentError))
           }
           else -> {
-            val errorMessage = "unhandled error: ${result.status}"
-            promise.resolve(createError(ConfirmPaymentErrorType.Unknown.toString(), errorMessage))
+            promise.resolve(createError(ConfirmPaymentErrorType.Unknown.toString(), "unhandled error: ${result.status}"))
           }
         }
       }
     })
   }
 
-  /// Check paymentIntent.nextAction is voucher-based payment method.
-  /// If it's voucher-based, the paymentIntent status stays in requiresAction until the voucher is paid or expired.
-  /// Currently only OXXO payment is voucher-based.
-  private fun isPaymentIntentNextActionVoucherBased(nextAction: StripeIntent.NextActionType?): Boolean {
-    nextAction?.let {
-      return it == StripeIntent.NextActionType.DisplayOxxoDetails
+  /**
+   * Check if paymentIntent.nextAction is out-of-band, such as voucher-based or waiting
+   * on customer verification. If it is, then being in this state is considered "successful".
+   */
+  private fun isNextActionSuccessState(nextAction: StripeIntent.NextActionType?): Boolean {
+    return when (nextAction) {
+      StripeIntent.NextActionType.DisplayOxxoDetails,
+      StripeIntent.NextActionType.VerifyWithMicrodeposits -> true
+      StripeIntent.NextActionType.RedirectToUrl,
+      StripeIntent.NextActionType.UseStripeSdk,
+      StripeIntent.NextActionType.AlipayRedirect,
+      StripeIntent.NextActionType.BlikAuthorize,
+      StripeIntent.NextActionType.WeChatPayRedirect,
+      null -> false
     }
-    return false
   }
 }