@stripe/stripe-react-native 0.6.0 → 0.7.0

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

@@ -30,6 +30,7 @@ class PaymentMethodCreateParamsFactory(
         PaymentMethod.Type.AfterpayClearpay -> createAfterpayClearpayPaymentConfirmParams()
         PaymentMethod.Type.AuBecsDebit -> createAuBecsDebitPaymentConfirmParams()
         PaymentMethod.Type.Klarna -> createKlarnaPaymentConfirmParams()
+        PaymentMethod.Type.USBankAccount -> createUSBankAccountPaymentConfirmParams()
         else -> {
           throw Exception("This paymentMethodType is not supported yet")
         }
@@ -49,6 +50,7 @@ class PaymentMethodCreateParamsFactory(
         PaymentMethod.Type.Bancontact -> createBancontactPaymentSetupParams()
         PaymentMethod.Type.SepaDebit -> createSepaPaymentSetupParams()
         PaymentMethod.Type.AuBecsDebit -> createAuBecsDebitPaymentSetupParams()
+        PaymentMethod.Type.USBankAccount -> createUSBankAccountPaymentSetupParams()
         else -> {
           throw Exception("This paymentMethodType is not supported yet")
         }
@@ -154,8 +156,8 @@ class PaymentMethodCreateParamsFactory(
       val sepaParams = PaymentMethodCreateParams.SepaDebit(iban)
       val createParams =
         PaymentMethodCreateParams.create(
-                     sepaDebit = sepaParams,
-                     billingDetails = it
+          sepaDebit = sepaParams,
+          billingDetails = it
         )
 
       return ConfirmSetupIntentParams.create(
@@ -170,7 +172,7 @@ class PaymentMethodCreateParamsFactory(
   @Throws(PaymentMethodCreateParamsException::class)
   private fun createCardPaymentSetupParams(): ConfirmSetupIntentParams {
     val cardParams = cardFieldView?.cardParams ?: cardFormView?.cardParams
-      ?: throw PaymentMethodCreateParamsException("Card details not complete")
+    ?: throw PaymentMethodCreateParamsException("Card details not complete")
 
     val paymentMethodCreateParams =
       PaymentMethodCreateParams.create(cardParams, billingDetailsParams)
@@ -422,11 +424,31 @@ class PaymentMethodCreateParamsFactory(
       )
   }
 
+  @Throws(PaymentMethodCreateParamsException::class)
+  private fun createUSBankAccountPaymentSetupParams(): ConfirmSetupIntentParams {
+    params.getString("accountNumber")?.let {
+      if (billingDetailsParams?.name.isNullOrBlank()) {
+        throw PaymentMethodCreateParamsException("When creating a US bank account payment method, you must provide the following billing details: name")
+      }
+      return ConfirmSetupIntentParams.create(
+        paymentMethodCreateParams = createUSBankAccountParams(params),
+        clientSecret = clientSecret,
+      )
+    } ?: run {
+      // Payment method is assumed to be already attached through via collectBankAccountForSetup
+      return ConfirmSetupIntentParams.create(
+        clientSecret = clientSecret,
+        paymentMethodType = PaymentMethod.Type.USBankAccount
+      )
+    }
+  }
+
+
   @Throws(PaymentMethodCreateParamsException::class)
   private fun createKlarnaPaymentConfirmParams(): ConfirmPaymentIntentParams {
     if (billingDetailsParams == null ||
-        billingDetailsParams.address?.country.isNullOrBlank() ||
-        billingDetailsParams.email.isNullOrBlank()
+      billingDetailsParams.address?.country.isNullOrBlank() ||
+      billingDetailsParams.email.isNullOrBlank()
     ) {
       throw PaymentMethodCreateParamsException("Klarna requires that you provide the following billing details: email, country")
     }
@@ -439,6 +461,60 @@ class PaymentMethodCreateParamsFactory(
         clientSecret = clientSecret,
       )
   }
+
+  @Throws(PaymentMethodCreateParamsException::class)
+  private fun createUSBankAccountPaymentConfirmParams(): ConfirmPaymentIntentParams {
+    params.getString("accountNumber")?.let {
+      if (billingDetailsParams?.name.isNullOrBlank()) {
+        throw PaymentMethodCreateParamsException("When creating a US bank account payment method, you must provide the following billing details: name")
+      }
+
+      return ConfirmPaymentIntentParams.createWithPaymentMethodCreateParams(
+        paymentMethodCreateParams = createUSBankAccountParams(params),
+        clientSecret,
+        setupFutureUsage = mapToPaymentIntentFutureUsage(getValOr(params, "setupFutureUsage"))
+      )
+    } ?: run {
+      // Payment method is assumed to be already attached through via collectBankAccountForPayment
+      return ConfirmPaymentIntentParams.create(
+        clientSecret = clientSecret,
+        paymentMethodType = PaymentMethod.Type.USBankAccount
+      )
+    }
+  }
+
+  @Throws(PaymentMethodCreateParamsException::class)
+  private fun createUSBankAccountParams(params: ReadableMap): PaymentMethodCreateParams {
+    val accountNumber = getValOr(params, "accountNumber", null)
+    val routingNumber = getValOr(params, "routingNumber", null)
+
+    if (accountNumber.isNullOrBlank()) {
+      throw PaymentMethodCreateParamsException("When creating a US bank account payment method, you must provide the bank account number")
+    } else if (routingNumber.isNullOrBlank()) {
+      throw PaymentMethodCreateParamsException("When creating a US bank account payment method, you must provide the bank routing number")
+    }
+
+    val usBankAccount = PaymentMethodCreateParams.USBankAccount(
+      accountNumber,
+      routingNumber,
+      mapToUSBankAccountType(
+        getValOr(
+          params,
+          "accountType",
+          null)),
+      mapToUSBankAccountHolderType(
+        getValOr(
+          params,
+          "accountHolderType",
+          null))
+    )
+
+    return PaymentMethodCreateParams.Companion.create(
+      usBankAccount,
+      billingDetailsParams,
+      null
+    )
+  }
 }
 
 class PaymentMethodCreateParamsException(message: String) : Exception(message)

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

@@ -8,7 +8,6 @@ class StripeContainerManager : ViewGroupManager<StripeContainerView>() {
   override fun getName() = "StripeContainer"
 
   @ReactProp(name = "keyboardShouldPersistTaps")
-  @SuppressWarnings("unused")
   fun setKeyboardShouldPersistTaps(view: StripeContainerView, keyboardShouldPersistTaps: Boolean) {
     view.setKeyboardShouldPersistTaps(keyboardShouldPersistTaps)
   }

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

@@ -7,15 +7,16 @@ import android.content.Intent
 import android.content.IntentFilter
 import android.os.Parcelable
 import android.util.Log
-import androidx.activity.ComponentActivity
 import androidx.appcompat.app.AppCompatActivity
 import androidx.localbroadcastmanager.content.LocalBroadcastManager
 import com.facebook.react.bridge.*
 import com.facebook.react.module.annotations.ReactModule
 import com.stripe.android.*
+import com.stripe.android.core.AppInfo
 import com.stripe.android.googlepaylauncher.GooglePayLauncher
 import com.stripe.android.googlepaylauncher.GooglePayPaymentMethodLauncher
 import com.stripe.android.model.*
+import com.stripe.android.payments.bankaccount.CollectBankAccountConfiguration
 import com.stripe.android.paymentsheet.PaymentSheetResult
 import com.stripe.android.view.AddPaymentMethodActivityStarter
 import kotlinx.coroutines.CoroutineScope
@@ -23,7 +24,7 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 
 @ReactModule(name = StripeSdkModule.NAME)
-class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+class StripeSdkModule(private val reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
   var cardFieldView: CardFieldView? = null
   var cardFormView: CardFormView? = null
 
@@ -40,7 +41,6 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
 
   private var urlScheme: String? = null
   private var confirmPromise: Promise? = null
-  private var confirmSetupIntentPromise: Promise? = null
   private var confirmPaymentSheetPaymentPromise: Promise? = null
   private var presentPaymentSheetPromise: Promise? = null
   private var initPaymentSheetPromise: Promise? = null
@@ -53,34 +53,8 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   private val mActivityEventListener = object : BaseActivityEventListener() {
     override fun onActivityResult(activity: Activity, requestCode: Int, resultCode: Int, data: Intent?) {
       if (::stripe.isInitialized) {
-        stripe.onSetupResult(requestCode, data, object : ApiResultCallback<SetupIntentResult> {
-          override fun onSuccess(result: SetupIntentResult) {
-            val setupIntent = result.intent
-            when (setupIntent.status) {
-              StripeIntent.Status.Succeeded -> {
-                confirmSetupIntentPromise?.resolve(createResult("setupIntent", mapFromSetupIntentResult(setupIntent)))
-              }
-              StripeIntent.Status.Canceled -> {
-                confirmSetupIntentPromise?.resolve(createError(ConfirmSetupIntentErrorType.Canceled.toString(), setupIntent.lastSetupError))
-              }
-              StripeIntent.Status.RequiresAction -> {
-                confirmSetupIntentPromise?.resolve(createError(ConfirmSetupIntentErrorType.Canceled.toString(), setupIntent.lastSetupError))
-              }
-              else -> {
-                val errorMessage = "unhandled error: ${setupIntent.status}"
-                confirmSetupIntentPromise?.resolve(createError(ConfirmSetupIntentErrorType.Failed.toString(), errorMessage))
-              }
-            }
-          }
-
-          override fun onError(e: Exception) {
-            confirmSetupIntentPromise?.resolve(createError(ConfirmSetupIntentErrorType.Failed.toString(), e))
-          }
-        })
-
         paymentSheetFragment?.activity?.activityResultRegistry?.dispatchResult(requestCode, resultCode, data)
         googlePayFragment?.activity?.activityResultRegistry?.dispatchResult(requestCode, resultCode, data)
-
         try {
           val result = AddPaymentMethodActivityStarter.Result.fromIntent(data)
           if (data?.getParcelableExtra<Parcelable>("extra_activity_result") != null) {
@@ -115,16 +89,17 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
 
   private val googlePayReceiver: BroadcastReceiver = object : BroadcastReceiver() {
     override fun onReceive(context: Context?, intent: Intent) {
-      if (intent.action == ON_GOOGLE_PAY_FRAGMENT_CREATED) {
-        googlePayFragment = (currentActivity as AppCompatActivity).supportFragmentManager.findFragmentByTag("google_pay_launch_fragment") as GooglePayFragment
-      }
       if (intent.action == ON_INIT_GOOGLE_PAY) {
         val isReady = intent.extras?.getBoolean("isReady") ?: false
-
         if (isReady) {
           initGooglePayPromise?.resolve(WritableNativeMap())
         } else {
-          initGooglePayPromise?.resolve(createError(GooglePayErrorType.Failed.toString(), "Google Pay is not available on this device"))
+          initGooglePayPromise?.resolve(
+            createError(
+              GooglePayErrorType.Failed.toString(),
+              "Google Pay is not available on this device. You can use isGooglePaySupported to preemptively check for Google Pay support."
+            )
+          )
         }
       }
       if (intent.action == ON_GOOGLE_PAYMENT_METHOD_RESULT) {
@@ -215,7 +190,6 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   }
 
   @ReactMethod
-  @SuppressWarnings("unused")
   fun initialise(params: ReadableMap, promise: Promise) {
     val publishableKey = getValOr(params, "publishableKey", null) as String
     val appInfo = getMapOrNull(params, "appInfo") as ReadableMap
@@ -241,77 +215,78 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
     PaymentConfiguration.init(reactApplicationContext, publishableKey, stripeAccountId)
 
     paymentLauncherFragment = PaymentLauncherFragment(stripe, publishableKey, stripeAccountId)
-    (currentActivity as AppCompatActivity).supportFragmentManager.beginTransaction()
-      .add(paymentLauncherFragment, "payment_launcher_fragment")
-      .commit()
-
-    val localBroadcastManager = LocalBroadcastManager.getInstance(reactApplicationContext)
-    localBroadcastManager.registerReceiver(mPaymentSheetReceiver, IntentFilter(ON_PAYMENT_RESULT_ACTION))
-    localBroadcastManager.registerReceiver(mPaymentSheetReceiver, IntentFilter(ON_PAYMENT_OPTION_ACTION))
-    localBroadcastManager.registerReceiver(mPaymentSheetReceiver, IntentFilter(ON_CONFIGURE_FLOW_CONTROLLER))
-    localBroadcastManager.registerReceiver(mPaymentSheetReceiver, IntentFilter(ON_INIT_PAYMENT_SHEET))
-
-    localBroadcastManager.registerReceiver(googlePayReceiver, IntentFilter(ON_GOOGLE_PAY_FRAGMENT_CREATED))
-    localBroadcastManager.registerReceiver(googlePayReceiver, IntentFilter(ON_INIT_GOOGLE_PAY))
-    localBroadcastManager.registerReceiver(googlePayReceiver, IntentFilter(ON_GOOGLE_PAY_RESULT))
-    localBroadcastManager.registerReceiver(googlePayReceiver, IntentFilter(ON_GOOGLE_PAYMENT_METHOD_RESULT))
-
-    promise.resolve(null)
+    getCurrentActivityOrResolveWithError(promise)?.let {
+      it.supportFragmentManager.beginTransaction()
+        .add(paymentLauncherFragment, "payment_launcher_fragment")
+        .commit()
+
+      val localBroadcastManager = LocalBroadcastManager.getInstance(reactApplicationContext)
+      localBroadcastManager.registerReceiver(mPaymentSheetReceiver, IntentFilter(ON_PAYMENT_RESULT_ACTION))
+      localBroadcastManager.registerReceiver(mPaymentSheetReceiver, IntentFilter(ON_PAYMENT_OPTION_ACTION))
+      localBroadcastManager.registerReceiver(mPaymentSheetReceiver, IntentFilter(ON_CONFIGURE_FLOW_CONTROLLER))
+      localBroadcastManager.registerReceiver(mPaymentSheetReceiver, IntentFilter(ON_INIT_PAYMENT_SHEET))
+
+      localBroadcastManager.registerReceiver(googlePayReceiver, IntentFilter(ON_INIT_GOOGLE_PAY))
+      localBroadcastManager.registerReceiver(googlePayReceiver, IntentFilter(ON_GOOGLE_PAY_RESULT))
+      localBroadcastManager.registerReceiver(googlePayReceiver, IntentFilter(ON_GOOGLE_PAYMENT_METHOD_RESULT))
+
+      promise.resolve(null)
+    }
   }
 
   @ReactMethod
-  @SuppressWarnings("unused")
   fun initPaymentSheet(params: ReadableMap, promise: Promise) {
-    val activity = currentActivity as AppCompatActivity?
+    getCurrentActivityOrResolveWithError(promise)?.let { activity ->
+      this.initPaymentSheetPromise = promise
 
-    if (activity == null) {
-      promise.resolve(createError("Failed", "Activity doesn't exist"))
-      return
-    }
-
-    this.initPaymentSheetPromise = promise
-
-    paymentSheetFragment = PaymentSheetFragment().also {
-      val bundle = toBundleObject(params)
-      it.arguments = bundle
+      paymentSheetFragment = PaymentSheetFragment().also {
+        val bundle = toBundleObject(params)
+        it.arguments = bundle
+      }
+      activity.supportFragmentManager.beginTransaction()
+        .add(paymentSheetFragment!!, "payment_sheet_launch_fragment")
+        .commit()
     }
-    activity.supportFragmentManager.beginTransaction()
-      .add(paymentSheetFragment!!, "payment_sheet_launch_fragment")
-      .commit()
   }
 
   @ReactMethod
-  @SuppressWarnings("unused")
   fun presentPaymentSheet(promise: Promise) {
     this.presentPaymentSheetPromise = promise
     paymentSheetFragment?.present()
   }
 
   @ReactMethod
-  @SuppressWarnings("unused")
   fun confirmPaymentSheetPayment(promise: Promise) {
     this.confirmPaymentSheetPaymentPromise = promise
     paymentSheetFragment?.confirmPayment()
   }
 
   private fun payWithFpx() {
-    AddPaymentMethodActivityStarter(currentActivity as AppCompatActivity)
-      .startForResult(
-        AddPaymentMethodActivityStarter.Args.Builder()
-          .setPaymentMethodType(PaymentMethod.Type.Fpx)
-          .build()
-      )
+    getCurrentActivityOrResolveWithError(confirmPromise)?.let {
+      AddPaymentMethodActivityStarter(it)
+        .startForResult(AddPaymentMethodActivityStarter.Args.Builder()
+                          .setPaymentMethodType(PaymentMethod.Type.Fpx)
+                          .build()
+        )
+    }
   }
 
   private fun onFpxPaymentMethodResult(result: AddPaymentMethodActivityStarter.Result) {
     when (result) {
       is AddPaymentMethodActivityStarter.Result.Success -> {
-        paymentLauncherFragment.paymentLauncher.confirm(
-          ConfirmPaymentIntentParams.createWithPaymentMethodId(
-            result.paymentMethod.id!!,
-            confirmPaymentClientSecret!!
+        if (confirmPaymentClientSecret != null && confirmPromise != null) {
+          paymentLauncherFragment.confirm(
+            ConfirmPaymentIntentParams.createWithPaymentMethodId(
+              result.paymentMethod.id!!,
+              confirmPaymentClientSecret!!
+            ),
+            confirmPaymentClientSecret!!,
+            confirmPromise!!
           )
-        )
+        } else {
+          Log.e("StripeReactNative", "FPX payment failed. Promise and/or client secret is not set.")
+          confirmPromise?.resolve(createError(ConfirmPaymentErrorType.Failed.toString(), "FPX payment failed."))
+        }
       }
       is AddPaymentMethodActivityStarter.Result.Failure -> {
         confirmPromise?.resolve(createError(ConfirmPaymentErrorType.Failed.toString(), result.exception))
@@ -321,10 +296,10 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
       }
     }
     this.confirmPaymentClientSecret = null
+    this.confirmPromise = null
   }
 
   @ReactMethod
-  @SuppressWarnings("unused")
   fun createPaymentMethod(data: ReadableMap, options: ReadableMap, promise: Promise) {
     val cardParams = (cardFieldView?.cardParams ?: cardFormView?.cardParams) ?: run {
       promise.resolve(createError("Failed", "Card details not complete"))
@@ -350,7 +325,6 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   }
 
   @ReactMethod
-  @SuppressWarnings("unused")
   fun createToken(params: ReadableMap, promise: Promise) {
     val type = getValOr(params, "type", null)
     if (type == null) {
@@ -431,7 +405,6 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   }
 
   @ReactMethod
-  @SuppressWarnings("unused")
   fun createTokenForCVCUpdate(cvc: String, promise: Promise) {
     stripe.createCvcUpdateToken(
       cvc,
@@ -451,11 +424,11 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   }
 
   @ReactMethod
-  @SuppressWarnings("unused")
   fun handleNextAction(paymentIntentClientSecret: String, promise: Promise) {
-    paymentLauncherFragment.clientSecret = paymentIntentClientSecret
-    paymentLauncherFragment.promise = promise
-    paymentLauncherFragment.paymentLauncher.handleNextActionForPaymentIntent(paymentIntentClientSecret)
+    paymentLauncherFragment.handleNextActionForPaymentIntent(
+      paymentIntentClientSecret,
+      promise
+    )
   }
 
 // TODO: Uncomment when WeChat is re-enabled in stripe-ios
@@ -478,20 +451,17 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
 //  }
 
   @ReactMethod
-  @SuppressWarnings("unused")
   fun confirmPayment(paymentIntentClientSecret: String, params: ReadableMap, options: ReadableMap, promise: Promise) {
     val paymentMethodType = getValOr(params, "type")?.let { mapToPaymentMethodType(it) } ?: run {
       promise.resolve(createError(ConfirmPaymentErrorType.Failed.toString(), "You must provide paymentMethodType"))
       return
     }
 
-    paymentLauncherFragment.clientSecret = paymentIntentClientSecret
-    paymentLauncherFragment.promise = promise
-
     val testOfflineBank = getBooleanOrFalse(params, "testOfflineBank")
 
     if (paymentMethodType == PaymentMethod.Type.Fpx && !testOfflineBank) {
       confirmPaymentClientSecret = paymentIntentClientSecret
+      confirmPromise = promise
       payWithFpx()
       return
     }
@@ -501,7 +471,7 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
 //        promise.resolve(createError("Failed", "You must provide appId"))
 //        return
 //      }
-//      payWithWeChatPay(paymentIntentClientSecret, appId)
+//      payWithWeChatPay(paymentIntentClientSecret, appId, promise)
 //
 //      return
 //    }
@@ -514,14 +484,17 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
         confirmParams.returnUrl = mapToReturnURL(urlScheme)
       }
       confirmParams.shipping = mapToShippingDetails(getMapOrNull(params, "shippingDetails"))
-      paymentLauncherFragment.paymentLauncher.confirm(confirmParams)
+      paymentLauncherFragment.confirm(
+        confirmParams,
+        paymentIntentClientSecret,
+        promise
+      )
     } catch (error: PaymentMethodCreateParamsException) {
       promise.resolve(createError(ConfirmPaymentErrorType.Failed.toString(), error))
     }
   }
 
   @ReactMethod
-  @SuppressWarnings("unused")
   fun retrievePaymentIntent(clientSecret: String, promise: Promise) {
     CoroutineScope(Dispatchers.IO).launch {
       val paymentIntent = stripe.retrievePaymentIntentSynchronous(clientSecret)
@@ -534,7 +507,6 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   }
 
   @ReactMethod
-  @SuppressWarnings("unused")
   fun retrieveSetupIntent(clientSecret: String, promise: Promise) {
     CoroutineScope(Dispatchers.IO).launch {
       val setupIntent = stripe.retrieveSetupIntentSynchronous(clientSecret)
@@ -547,10 +519,7 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   }
 
   @ReactMethod
-  @SuppressWarnings("unused")
   fun confirmSetupIntent(setupIntentClientSecret: String, params: ReadableMap, options: ReadableMap, promise: Promise) {
-    confirmSetupIntentPromise = promise
-
     val paymentMethodType = getValOr(params, "type")?.let { mapToPaymentMethodType(it) } ?: run {
       promise.resolve(createError(ConfirmPaymentErrorType.Failed.toString(), "You must provide paymentMethodType"))
       return
@@ -559,50 +528,53 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
     val factory = PaymentMethodCreateParamsFactory(setupIntentClientSecret, params, cardFieldView, cardFormView)
 
     try {
-      val activity = currentActivity as ComponentActivity
       val confirmParams = factory.createSetupParams(paymentMethodType)
       urlScheme?.let {
         confirmParams.returnUrl = mapToReturnURL(urlScheme)
       }
-      stripe.confirmSetupIntent(activity, confirmParams)
+      paymentLauncherFragment.confirm(
+        confirmParams,
+        setupIntentClientSecret,
+        promise
+      )
     } catch (error: PaymentMethodCreateParamsException) {
       promise.resolve(createError(ConfirmPaymentErrorType.Failed.toString(), error))
     }
   }
 
   @ReactMethod
-  @SuppressWarnings("unused")
   fun isGooglePaySupported(params: ReadableMap?, promise: Promise) {
     val fragment = GooglePayPaymentMethodLauncherFragment(
-      currentActivity as AppCompatActivity,
+      reactContext,
       getBooleanOrFalse(params, "testEnv"),
       getBooleanOrFalse(params, "existingPaymentMethodRequired"),
       promise
     )
 
-    (currentActivity as AppCompatActivity).supportFragmentManager.beginTransaction()
-      .add(fragment, "google_pay_support_fragment")
-      .commit()
+    getCurrentActivityOrResolveWithError(promise)?.let {
+      it.supportFragmentManager.beginTransaction()
+        .add(fragment, "google_pay_support_fragment")
+        .commit()
+    }
   }
 
   @ReactMethod
-  @SuppressWarnings("unused")
   fun initGooglePay(params: ReadableMap, promise: Promise) {
-    val activity = currentActivity as AppCompatActivity
-    val fragment = GooglePayFragment().also {
+    googlePayFragment = GooglePayFragment().also {
       val bundle = toBundleObject(params)
       it.arguments = bundle
     }
 
-    initGooglePayPromise = promise
+    getCurrentActivityOrResolveWithError(promise)?.let {
+      initGooglePayPromise = promise
 
-    activity.supportFragmentManager.beginTransaction()
-      .add(fragment, "google_pay_launch_fragment")
-      .commit()
+      it.supportFragmentManager.beginTransaction()
+        .add(googlePayFragment!!, "google_pay_launch_fragment")
+        .commit()
+    }
   }
 
   @ReactMethod
-  @SuppressWarnings("unused")
   fun presentGooglePay(params: ReadableMap, promise: Promise) {
     val clientSecret = getValOr(params, "clientSecret") ?: run {
       promise.resolve(createError(GooglePayErrorType.Failed.toString(), "you must provide clientSecret"))
@@ -621,7 +593,6 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   }
 
   @ReactMethod
-  @SuppressWarnings("unused")
   fun createGooglePayPaymentMethod(params: ReadableMap, promise: Promise) {
     val currencyCode = getValOr(params, "currencyCode", null) ?: run {
       promise.resolve(createError(GooglePayErrorType.Failed.toString(), "you must provide currencyCode"))
@@ -635,6 +606,121 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
     googlePayFragment?.createPaymentMethod(currencyCode, amount)
   }
 
+  @ReactMethod
+  fun collectBankAccount(isPaymentIntent: Boolean, clientSecret: String, params: ReadableMap, promise: Promise) {
+    val paymentMethodType = mapToPaymentMethodType(getValOr(params, "type", null))
+    if (paymentMethodType != PaymentMethod.Type.USBankAccount) {
+      promise.resolve(createError(ErrorType.Failed.toString(), "collectBankAccount currently only accepts the USBankAccount payment method type."))
+      return
+    }
+
+    val billingDetails = getMapOrNull(params, "billingDetails")
+
+    val name = billingDetails?.getString("name")
+    if (name.isNullOrEmpty()) {
+      promise.resolve(createError(ErrorType.Failed.toString(), "You must provide a name when collecting US bank account details."))
+      return
+    }
+
+    val collectParams = CollectBankAccountConfiguration.USBankAccount(
+      name,
+      billingDetails.getString("email")
+    )
+
+    val fragment = CollectBankAccountLauncherFragment(
+      reactContext,
+      publishableKey,
+      clientSecret,
+      isPaymentIntent,
+      collectParams,
+      promise
+    )
+    getCurrentActivityOrResolveWithError(promise)?.let {
+      it.supportFragmentManager.beginTransaction()
+        .add(fragment, "collect_bank_account_launcher_fragment")
+        .commit()
+    }
+  }
+
+  @ReactMethod
+  fun verifyMicrodeposits(isPaymentIntent: Boolean, clientSecret: String, params: ReadableMap, promise: Promise) {
+    val amounts = params.getArray("amounts")
+    val descriptorCode = params.getString("descriptorCode")
+
+    if ((amounts != null && descriptorCode != null) || (amounts == null && descriptorCode == null)) {
+      promise.resolve(createError(ErrorType.Failed.toString(), "You must provide either amounts OR descriptorCode, not both."))
+      return
+    }
+
+    val paymentCallback = object : ApiResultCallback<PaymentIntent> {
+      override fun onError(e: Exception) {
+        promise.resolve(createError(ErrorType.Failed.toString(), e))
+      }
+
+      override fun onSuccess(result: PaymentIntent) {
+        promise.resolve(createResult("paymentIntent", mapFromPaymentIntentResult(result)))
+      }
+    }
+    val setupCallback = object : ApiResultCallback<SetupIntent> {
+      override fun onError(e: Exception) {
+        promise.resolve(createError(ErrorType.Failed.toString(), e))
+      }
+
+      override fun onSuccess(result: SetupIntent) {
+        promise.resolve(createResult("setupIntent", mapFromSetupIntentResult(result)))
+      }
+    }
+
+    amounts?.let {
+      if (it.size() != 2) {
+        promise.resolve(createError(ErrorType.Failed.toString(), "Expected 2 integers in the amounts array, but received ${it.size()}"))
+        return
+      }
+
+      if (isPaymentIntent) {
+        stripe.verifyPaymentIntentWithMicrodeposits(
+          clientSecret,
+          it.getInt(0),
+          it.getInt(1),
+          paymentCallback
+        )
+      } else {
+        stripe.verifySetupIntentWithMicrodeposits(
+          clientSecret,
+          it.getInt(0),
+          it.getInt(1),
+          setupCallback
+        )
+      }
+    } ?: descriptorCode?.let {
+      if (isPaymentIntent) {
+        stripe.verifyPaymentIntentWithMicrodeposits(
+          clientSecret,
+          it,
+          paymentCallback
+        )
+      } else {
+        stripe.verifySetupIntentWithMicrodeposits(
+          clientSecret,
+          it,
+          setupCallback
+        )
+      }
+    }
+  }
+
+  /**
+   * 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?): AppCompatActivity? {
+    (currentActivity as? AppCompatActivity)?.let {
+      return it
+    }
+    promise?.resolve(createMissingActivityError())
+    return null
+  }
+
   companion object {
     const val NAME = "StripeSdk"
   }