@stripe/stripe-react-native 0.16.0 → 0.17.0

package/.husky/pre-commit

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+yarn lint && yarn typescript

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## Unreleased
 
+## 0.17.0 - 2022-08-11
+
+### Breaking changes
+
+### New features
+
+- Added the [`collectBankAccountToken`](https://stripe.com/docs/financial-connections/connect-payouts?platform=react-native) & [`collectFinancialConnectionsAccounts`](https://stripe.com/docs/financial-connections/other-data-powered-products?platform=react-native) functions.
+
+### Fixes
+
+- Fixed an issue where `collectBankAccountForPayment` and `collectBankAccountForSetup` would fail on Android when using React Native 0.65.x or under. [#1059](https://github.com/stripe/stripe-react-native/pull/1059)
+- Fixed an issue where Android apps could crash with the error `IllegalStateException: Cannot remove Fragment attached to a different FragmentManager`. [#1054](https://github.com/stripe/stripe-react-native/pull/1054)
+- Bumped Gradle from 4.2.2 to 7.1.1. [#1058](https://github.com/stripe/stripe-react-native/pull/1058)
+
 ## 0.16.0 - 2022-07-22
 
 ### Breaking changes

package/android/build.gradle

@@ -8,7 +8,7 @@ buildscript {
   }
 
   dependencies {
-    classpath 'com.android.tools.build:gradle:4.2.2'
+    classpath 'com.android.tools.build:gradle:7.1.1'
     // noinspection DifferentKotlinGradleVersion
     classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
   }

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

@@ -83,7 +83,11 @@ class CollectBankAccountLauncherFragment(
           promise.resolve(createError(ErrorType.Failed.toString(), result.error))
         }
       }
-      (context.currentActivity as? AppCompatActivity)?.supportFragmentManager?.beginTransaction()?.remove(this)?.commitAllowingStateLoss()
+      removeFragment(context)
     }
   }
+
+  companion object {
+    const val TAG = "collect_bank_account_launcher_fragment"
+  }
 }

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

@@ -0,0 +1,284 @@
+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.*
+import com.reactnativestripesdk.utils.*
+import com.reactnativestripesdk.utils.createError
+import com.reactnativestripesdk.utils.createMissingActivityError
+import com.reactnativestripesdk.utils.createResult
+import com.reactnativestripesdk.utils.mapFromToken
+import com.stripe.android.financialconnections.FinancialConnectionsSheet
+import com.stripe.android.financialconnections.FinancialConnectionsSheetForTokenResult
+import com.stripe.android.financialconnections.FinancialConnectionsSheetResult
+import com.stripe.android.financialconnections.FinancialConnectionsSheetResultCallback
+import com.stripe.android.financialconnections.model.*
+
+class FinancialConnectionsSheetFragment : Fragment() {
+  enum class Mode {
+    ForToken, ForSession
+  }
+
+  private lateinit var promise: Promise
+  private lateinit var context: ReactApplicationContext
+  private lateinit var clientSecret: String
+  private lateinit var publishableKey: String
+  private lateinit var mode: Mode
+
+  override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?,
+                            savedInstanceState: Bundle?): View {
+    return FrameLayout(requireActivity()).also {
+      it.visibility = View.GONE
+    }
+  }
+
+  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+    when (mode) {
+      Mode.ForToken -> {
+        FinancialConnectionsSheet.createForBankAccountToken(
+          this,
+          ::onFinancialConnectionsSheetForTokenResult
+        ).present(
+          configuration = FinancialConnectionsSheet.Configuration(
+            financialConnectionsSessionClientSecret = clientSecret,
+            publishableKey = publishableKey
+          )
+        )
+      }
+      Mode.ForSession -> {
+        FinancialConnectionsSheet.create(
+          this,
+          ::onFinancialConnectionsSheetForDataResult
+        ).present(
+          configuration = FinancialConnectionsSheet.Configuration(
+            financialConnectionsSessionClientSecret = clientSecret,
+            publishableKey = publishableKey
+          )
+        )
+      }
+    }
+  }
+
+  private fun onFinancialConnectionsSheetForTokenResult(result: FinancialConnectionsSheetForTokenResult) {
+    when(result) {
+      is FinancialConnectionsSheetForTokenResult.Canceled -> {
+        promise.resolve(
+          createError(ErrorType.Canceled.toString(), "The flow has been canceled")
+        )
+      }
+      is FinancialConnectionsSheetForTokenResult.Failed -> {
+        promise.resolve(
+          createError(ErrorType.Failed.toString(), result.error)
+        )
+      }
+      is FinancialConnectionsSheetForTokenResult.Completed -> {
+        promise.resolve(createTokenResult(result))
+        (context.currentActivity as? AppCompatActivity)?.supportFragmentManager?.beginTransaction()?.remove(this)?.commitAllowingStateLoss()
+      }
+    }
+  }
+
+  private fun onFinancialConnectionsSheetForDataResult(result: FinancialConnectionsSheetResult) {
+    when(result) {
+      is FinancialConnectionsSheetResult.Canceled -> {
+        promise.resolve(
+          createError(ErrorType.Canceled.toString(), "The flow has been canceled")
+        )
+      }
+      is FinancialConnectionsSheetResult.Failed -> {
+        promise.resolve(
+          createError(ErrorType.Failed.toString(), result.error)
+        )
+      }
+      is FinancialConnectionsSheetResult.Completed -> {
+        promise.resolve(
+            WritableNativeMap().also {
+              it.putMap("session", mapFromSession(result.financialConnectionsSession))
+            }
+        )
+        (context.currentActivity as? AppCompatActivity)?.supportFragmentManager?.beginTransaction()?.remove(this)?.commitAllowingStateLoss()
+      }
+    }
+  }
+
+  fun presentFinancialConnectionsSheet(clientSecret: String, mode: Mode, publishableKey: String, promise: Promise, context: ReactApplicationContext) {
+    this.promise = promise
+    this.context = context
+    this.clientSecret = clientSecret
+    this.publishableKey = publishableKey
+    this.mode = mode
+
+    (context.currentActivity as? AppCompatActivity)?.let {
+      attemptToCleanupPreviousFragment(it)
+      commitFragmentAndStartFlow(it)
+    } ?: run {
+      promise.resolve(createMissingActivityError())
+      return
+    }
+  }
+
+  private fun attemptToCleanupPreviousFragment(currentActivity: AppCompatActivity) {
+    currentActivity.supportFragmentManager.beginTransaction()
+      .remove(this)
+      .commitAllowingStateLoss()
+  }
+
+  private fun commitFragmentAndStartFlow(currentActivity: AppCompatActivity) {
+    try {
+      currentActivity.supportFragmentManager.beginTransaction()
+        .add(this, "financial_connections_sheet_launch_fragment")
+        .commit()
+    } catch (error: IllegalStateException) {
+      promise.resolve(createError(ErrorType.Failed.toString(), error.message))
+    }
+  }
+
+  companion object {
+    private fun createTokenResult(result: FinancialConnectionsSheetForTokenResult.Completed): WritableMap {
+      return WritableNativeMap().also {
+        it.putMap("session", mapFromSession(result.financialConnectionsSession))
+        it.putMap("token", mapFromToken(result.token))
+      }
+    }
+
+    private fun mapFromSession(financialConnectionsSession: FinancialConnectionsSession): WritableMap {
+      val session = WritableNativeMap()
+      session.putString("id", financialConnectionsSession.id)
+      session.putString("clientSecret", financialConnectionsSession.clientSecret)
+      session.putBoolean("livemode", financialConnectionsSession.livemode)
+      session.putArray("accounts", mapFromAccountsList(financialConnectionsSession.accounts))
+      return session
+    }
+
+    private fun mapFromAccountsList(accounts: FinancialConnectionsAccountList): ReadableArray {
+      val results: WritableArray = Arguments.createArray()
+      for (account in accounts.data) {
+        val map = WritableNativeMap()
+        map.putString("id", account.id)
+        map.putBoolean("livemode", account.livemode)
+        map.putString("displayName", account.displayName)
+        map.putString("status", mapFromStatus(account.status))
+        map.putString("institutionName", account.institutionName)
+        map.putString("last4", account.last4)
+        map.putDouble("created", account.created * 1000.0)
+        map.putMap("balance", mapFromAccountBalance(account.balance))
+        map.putMap("balanceRefresh", mapFromAccountBalanceRefresh(account.balanceRefresh))
+        map.putString("category", mapFromCategory(account.category))
+        map.putString("subcategory", mapFromSubcategory(account.subcategory))
+        map.putArray("permissions", (account.permissions?.map { permission -> mapFromPermission(permission) })?.toReadableArray())
+        map.putArray("supportedPaymentMethodTypes", (account.supportedPaymentMethodTypes.map { type -> mapFromSupportedPaymentMethodTypes(type) }).toReadableArray())
+        results.pushMap(map)
+      }
+      return results
+    }
+
+    private fun mapFromAccountBalance(balance: Balance?): WritableMap? {
+      if (balance == null) {
+        return null
+      }
+      val map = WritableNativeMap()
+      map.putDouble("asOf", balance.asOf * 1000.0)
+      map.putString("type", mapFromBalanceType(balance.type))
+      map.putMap("current", balance.current as ReadableMap)
+      WritableNativeMap().also {
+        it.putMap("available", balance.cash?.available as ReadableMap)
+        map.putMap("cash", it)
+      }
+      WritableNativeMap().also {
+        it.putMap("used", balance.credit?.used as ReadableMap)
+        map.putMap("credit", it)
+      }
+      return map
+    }
+
+    private fun mapFromAccountBalanceRefresh(balanceRefresh: BalanceRefresh?): WritableMap? {
+      if (balanceRefresh == null) {
+        return null
+      }
+      val map = WritableNativeMap()
+      map.putString("status", mapFromBalanceRefreshStatus(balanceRefresh.status))
+      map.putDouble("lastAttemptedAt", balanceRefresh.lastAttemptedAt * 1000.0)
+      return map
+    }
+
+    private fun mapFromStatus(status: FinancialConnectionsAccount.Status): String {
+      return when (status) {
+        FinancialConnectionsAccount.Status.ACTIVE -> "active"
+        FinancialConnectionsAccount.Status.DISCONNECTED -> "disconnected"
+        FinancialConnectionsAccount.Status.INACTIVE -> "inactive"
+        FinancialConnectionsAccount.Status.UNKNOWN -> "unparsable"
+      }
+    }
+
+    private fun mapFromCategory(category: FinancialConnectionsAccount.Category): String {
+      return when (category) {
+        FinancialConnectionsAccount.Category.CASH -> "cash"
+        FinancialConnectionsAccount.Category.CREDIT -> "credit"
+        FinancialConnectionsAccount.Category.INVESTMENT -> "investment"
+        FinancialConnectionsAccount.Category.OTHER -> "other"
+        FinancialConnectionsAccount.Category.UNKNOWN -> "unparsable"
+      }
+    }
+
+    private fun mapFromSubcategory(subcategory: FinancialConnectionsAccount.Subcategory): String {
+      return when (subcategory) {
+        FinancialConnectionsAccount.Subcategory.CHECKING -> "checking"
+        FinancialConnectionsAccount.Subcategory.CREDIT_CARD -> "creditCard"
+        FinancialConnectionsAccount.Subcategory.LINE_OF_CREDIT -> "lineOfCredit"
+        FinancialConnectionsAccount.Subcategory.MORTGAGE -> "mortgage"
+        FinancialConnectionsAccount.Subcategory.OTHER -> "other"
+        FinancialConnectionsAccount.Subcategory.SAVINGS -> "savings"
+        FinancialConnectionsAccount.Subcategory.UNKNOWN -> "unparsable"
+      }
+    }
+
+    private fun mapFromPermission(permission: FinancialConnectionsAccount.Permissions): String {
+      return when (permission) {
+        FinancialConnectionsAccount.Permissions.PAYMENT_METHOD -> "paymentMethod"
+        FinancialConnectionsAccount.Permissions.BALANCES -> "balances"
+        FinancialConnectionsAccount.Permissions.OWNERSHIP -> "ownership"
+        FinancialConnectionsAccount.Permissions.TRANSACTIONS -> "transactions"
+        FinancialConnectionsAccount.Permissions.UNKNOWN -> "unparsable"
+      }
+    }
+
+    private fun mapFromSupportedPaymentMethodTypes(type: FinancialConnectionsAccount.SupportedPaymentMethodTypes): String {
+      return when (type) {
+        FinancialConnectionsAccount.SupportedPaymentMethodTypes.US_BANK_ACCOUNT -> "usBankAccount"
+        FinancialConnectionsAccount.SupportedPaymentMethodTypes.LINK -> "link"
+        FinancialConnectionsAccount.SupportedPaymentMethodTypes.UNKNOWN -> "unparsable"
+      }
+    }
+
+    private fun mapFromBalanceType(type: Balance.Type): String {
+      return when (type) {
+        Balance.Type.CASH -> "cash"
+        Balance.Type.CREDIT -> "credit"
+        Balance.Type.UNKNOWN -> "unparsable"
+      }
+    }
+
+    private fun mapFromBalanceRefreshStatus(status: BalanceRefresh.BalanceRefreshStatus?): String {
+      return when (status) {
+        BalanceRefresh.BalanceRefreshStatus.SUCCEEDED -> "succeeded"
+        BalanceRefresh.BalanceRefreshStatus.FAILED -> "failed"
+        BalanceRefresh.BalanceRefreshStatus.PENDING -> "pending"
+        BalanceRefresh.BalanceRefreshStatus.UNKNOWN -> "unparsable"
+        null -> "null"
+      }
+    }
+  }
+}
+
+fun List<String>.toReadableArray(): ReadableArray {
+  val results: WritableArray = Arguments.createArray()
+  for (s in this) {
+    results.pushString(s)
+  }
+  return results
+}

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

@@ -204,4 +204,8 @@ class GooglePayFragment(private val initPromise: Promise) : Fragment() {
       isPhoneNumberRequired = isPhoneNumberRequired
     )
   }
+
+  companion object {
+    const val TAG = "google_pay_launch_fragment"
+  }
 }

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

@@ -5,10 +5,10 @@ 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.reactnativestripesdk.utils.removeFragment
 import com.stripe.android.googlepaylauncher.GooglePayEnvironment
 import com.stripe.android.googlepaylauncher.GooglePayPaymentMethodLauncher
 
@@ -37,9 +37,13 @@ class GooglePayPaymentMethodLauncherFragment(
       ),
       readyCallback = {
         promise.resolve(it)
-        (context.currentActivity as? AppCompatActivity)?.supportFragmentManager?.beginTransaction()?.remove(this)?.commitAllowingStateLoss()
+        removeFragment(context)
       },
       resultCallback = {}
     )
   }
+
+  companion object {
+    const val TAG = "google_pay_support_fragment"
+  }
 }

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

@@ -110,7 +110,7 @@ class PaymentLauncherFragment(
       (context.currentActivity as? AppCompatActivity)?.let {
         try {
           it.supportFragmentManager.beginTransaction()
-            .add(fragment, "payment_launcher_fragment")
+            .add(fragment, TAG)
             .commit()
         } catch (error: IllegalStateException) {
           promise.resolve(createError(ErrorType.Failed.toString(), error.message))
@@ -119,6 +119,8 @@ class PaymentLauncherFragment(
         promise.resolve(createMissingActivityError())
       }
     }
+
+    const val TAG = "payment_launcher_fragment"
   }
 
   override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?,
@@ -154,25 +156,21 @@ class PaymentLauncherFragment(
         }
         is PaymentResult.Canceled -> {
           promise.resolve(createError(ConfirmPaymentErrorType.Canceled.toString(), message = null))
-          cleanup()
+          removeFragment(context)
         }
         is PaymentResult.Failed -> {
           promise.resolve(createError(ConfirmPaymentErrorType.Failed.toString(), paymentResult.throwable))
-          cleanup()
+          removeFragment(context)
         }
       }
     }
   }
 
-  private fun cleanup() {
-    (context.currentActivity as? AppCompatActivity)?.supportFragmentManager?.beginTransaction()?.remove(this)?.commitAllowingStateLoss()
-  }
-
   private fun retrieveSetupIntent(clientSecret: String, stripeAccountId: String?) {
     stripe.retrieveSetupIntent(clientSecret, stripeAccountId, object : ApiResultCallback<SetupIntent> {
       override fun onError(e: Exception) {
         promise.resolve(createError(ConfirmSetupIntentErrorType.Failed.toString(), e))
-        cleanup()
+        removeFragment(context)
       }
 
       override fun onSuccess(result: SetupIntent) {
@@ -204,7 +202,7 @@ class PaymentLauncherFragment(
             promise.resolve(createError(ConfirmSetupIntentErrorType.Unknown.toString(), "unhandled error: ${result.status}"))
           }
         }
-        cleanup()
+        removeFragment(context)
       }
     })
   }
@@ -213,7 +211,7 @@ class PaymentLauncherFragment(
     stripe.retrievePaymentIntent(clientSecret, stripeAccountId, object : ApiResultCallback<PaymentIntent> {
       override fun onError(e: Exception) {
         promise.resolve(createError(ConfirmPaymentErrorType.Failed.toString(), e))
-        cleanup()
+        removeFragment(context)
       }
 
       override fun onSuccess(result: PaymentIntent) {
@@ -245,7 +243,7 @@ class PaymentLauncherFragment(
             promise.resolve(createError(ConfirmPaymentErrorType.Unknown.toString(), "unhandled error: ${result.status}"))
           }
         }
-        cleanup()
+        removeFragment(context)
       }
     })
   }

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

@@ -95,7 +95,7 @@ class PaymentSheetFragment(
         is PaymentSheetResult.Completed -> {
           resolvePaymentResult(WritableNativeMap())
           // Remove the fragment now, we can be sure it won't be needed again if an intent is successful
-          (context.currentActivity as? AppCompatActivity)?.supportFragmentManager?.beginTransaction()?.remove(this)?.commitAllowingStateLoss()
+          removeFragment(context)
         }
       }
     }
@@ -196,6 +196,8 @@ class PaymentSheetFragment(
   }
 
   companion object {
+    const val TAG = "payment_sheet_launch_fragment"
+
     internal fun buildGooglePayConfig(params: Bundle?): PaymentSheet.GooglePayConfiguration? {
       if (params == null) {
         return null

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

@@ -5,6 +5,7 @@ import android.content.Intent
 import android.os.Parcelable
 import android.util.Log
 import androidx.appcompat.app.AppCompatActivity
+import androidx.fragment.app.Fragment
 import com.facebook.react.bridge.*
 import com.facebook.react.module.annotations.ReactModule
 import com.reactnativestripesdk.pushprovisioning.PushProvisioningProxy
@@ -39,6 +40,15 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   private var paymentSheetFragment: PaymentSheetFragment? = null
   private var googlePayFragment: GooglePayFragment? = null
   private var paymentLauncherFragment: PaymentLauncherFragment? = null
+  private var collectBankAccountLauncherFragment: CollectBankAccountLauncherFragment? = null
+  private var financialConnectionsSheetFragment: FinancialConnectionsSheetFragment? = null
+  private var allFragments : Array<Fragment?> = arrayOf(
+    paymentSheetFragment,
+    googlePayFragment,
+    paymentLauncherFragment,
+    collectBankAccountLauncherFragment,
+    financialConnectionsSheetFragment
+  )
 
   private var confirmPromise: Promise? = null
   private var confirmPaymentClientSecret: String? = null
@@ -46,11 +56,7 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   private val mActivityEventListener = object : BaseActivityEventListener() {
     override fun onActivityResult(activity: Activity, requestCode: Int, resultCode: Int, data: Intent?) {
       if (::stripe.isInitialized) {
-        // BEGIN - Necessary on older versions of React Native (~0.64 and below)
-        paymentSheetFragment?.activity?.activityResultRegistry?.dispatchResult(requestCode, resultCode, data)
-        googlePayFragment?.activity?.activityResultRegistry?.dispatchResult(requestCode, resultCode, data)
-        paymentLauncherFragment?.activity?.activityResultRegistry?.dispatchResult(requestCode, resultCode, data)
-        // END
+        dispatchActivityResultsToFragments(requestCode, resultCode, data)
         try {
           val result = AddPaymentMethodActivityStarter.Result.fromIntent(data)
           if (data?.getParcelableExtra<Parcelable>("extra_activity_result") != null) {
@@ -67,6 +73,13 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
     reactContext.addActivityEventListener(mActivityEventListener)
   }
 
+  // Necessary on older versions of React Native (~0.65 and below)
+  private fun dispatchActivityResultsToFragments(requestCode: Int, resultCode: Int, data: Intent?) {
+    for (fragment in allFragments) {
+      fragment?.activity?.activityResultRegistry?.dispatchResult(requestCode, resultCode, data)
+    }
+  }
+
   private fun configure3dSecure(params: ReadableMap) {
     val stripe3dsConfigBuilder = PaymentAuthConfig.Stripe3ds2Config.Builder()
     if (params.hasKey("timeout")) stripe3dsConfigBuilder.setTimeout(params.getInt("timeout"))
@@ -121,17 +134,14 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   @ReactMethod
   fun initPaymentSheet(params: ReadableMap, promise: Promise) {
     getCurrentActivityOrResolveWithError(promise)?.let { activity ->
-      paymentSheetFragment?.let {
-        // If a payment sheet was already initialized, we want to remove its fragment first
-        activity.supportFragmentManager.beginTransaction().remove(it).commitAllowingStateLoss()
-      }
+      paymentSheetFragment?.removeFragment(reactApplicationContext)
       paymentSheetFragment = PaymentSheetFragment(reactApplicationContext, promise).also {
         val bundle = toBundleObject(params)
         it.arguments = bundle
       }
       try {
         activity.supportFragmentManager.beginTransaction()
-          .add(paymentSheetFragment!!, "payment_sheet_launch_fragment")
+          .add(paymentSheetFragment!!, PaymentSheetFragment.TAG)
           .commit()
       } catch (error: IllegalStateException) {
         promise.resolve(createError(ErrorType.Failed.toString(), error.message))
@@ -480,7 +490,7 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
     getCurrentActivityOrResolveWithError(promise)?.let {
       try {
         it.supportFragmentManager.beginTransaction()
-          .add(fragment, "google_pay_support_fragment")
+          .add(fragment, GooglePayPaymentMethodLauncherFragment.TAG)
           .commit()
       } catch (error: IllegalStateException) {
         promise.resolve(createError(ErrorType.Failed.toString(), error.message))
@@ -498,7 +508,7 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
     getCurrentActivityOrResolveWithError(promise)?.let {
       try {
         it.supportFragmentManager.beginTransaction()
-          .add(googlePayFragment!!, "google_pay_launch_fragment")
+          .add(googlePayFragment!!, GooglePayFragment.TAG)
           .commit()
       } catch (error: IllegalStateException) {
         promise.resolve(createError(ErrorType.Failed.toString(), error.message))
@@ -603,7 +613,7 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
       billingDetails.getString("email")
     )
 
-    val fragment = CollectBankAccountLauncherFragment(
+    collectBankAccountLauncherFragment = CollectBankAccountLauncherFragment(
       reactApplicationContext,
       publishableKey,
       clientSecret,
@@ -614,7 +624,7 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
     getCurrentActivityOrResolveWithError(promise)?.let {
       try {
         it.supportFragmentManager.beginTransaction()
-          .add(fragment, "collect_bank_account_launcher_fragment")
+          .add(collectBankAccountLauncherFragment!!, "collect_bank_account_launcher_fragment")
           .commit()
       } catch (error: IllegalStateException) {
         promise.resolve(createError(ErrorType.Failed.toString(), error.message))
@@ -690,6 +700,28 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
     }
   }
 
+  @ReactMethod
+  fun collectBankAccountToken(clientSecret: String, promise: Promise) {
+    if (!::stripe.isInitialized) {
+      promise.resolve(createMissingInitError())
+      return
+    }
+    financialConnectionsSheetFragment = FinancialConnectionsSheetFragment().also {
+      it.presentFinancialConnectionsSheet(clientSecret, FinancialConnectionsSheetFragment.Mode.ForToken, publishableKey, promise, reactApplicationContext)
+    }
+  }
+
+  @ReactMethod
+  fun collectFinancialConnectionsAccounts(clientSecret: String, promise: Promise) {
+    if (!::stripe.isInitialized) {
+      promise.resolve(createMissingInitError())
+      return
+    }
+    financialConnectionsSheetFragment = FinancialConnectionsSheetFragment().also {
+      it.presentFinancialConnectionsSheet(clientSecret, FinancialConnectionsSheetFragment.Mode.ForSession, publishableKey, promise, reactApplicationContext)
+    }
+  }
+
   /**
    * 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.

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

@@ -111,3 +111,7 @@ internal fun createError(code: String, error: Throwable): WritableMap {
     null,
     null)
 }
+
+internal fun createMissingInitError(): WritableMap {
+  return createError(ErrorType.Failed.toString(), "Stripe has not been initialized. Initialize Stripe in your app with the StripeProvider component or the initStripe method.")
+}

package/android/src/main/java/com/reactnativestripesdk/utils/Extensions.kt

@@ -3,6 +3,9 @@ package com.reactnativestripesdk.utils
 import android.content.Context
 import android.view.View
 import android.view.inputmethod.InputMethodManager
+import androidx.appcompat.app.AppCompatActivity
+import androidx.fragment.app.Fragment
+import com.facebook.react.bridge.ReactApplicationContext
 
 fun View.showSoftKeyboard() {
   post {
@@ -19,3 +22,11 @@ fun View.hideSoftKeyboard() {
     imm?.hideSoftInputFromWindow(windowToken, 0)
   }
 }
+
+fun Fragment.removeFragment(context: ReactApplicationContext) {
+  (context.currentActivity as? AppCompatActivity)?.supportFragmentManager?.let {
+    if (it.findFragmentByTag(this.tag) != null) {
+      it.beginTransaction().remove(this).commitAllowingStateLoss()
+    }
+  }
+}

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

@@ -217,12 +217,11 @@ internal fun mapFromBankAccountStatus(status: BankAccount.Status?): String {
 }
 
 internal fun mapFromBankAccount(bankAccount: BankAccount?): WritableMap? {
-  val bankAccountMap: WritableMap = WritableNativeMap()
-
   if (bankAccount == null) {
     return null
   }
 
+  val bankAccountMap: WritableMap = WritableNativeMap()
   bankAccountMap.putString("id", bankAccount.id)
   bankAccountMap.putString("bankName", bankAccount.bankName)
   bankAccountMap.putString("accountHolderName", bankAccount.accountHolderName)
@@ -231,6 +230,8 @@ internal fun mapFromBankAccount(bankAccount: BankAccount?): WritableMap? {
   bankAccountMap.putString("country", bankAccount.countryCode)
   bankAccountMap.putString("routingNumber", bankAccount.routingNumber)
   bankAccountMap.putString("status", mapFromBankAccountStatus(bankAccount.status))
+  bankAccountMap.putString("fingerprint", bankAccount.fingerprint)
+  bankAccountMap.putString("last4", bankAccount.last4)
 
   return bankAccountMap
 }
@@ -312,13 +313,13 @@ internal fun mapFromCard(card: Card?): WritableMap? {
 
 internal fun mapFromToken(token: Token): WritableMap {
   val tokenMap: WritableMap = WritableNativeMap()
-
   tokenMap.putString("id", token.id)
-  tokenMap.putString("created", token.created.time.toString())
+  tokenMap.putDouble("created", token.created.time.toDouble())
   tokenMap.putString("type", mapTokenType(token.type))
   tokenMap.putBoolean("livemode", token.livemode)
   tokenMap.putMap("bankAccount", mapFromBankAccount(token.bankAccount))
   tokenMap.putMap("card", mapFromCard(token.card))
+  tokenMap.putBoolean("used", token.used)
 
   return tokenMap
 }