@stripe/stripe-react-native 0.6.0 → 0.9.0

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

@@ -0,0 +1,84 @@
+package com.reactnativestripesdk
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+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.model.PaymentIntent
+import com.stripe.android.model.SetupIntent
+import com.stripe.android.model.StripeIntent
+import com.stripe.android.payments.bankaccount.CollectBankAccountConfiguration
+import com.stripe.android.payments.bankaccount.CollectBankAccountLauncher
+import com.stripe.android.payments.bankaccount.navigation.CollectBankAccountResult
+
+class CollectBankAccountLauncherFragment(
+  private val context: ReactApplicationContext,
+  private val publishableKey: String,
+  private val clientSecret: String,
+  private val isPaymentIntent: Boolean,
+  private val collectParams:  CollectBankAccountConfiguration.USBankAccount,
+  private val promise: Promise
+) : Fragment() {
+  private lateinit var collectBankAccountLauncher: CollectBankAccountLauncher
+
+  override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?,
+                            savedInstanceState: Bundle?): View {
+    collectBankAccountLauncher = createBankAccountLauncher()
+
+    return FrameLayout(requireActivity()).also {
+      it.visibility = View.GONE
+    }
+  }
+
+  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+    super.onViewCreated(
+      view,
+      savedInstanceState)
+
+    if (isPaymentIntent) {
+      collectBankAccountLauncher.presentWithPaymentIntent(
+        publishableKey,
+        clientSecret,
+        collectParams
+      )
+    } else {
+      collectBankAccountLauncher.presentWithSetupIntent(
+        publishableKey,
+        clientSecret,
+        collectParams
+      )
+    }
+  }
+
+  private fun createBankAccountLauncher(): CollectBankAccountLauncher {
+    return CollectBankAccountLauncher.create(this) { result ->
+      when (result) {
+        is CollectBankAccountResult.Completed -> {
+          val intent = result.response.intent
+          if (intent.status === StripeIntent.Status.RequiresPaymentMethod) {
+            promise.resolve(createError(ErrorType.Canceled.toString(), "Bank account collection was canceled."))
+          } else if (intent.status === StripeIntent.Status.RequiresConfirmation) {
+            promise.resolve(
+              if (isPaymentIntent)
+                createResult("paymentIntent", mapFromPaymentIntentResult(intent as PaymentIntent))
+              else
+                createResult("setupIntent", mapFromSetupIntentResult(intent as SetupIntent))
+            )
+          }
+        }
+        is CollectBankAccountResult.Cancelled -> {
+          promise.resolve(createError(ErrorType.Canceled.toString(), "Bank account collection was canceled."))
+        }
+        is CollectBankAccountResult.Failed -> {
+          promise.resolve(createError(ErrorType.Failed.toString(), result.error))
+        }
+      }
+      (context.currentActivity as? AppCompatActivity)?.supportFragmentManager?.beginTransaction()?.remove(this)?.commitAllowingStateLoss()
+    }
+  }
+}

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

@@ -5,7 +5,6 @@ var ON_PAYMENT_OPTION_ACTION = "com.reactnativestripesdk.PAYMENT_OPTION_ACTION"
 var ON_CONFIGURE_FLOW_CONTROLLER = "com.reactnativestripesdk.CONFIGURE_FLOW_CONTROLLER_ACTION"
 var ON_INIT_PAYMENT_SHEET = "com.reactnativestripesdk.INIT_PAYMENT_SHEET"
 
-var ON_GOOGLE_PAY_FRAGMENT_CREATED = "com.reactnativestripesdk.ON_GOOGLE_PAY_FRAGMENT_CREATED"
 var ON_INIT_GOOGLE_PAY = "com.reactnativestripesdk.ON_INIT_GOOGLE_PAY"
 var ON_GOOGLE_PAY_RESULT = "com.reactnativestripesdk.ON_GOOGLE_PAY_RESULT"
 var ON_GOOGLE_PAYMENT_METHOD_RESULT = "com.reactnativestripesdk.ON_GOOGLE_PAYMENT_METHOD_RESULT"

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)?.commitAllowingStateLoss()
       },
       resultCallback = {}
     )

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

@@ -106,6 +106,8 @@ internal fun mapPaymentMethodType(type: PaymentMethod.Type?): String {
     PaymentMethod.Type.Upi -> "Upi"
     PaymentMethod.Type.WeChatPay -> "WeChatPay"
     PaymentMethod.Type.Klarna -> "Klarna"
+    PaymentMethod.Type.USBankAccount -> "USBankAccount"
+    PaymentMethod.Type.PayPal -> "PayPal"
     else -> "Unknown"
   }
 }
@@ -132,6 +134,8 @@ internal fun mapToPaymentMethodType(type: String?): PaymentMethod.Type? {
     "Upi" -> PaymentMethod.Type.Upi
     "WeChatPay" -> PaymentMethod.Type.WeChatPay
     "Klarna" -> PaymentMethod.Type.Klarna
+    "USBankAccount" -> PaymentMethod.Type.USBankAccount
+    "PayPal" -> PaymentMethod.Type.PayPal
     else -> null
   }
 }
@@ -213,6 +217,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()
 
@@ -279,10 +315,10 @@ 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)
-
   paymentMethod.card?.expiryYear?.let {
     card.putInt("expYear", it)
   }
@@ -291,6 +327,7 @@ internal fun mapFromPaymentMethod(paymentMethod: PaymentMethod): WritableMap {
   }
   card.putString("funding", paymentMethod.card?.funding)
   card.putString("last4", paymentMethod.card?.last4)
+  card.putString("fingerprint", paymentMethod.card?.fingerprint)
 
   sepaDebit.putString("bankCode", paymentMethod.sepaDebit?.bankCode)
   sepaDebit.putString("country", paymentMethod.sepaDebit?.country)
@@ -315,8 +352,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))
@@ -328,6 +375,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
 }
@@ -377,6 +425,14 @@ 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) {
@@ -386,15 +442,14 @@ internal fun mapNextAction(type: NextActionType?, data: NextActionData?): Writab
         nextActionMap.putString("redirectUrl", it.url.toString())
       }
     }
-    // TODO: This is currently private. Uncomment when ACHv2 is available on Android.
-    // 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", it.microdepositType.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")
@@ -445,30 +500,33 @@ 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? {
-  if (addressMap == null) {
-    return null
-  }
+internal fun mapToAddress(addressMap: ReadableMap?, cardAddress: Address?): Address {
   val address = Address.Builder()
-    .setPostalCode(getValOr(addressMap, "postalCode"))
-    .setCity(getValOr(addressMap, "city"))
-    .setCountry(getValOr(addressMap, "country"))
-    .setLine1(getValOr(addressMap, "line1"))
-    .setLine2(getValOr(addressMap, "line2"))
-    .setState(getValOr(addressMap, "state"))
-
-    cardAddress?.let { ca ->
-      ca.postalCode?.let {
-        address.setPostalCode(it)
-      }
-      ca.country?.let {
-        address.setCountry(it)
-      }
+
+  addressMap?.let {
+    address
+      .setPostalCode(getValOr(it, "postalCode"))
+      .setCity(getValOr(it, "city"))
+      .setCountry(getValOr(it, "country"))
+      .setLine1(getValOr(it, "line1"))
+      .setLine2(getValOr(it, "line2"))
+      .setState(getValOr(it, "state"))
+  }
+
+  cardAddress?.let {
+    if (!it.postalCode.isNullOrEmpty()) {
+      address.setPostalCode(it.postalCode)
     }
+    if (!it.country.isNullOrEmpty()) {
+      address.setCountry(it.country)
+    }
+  }
 
   return address.build()
 }
@@ -477,31 +535,17 @@ internal fun mapToBillingDetails(billingDetails: ReadableMap?, cardAddress: Addr
   if (billingDetails == null && cardAddress == null) {
     return null
   }
-  val addressBuilder = Address.Builder()
+  val address = mapToAddress(getMapOrNull(billingDetails, "address"), cardAddress)
   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"))
     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)
   return paymentMethodBillingDetailsBuilder.build()
 }
 
@@ -510,16 +554,11 @@ internal fun mapToShippingDetails(shippingDetails: ReadableMap?): ConfirmPayment
     return null
   }
 
+  val address = mapToAddress(getMapOrNull(shippingDetails, "address"), null)
+
   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
   )
 }
 

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 (isNextActionSuccessState(result.nextActionType)) {
-              val paymentIntent = createResult("paymentIntent", mapFromPaymentIntentResult(result))
-              promise.resolve(paymentIntent)
+              promise.resolve(createResult("paymentIntent", mapFromPaymentIntentResult(result)))
             } else {
               (result.lastPaymentError)?.let {
                 promise.resolve(createError(ConfirmPaymentErrorType.Canceled.toString(), it))
@@ -82,20 +144,13 @@ 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}"))
           }
         }
       }