@stripe/stripe-react-native 0.41.0 → 0.43.0

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

@@ -2,20 +2,63 @@ package com.reactnativestripesdk
 
 import android.app.Activity
 import android.content.Intent
-import android.os.Parcelable
 import android.util.Log
 import androidx.fragment.app.FragmentActivity
-import com.facebook.react.bridge.*
+import com.facebook.react.bridge.BaseActivityEventListener
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeMap
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.reactnativestripesdk.addresssheet.AddressLauncherFragment
 import com.reactnativestripesdk.pushprovisioning.PushProvisioningProxy
-import com.reactnativestripesdk.utils.*
-import com.stripe.android.*
+import com.reactnativestripesdk.utils.ConfirmPaymentErrorType
+import com.reactnativestripesdk.utils.CreateTokenErrorType
+import com.reactnativestripesdk.utils.ErrorType
+import com.reactnativestripesdk.utils.GooglePayErrorType
+import com.reactnativestripesdk.utils.createCanAddCardResult
+import com.reactnativestripesdk.utils.createError
+import com.reactnativestripesdk.utils.createMissingActivityError
+import com.reactnativestripesdk.utils.createMissingInitError
+import com.reactnativestripesdk.utils.createResult
+import com.reactnativestripesdk.utils.getBooleanOr
+import com.reactnativestripesdk.utils.getBooleanOrFalse
+import com.reactnativestripesdk.utils.getMapOrNull
+import com.reactnativestripesdk.utils.getValOr
+import com.reactnativestripesdk.utils.mapFromPaymentIntentResult
+import com.reactnativestripesdk.utils.mapFromPaymentMethod
+import com.reactnativestripesdk.utils.mapFromSetupIntentResult
+import com.reactnativestripesdk.utils.mapFromToken
+import com.reactnativestripesdk.utils.mapToAddress
+import com.reactnativestripesdk.utils.mapToBankAccountType
+import com.reactnativestripesdk.utils.mapToPaymentMethodType
+import com.reactnativestripesdk.utils.mapToReturnURL
+import com.reactnativestripesdk.utils.mapToShippingDetails
+import com.reactnativestripesdk.utils.mapToUICustomization
+import com.reactnativestripesdk.utils.removeFragment
+import com.reactnativestripesdk.utils.toBundleObject
+import com.stripe.android.ApiResultCallback
+import com.stripe.android.GooglePayJsonFactory
+import com.stripe.android.PaymentAuthConfig
+import com.stripe.android.PaymentConfiguration
+import com.stripe.android.Stripe
 import com.stripe.android.core.ApiVersion
 import com.stripe.android.core.AppInfo
 import com.stripe.android.googlepaylauncher.GooglePayLauncher
-import com.stripe.android.model.*
+import com.stripe.android.model.BankAccountTokenParams
+import com.stripe.android.model.CardParams
+import com.stripe.android.model.ConfirmPaymentIntentParams
+import com.stripe.android.model.ConfirmSetupIntentParams
+import com.stripe.android.model.PaymentIntent
+import com.stripe.android.model.PaymentMethod
+import com.stripe.android.model.SetupIntent
+import com.stripe.android.model.Token
 import com.stripe.android.payments.bankaccount.CollectBankAccountConfiguration
 import com.stripe.android.paymentsheet.PaymentSheet
 import kotlinx.coroutines.CoroutineScope
@@ -23,12 +66,11 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import org.json.JSONObject
 
-
 @ReactModule(name = StripeSdkModule.NAME)
-class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
-  override fun getName(): String {
-    return "StripeSdk"
-  }
+class StripeSdkModule(
+  reactContext: ReactApplicationContext,
+) : ReactContextBaseJavaModule(reactContext) {
+  override fun getName(): String = NAME
 
   var cardFieldView: CardFieldView? = null
   var cardFormView: CardFormView? = null
@@ -38,8 +80,6 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   private var stripeAccountId: String? = null
   private var urlScheme: String? = null
 
-  private var confirmPromise: Promise? = null
-  private var confirmPaymentClientSecret: String? = null
   private var createPlatformPayPaymentMethodPromise: Promise? = null
   private var platformPayUsesDeprecatedTokenFlow = false
 
@@ -54,40 +94,63 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   // If you create a new Fragment, you must put the tag here, otherwise result callbacks for that
   // Fragment will not work on RN < 0.65
   private val allStripeFragmentTags: List<String>
-    get() = listOf(
-      PaymentSheetFragment.TAG,
-      PaymentLauncherFragment.TAG,
-      CollectBankAccountLauncherFragment.TAG,
-      FinancialConnectionsSheetFragment.TAG,
-      AddressLauncherFragment.TAG,
-      GooglePayLauncherFragment.TAG,
-      CustomerSheetFragment.TAG
-    )
+    get() =
+      listOf(
+        PaymentSheetFragment.TAG,
+        PaymentLauncherFragment.TAG,
+        CollectBankAccountLauncherFragment.TAG,
+        FinancialConnectionsSheetFragment.TAG,
+        AddressLauncherFragment.TAG,
+        GooglePayLauncherFragment.TAG,
+        CustomerSheetFragment.TAG,
+      )
 
-  private val mActivityEventListener = object : BaseActivityEventListener() {
-    override fun onActivityResult(activity: Activity, requestCode: Int, resultCode: Int, data: Intent?) {
-      if (::stripe.isInitialized) {
-        when (requestCode) {
-          GooglePayRequestHelper.LOAD_PAYMENT_DATA_REQUEST_CODE -> {
-            createPlatformPayPaymentMethodPromise?.let {
-              GooglePayRequestHelper.handleGooglePaymentMethodResult(resultCode, data, stripe, platformPayUsesDeprecatedTokenFlow, it)
-              createPlatformPayPaymentMethodPromise = null
-            } ?: run { Log.d("StripeReactNative", "No promise was found, Google Pay result went unhandled,") }
-          }
-          else -> {
-            dispatchActivityResultsToFragments(requestCode, resultCode, data)
+  private val mActivityEventListener =
+    object : BaseActivityEventListener() {
+      override fun onActivityResult(
+        activity: Activity,
+        requestCode: Int,
+        resultCode: Int,
+        data: Intent?,
+      ) {
+        if (::stripe.isInitialized) {
+          when (requestCode) {
+            GooglePayRequestHelper.LOAD_PAYMENT_DATA_REQUEST_CODE -> {
+              createPlatformPayPaymentMethodPromise?.let {
+                GooglePayRequestHelper.handleGooglePaymentMethodResult(
+                  resultCode,
+                  data,
+                  stripe,
+                  platformPayUsesDeprecatedTokenFlow,
+                  it,
+                )
+                createPlatformPayPaymentMethodPromise = null
+              } ?: run {
+                Log.d(
+                  "StripeReactNative",
+                  "No promise was found, Google Pay result went unhandled,",
+                )
+              }
+            }
+
+            else -> {
+              dispatchActivityResultsToFragments(requestCode, resultCode, data)
+            }
           }
         }
       }
     }
-  }
 
   init {
     reactContext.addActivityEventListener(mActivityEventListener)
   }
 
   // Necessary on older versions of React Native (~0.65 and below)
-  private fun dispatchActivityResultsToFragments(requestCode: Int, resultCode: Int, data: Intent?) {
+  private fun dispatchActivityResultsToFragments(
+    requestCode: Int,
+    resultCode: Int,
+    data: Intent?,
+  ) {
     getCurrentActivityOrResolveWithError(null)?.supportFragmentManager?.let { fragmentManager ->
       for (tag in allStripeFragmentTags) {
         fragmentManager.findFragmentByTag(tag)?.let {
@@ -103,26 +166,30 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
     val uiCustomization = mapToUICustomization(params)
 
     PaymentAuthConfig.init(
-      PaymentAuthConfig.Builder()
+      PaymentAuthConfig
+        .Builder()
         .set3ds2Config(
           stripe3dsConfigBuilder
             .setUiCustomization(uiCustomization)
-            .build()
-        )
-        .build()
+            .build(),
+        ).build(),
     )
   }
 
   override fun getConstants(): MutableMap<String, Any> =
     hashMapOf(
-      "API_VERSIONS" to hashMapOf(
-        "CORE" to ApiVersion.API_VERSION_CODE,
-        "ISSUING" to PushProvisioningProxy.getApiVersion(),
-      )
+      "API_VERSIONS" to
+        hashMapOf(
+          "CORE" to ApiVersion.API_VERSION_CODE,
+          "ISSUING" to PushProvisioningProxy.getApiVersion(),
+        ),
     )
 
   @ReactMethod
-  fun initialise(params: ReadableMap, promise: Promise) {
+  fun initialise(
+    params: ReadableMap,
+    promise: Promise,
+  ) {
     val publishableKey = getValOr(params, "publishableKey", null) as String
     val appInfo = getMapOrNull(params, "appInfo") as ReadableMap
     this.stripeAccountId = getValOr(params, "stripeAccountId", null)
@@ -150,15 +217,20 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   }
 
   @ReactMethod
-  fun initPaymentSheet(params: ReadableMap, promise: Promise) {
+  fun initPaymentSheet(
+    params: ReadableMap,
+    promise: Promise,
+  ) {
     getCurrentActivityOrResolveWithError(promise)?.let { activity ->
       paymentSheetFragment?.removeFragment(reactApplicationContext)
-      paymentSheetFragment = PaymentSheetFragment(reactApplicationContext, promise).also {
-        val bundle = toBundleObject(params)
-        it.arguments = bundle
-      }
+      paymentSheetFragment =
+        PaymentSheetFragment(reactApplicationContext, promise).also {
+          val bundle = toBundleObject(params)
+          it.arguments = bundle
+        }
       try {
-        activity.supportFragmentManager.beginTransaction()
+        activity.supportFragmentManager
+          .beginTransaction()
           .add(paymentSheetFragment!!, PaymentSheetFragment.TAG)
           .commit()
       } catch (error: IllegalStateException) {
@@ -168,7 +240,10 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   }
 
   @ReactMethod
-  fun presentPaymentSheet(options: ReadableMap, promise: Promise) {
+  fun presentPaymentSheet(
+    options: ReadableMap,
+    promise: Promise,
+  ) {
     if (paymentSheetFragment == null) {
       promise.resolve(PaymentSheetFragment.createMissingInitError())
       return
@@ -177,7 +252,8 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
     val timeoutKey = "timeout"
     if (options.hasKey(timeoutKey)) {
       paymentSheetFragment?.presentWithTimeout(
-        options.getInt(timeoutKey).toLong(), promise
+        options.getInt(timeoutKey).toLong(),
+        promise,
       )
     } else {
       paymentSheetFragment?.present(promise)
@@ -201,7 +277,10 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   }
 
   @ReactMethod
-  fun intentCreationCallback(params: ReadableMap, promise: Promise) {
+  fun intentCreationCallback(
+    params: ReadableMap,
+    promise: Promise,
+  ) {
     if (paymentSheetFragment == null) {
       promise.resolve(PaymentSheetFragment.createMissingInitError())
       return
@@ -211,27 +290,39 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   }
 
   @ReactMethod
-  fun createPaymentMethod(data: ReadableMap, options: ReadableMap, promise: Promise) {
-    val paymentMethodType = getValOr(data, "paymentMethodType")?.let { mapToPaymentMethodType(it) } ?: run {
-      promise.resolve(createError(ConfirmPaymentErrorType.Failed.toString(), "You must provide paymentMethodType"))
-      return
-    }
+  fun createPaymentMethod(
+    data: ReadableMap,
+    options: ReadableMap,
+    promise: Promise,
+  ) {
+    val paymentMethodType =
+      getValOr(data, "paymentMethodType")?.let { mapToPaymentMethodType(it) } ?: run {
+        promise.resolve(
+          createError(
+            ConfirmPaymentErrorType.Failed.toString(),
+            "You must provide paymentMethodType",
+          ),
+        )
+        return
+      }
     val paymentMethodData = getMapOrNull(data, "paymentMethodData")
-    val factory = PaymentMethodCreateParamsFactory(paymentMethodData, options, cardFieldView, cardFormView)
+    val factory =
+      PaymentMethodCreateParamsFactory(paymentMethodData, options, cardFieldView, cardFormView)
     try {
       val paymentMethodCreateParams = factory.createPaymentMethodParams(paymentMethodType)
       stripe.createPaymentMethod(
         paymentMethodCreateParams,
-        callback = object : ApiResultCallback<PaymentMethod> {
-          override fun onError(e: Exception) {
-            promise.resolve(createError("Failed", e))
-          }
+        callback =
+          object : ApiResultCallback<PaymentMethod> {
+            override fun onError(e: Exception) {
+              promise.resolve(createError("Failed", e))
+            }
 
-          override fun onSuccess(result: PaymentMethod) {
-            val paymentMethodMap: WritableMap = mapFromPaymentMethod(result)
-            promise.resolve(createResult("paymentMethod", paymentMethodMap))
-          }
-        }
+            override fun onSuccess(result: PaymentMethod) {
+              val paymentMethodMap: WritableMap = mapFromPaymentMethod(result)
+              promise.resolve(createResult("paymentMethod", paymentMethodMap))
+            }
+          },
       )
     } catch (error: PaymentMethodCreateParamsException) {
       promise.resolve(createError(ConfirmPaymentErrorType.Failed.toString(), error))
@@ -239,10 +330,18 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   }
 
   @ReactMethod
-  fun createToken(params: ReadableMap, promise: Promise) {
+  fun createToken(
+    params: ReadableMap,
+    promise: Promise,
+  ) {
     val type = getValOr(params, "type", null)
     if (type == null) {
-      promise.resolve(createError(CreateTokenErrorType.Failed.toString(), "type parameter is required"))
+      promise.resolve(
+        createError(
+          CreateTokenErrorType.Failed.toString(),
+          "type parameter is required",
+        ),
+      )
       return
     }
 
@@ -250,34 +349,53 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
       "BankAccount" -> {
         createTokenFromBankAccount(params, promise)
       }
+
       "Card" -> {
         createTokenFromCard(params, promise)
       }
+
       "Pii" -> {
         createTokenFromPii(params, promise)
       }
+
       else -> {
-        promise.resolve(createError(CreateTokenErrorType.Failed.toString(), "$type type is not supported yet"))
+        promise.resolve(
+          createError(
+            CreateTokenErrorType.Failed.toString(),
+            "$type type is not supported yet",
+          ),
+        )
       }
     }
   }
 
-  private fun createTokenFromPii(params: ReadableMap, promise: Promise) {
+  private fun createTokenFromPii(
+    params: ReadableMap,
+    promise: Promise,
+  ) {
     getValOr(params, "personalId", null)?.let {
       CoroutineScope(Dispatchers.IO).launch {
         runCatching {
-          val token = stripe.createPiiToken(it, null, stripeAccountId)
+          val token = stripe.createPiiTokenSynchronous(it, null, stripeAccountId)
           promise.resolve(createResult("token", mapFromToken(token)))
         }.onFailure {
           promise.resolve(createError(CreateTokenErrorType.Failed.toString(), it.message))
         }
       }
     } ?: run {
-      promise.resolve(createError(CreateTokenErrorType.Failed.toString(), "personalId parameter is required"))
+      promise.resolve(
+        createError(
+          CreateTokenErrorType.Failed.toString(),
+          "personalId parameter is required",
+        ),
+      )
     }
   }
 
-  private fun createTokenFromBankAccount(params: ReadableMap, promise: Promise) {
+  private fun createTokenFromBankAccount(
+    params: ReadableMap,
+    promise: Promise,
+  ) {
     val accountHolderName = getValOr(params, "accountHolderName", null)
     val accountHolderType = getValOr(params, "accountHolderType", null)
     val accountNumber = getValOr(params, "accountNumber", null)
@@ -285,50 +403,62 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
     val currency = getValOr(params, "currency", null)
     val routingNumber = getValOr(params, "routingNumber", null)
 
-    val bankAccountParams = BankAccountTokenParams(
-      country = country!!,
-      currency = currency!!,
-      accountNumber = accountNumber!!,
-      accountHolderName = accountHolderName,
-      routingNumber = routingNumber,
-      accountHolderType = mapToBankAccountType(accountHolderType)
-    )
+    val bankAccountParams =
+      BankAccountTokenParams(
+        country = country!!,
+        currency = currency!!,
+        accountNumber = accountNumber!!,
+        accountHolderName = accountHolderName,
+        routingNumber = routingNumber,
+        accountHolderType = mapToBankAccountType(accountHolderType),
+      )
     CoroutineScope(Dispatchers.IO).launch {
       runCatching {
-        val token = stripe.createBankAccountToken(bankAccountParams, null, stripeAccountId)
+        val token =
+          stripe.createBankAccountTokenSynchronous(bankAccountParams, null, stripeAccountId)
         promise.resolve(createResult("token", mapFromToken(token)))
       }.onFailure {
         promise.resolve(createError(CreateTokenErrorType.Failed.toString(), it.message))
       }
     }
-
   }
 
-  private fun createTokenFromCard(params: ReadableMap, promise: Promise) {
-    val cardParamsMap = (cardFieldView?.cardParams ?: cardFormView?.cardParams)?.toParamMap()
-      ?: run {
-        promise.resolve(createError(CreateTokenErrorType.Failed.toString(), "Card details not complete"))
-        return
-      }
+  private fun createTokenFromCard(
+    params: ReadableMap,
+    promise: Promise,
+  ) {
+    val cardParamsMap =
+      (cardFieldView?.cardParams ?: cardFormView?.cardParams)?.toParamMap()
+        ?: run {
+          promise.resolve(
+            createError(
+              CreateTokenErrorType.Failed.toString(),
+              "Card details not complete",
+            ),
+          )
+          return
+        }
 
     val cardAddress = cardFieldView?.cardAddress ?: cardFormView?.cardAddress
     val address = getMapOrNull(params, "address")
-    val cardParams = CardParams(
-      number = cardParamsMap["number"] as String,
-      expMonth = cardParamsMap["exp_month"] as Int,
-      expYear = cardParamsMap["exp_year"] as Int,
-      cvc = cardParamsMap["cvc"] as String,
-      address = mapToAddress(address, cardAddress),
-      name = getValOr(params, "name", null),
-      currency = getValOr(params, "currency", null),
-    )
+    val cardParams =
+      CardParams(
+        number = cardParamsMap["number"] as String,
+        expMonth = cardParamsMap["exp_month"] as Int,
+        expYear = cardParamsMap["exp_year"] as Int,
+        cvc = cardParamsMap["cvc"] as String,
+        address = mapToAddress(address, cardAddress),
+        name = getValOr(params, "name", null),
+        currency = getValOr(params, "currency", null),
+      )
 
     CoroutineScope(Dispatchers.IO).launch {
       try {
-        val token = stripe.createCardToken(
-          cardParams = cardParams,
-          stripeAccountId = stripeAccountId
-        )
+        val token =
+          stripe.createCardTokenSynchronous(
+            cardParams = cardParams,
+            stripeAccountId = stripeAccountId,
+          )
         promise.resolve(createResult("token", mapFromToken(token)))
       } catch (e: Exception) {
         promise.resolve(createError(CreateTokenErrorType.Failed.toString(), e.message))
@@ -337,46 +467,58 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   }
 
   @ReactMethod
-  fun createTokenForCVCUpdate(cvc: String, promise: Promise) {
+  fun createTokenForCVCUpdate(
+    cvc: String,
+    promise: Promise,
+  ) {
     stripe.createCvcUpdateToken(
       cvc,
-      callback = object : ApiResultCallback<Token> {
-        override fun onSuccess(result: Token) {
-          val tokenId = result.id
-          val res = WritableNativeMap()
-          res.putString("tokenId", tokenId)
-          promise.resolve(res)
-        }
+      callback =
+        object : ApiResultCallback<Token> {
+          override fun onSuccess(result: Token) {
+            val tokenId = result.id
+            val res = WritableNativeMap()
+            res.putString("tokenId", tokenId)
+            promise.resolve(res)
+          }
 
-        override fun onError(e: Exception) {
-          promise.resolve(createError("Failed", e))
-        }
-      }
+          override fun onError(e: Exception) {
+            promise.resolve(createError("Failed", e))
+          }
+        },
     )
   }
 
   @ReactMethod
-  fun handleNextAction(paymentIntentClientSecret: String, promise: Promise) {
-    paymentLauncherFragment = PaymentLauncherFragment.forNextActionPayment(
-      context = reactApplicationContext,
-      stripe,
-      publishableKey,
-      stripeAccountId,
-      promise,
-      paymentIntentClientSecret
-    )
+  fun handleNextAction(
+    paymentIntentClientSecret: String,
+    promise: Promise,
+  ) {
+    paymentLauncherFragment =
+      PaymentLauncherFragment.forNextActionPayment(
+        context = reactApplicationContext,
+        stripe,
+        publishableKey,
+        stripeAccountId,
+        promise,
+        paymentIntentClientSecret,
+      )
   }
 
   @ReactMethod
-  fun handleNextActionForSetup(setupIntentClientSecret: String, promise: Promise) {
-    paymentLauncherFragment = PaymentLauncherFragment.forNextActionSetup(
-      context = reactApplicationContext,
-      stripe,
-      publishableKey,
-      stripeAccountId,
-      promise,
-      setupIntentClientSecret
-    )
+  fun handleNextActionForSetup(
+    setupIntentClientSecret: String,
+    promise: Promise,
+  ) {
+    paymentLauncherFragment =
+      PaymentLauncherFragment.forNextActionSetup(
+        context = reactApplicationContext,
+        stripe,
+        publishableKey,
+        stripeAccountId,
+        promise,
+        setupIntentClientSecret,
+      )
   }
 
 // TODO: Uncomment when WeChat is re-enabled in stripe-ios
@@ -399,15 +541,27 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
 //  }
 
   @ReactMethod
-  fun confirmPayment(paymentIntentClientSecret: String, params: ReadableMap?, options: ReadableMap, promise: Promise) {
+  fun confirmPayment(
+    paymentIntentClientSecret: String,
+    params: ReadableMap?,
+    options: ReadableMap,
+    promise: Promise,
+  ) {
     val paymentMethodData = getMapOrNull(params, "paymentMethodData")
-    val paymentMethodType = if (params != null)
-      mapToPaymentMethodType(params.getString("paymentMethodType")) ?: run {
-        promise.resolve(createError(ConfirmPaymentErrorType.Failed.toString(), "You must provide paymentMethodType"))
-        return
+    val paymentMethodType =
+      if (params != null) {
+        mapToPaymentMethodType(params.getString("paymentMethodType")) ?: run {
+          promise.resolve(
+            createError(
+              ConfirmPaymentErrorType.Failed.toString(),
+              "You must provide paymentMethodType",
+            ),
+          )
+          return
+        }
+      } else {
+        null // Expect that payment method was attached on the server
       }
-    else
-      null // Expect that payment method was attached on the server
 
 //    if (paymentMethodType == PaymentMethod.Type.WeChatPay) {
 //      val appId = getValOr(params, "appId") ?: run {
@@ -419,30 +573,41 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
 //      return
 //    }
 
-    val factory = PaymentMethodCreateParamsFactory(paymentMethodData, options, cardFieldView, cardFormView)
+    val factory =
+      PaymentMethodCreateParamsFactory(paymentMethodData, options, cardFieldView, cardFormView)
 
     try {
-      val confirmParams = factory.createParams(paymentIntentClientSecret, paymentMethodType, isPaymentIntent = true) as ConfirmPaymentIntentParams
+      val confirmParams =
+        factory.createParams(
+          paymentIntentClientSecret,
+          paymentMethodType,
+          isPaymentIntent = true,
+        ) as ConfirmPaymentIntentParams
       urlScheme?.let {
         confirmParams.returnUrl = mapToReturnURL(urlScheme)
       }
-      confirmParams.shipping = mapToShippingDetails(getMapOrNull(paymentMethodData, "shippingDetails"))
-      paymentLauncherFragment = PaymentLauncherFragment.forPayment(
-        context = reactApplicationContext,
-        stripe,
-        publishableKey,
-        stripeAccountId,
-        promise,
-        paymentIntentClientSecret,
-        confirmParams
-      )
+      confirmParams.shipping =
+        mapToShippingDetails(getMapOrNull(paymentMethodData, "shippingDetails"))
+      paymentLauncherFragment =
+        PaymentLauncherFragment.forPayment(
+          context = reactApplicationContext,
+          stripe,
+          publishableKey,
+          stripeAccountId,
+          promise,
+          paymentIntentClientSecret,
+          confirmParams,
+        )
     } catch (error: PaymentMethodCreateParamsException) {
       promise.resolve(createError(ConfirmPaymentErrorType.Failed.toString(), error))
     }
   }
 
   @ReactMethod
-  fun retrievePaymentIntent(clientSecret: String, promise: Promise) {
+  fun retrievePaymentIntent(
+    clientSecret: String,
+    promise: Promise,
+  ) {
     CoroutineScope(Dispatchers.IO).launch {
       val paymentIntent = stripe.retrievePaymentIntentSynchronous(clientSecret)
       promise.resolve(createResult("paymentIntent", mapFromPaymentIntentResult(paymentIntent)))
@@ -450,7 +615,10 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   }
 
   @ReactMethod
-  fun retrieveSetupIntent(clientSecret: String, promise: Promise) {
+  fun retrieveSetupIntent(
+    clientSecret: String,
+    promise: Promise,
+  ) {
     CoroutineScope(Dispatchers.IO).launch {
       val setupIntent = stripe.retrieveSetupIntentSynchronous(clientSecret)
       promise.resolve(createResult("setupIntent", mapFromSetupIntentResult(setupIntent)))
@@ -458,46 +626,74 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   }
 
   @ReactMethod
-  fun confirmSetupIntent(setupIntentClientSecret: String, params: ReadableMap, options: ReadableMap, promise: Promise) {
-    val paymentMethodType = getValOr(params, "paymentMethodType")?.let { mapToPaymentMethodType(it) } ?: run {
-      promise.resolve(createError(ConfirmPaymentErrorType.Failed.toString(), "You must provide paymentMethodType"))
-      return
-    }
+  fun confirmSetupIntent(
+    setupIntentClientSecret: String,
+    params: ReadableMap,
+    options: ReadableMap,
+    promise: Promise,
+  ) {
+    val paymentMethodType =
+      getValOr(params, "paymentMethodType")?.let { mapToPaymentMethodType(it) } ?: run {
+        promise.resolve(
+          createError(
+            ConfirmPaymentErrorType.Failed.toString(),
+            "You must provide paymentMethodType",
+          ),
+        )
+        return
+      }
 
-    val factory = PaymentMethodCreateParamsFactory(getMapOrNull(params, "paymentMethodData"), options, cardFieldView, cardFormView)
+    val factory =
+      PaymentMethodCreateParamsFactory(
+        getMapOrNull(params, "paymentMethodData"),
+        options,
+        cardFieldView,
+        cardFormView,
+      )
 
     try {
-      val confirmParams = factory.createParams(setupIntentClientSecret, paymentMethodType, isPaymentIntent = false) as ConfirmSetupIntentParams
+      val confirmParams =
+        factory.createParams(
+          setupIntentClientSecret,
+          paymentMethodType,
+          isPaymentIntent = false,
+        ) as ConfirmSetupIntentParams
       urlScheme?.let {
         confirmParams.returnUrl = mapToReturnURL(urlScheme)
       }
-      paymentLauncherFragment = PaymentLauncherFragment.forSetup(
-        context = reactApplicationContext,
-        stripe,
-        publishableKey,
-        stripeAccountId,
-        promise,
-        setupIntentClientSecret,
-        confirmParams
-      )
+      paymentLauncherFragment =
+        PaymentLauncherFragment.forSetup(
+          context = reactApplicationContext,
+          stripe,
+          publishableKey,
+          stripeAccountId,
+          promise,
+          setupIntentClientSecret,
+          confirmParams,
+        )
     } catch (error: PaymentMethodCreateParamsException) {
       promise.resolve(createError(ConfirmPaymentErrorType.Failed.toString(), error))
     }
   }
 
   @ReactMethod
-  fun isPlatformPaySupported(params: ReadableMap?, promise: Promise) {
+  fun isPlatformPaySupported(
+    params: ReadableMap?,
+    promise: Promise,
+  ) {
     val googlePayParams = params?.getMap("googlePay")
-    val fragment = GooglePayPaymentMethodLauncherFragment(
-      reactApplicationContext,
-      getBooleanOrFalse(googlePayParams, "testEnv"),
-      getBooleanOrFalse(googlePayParams, "existingPaymentMethodRequired"),
-      promise
-    )
+    val fragment =
+      GooglePayPaymentMethodLauncherFragment(
+        reactApplicationContext,
+        getBooleanOrFalse(googlePayParams, "testEnv"),
+        getBooleanOrFalse(googlePayParams, "existingPaymentMethodRequired"),
+        promise,
+      )
 
     getCurrentActivityOrResolveWithError(promise)?.let {
       try {
-        it.supportFragmentManager.beginTransaction()
+        it.supportFragmentManager
+          .beginTransaction()
           .add(fragment, GooglePayPaymentMethodLauncherFragment.TAG)
           .commit()
       } catch (error: IllegalStateException) {
@@ -507,23 +703,34 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   }
 
   @ReactMethod
-  fun confirmPlatformPay(clientSecret: String, params: ReadableMap, isPaymentIntent: Boolean, promise: Promise) {
+  fun confirmPlatformPay(
+    clientSecret: String,
+    params: ReadableMap,
+    isPaymentIntent: Boolean,
+    promise: Promise,
+  ) {
     if (!::stripe.isInitialized) {
       promise.resolve(createMissingInitError())
       return
     }
 
-    val googlePayParams: ReadableMap = params.getMap("googlePay") ?: run {
-      promise.resolve(createError(GooglePayErrorType.Failed.toString(), "You must provide the `googlePay` parameter."))
-      return
-    }
+    val googlePayParams: ReadableMap =
+      params.getMap("googlePay") ?: run {
+        promise.resolve(
+          createError(
+            GooglePayErrorType.Failed.toString(),
+            "You must provide the `googlePay` parameter.",
+          ),
+        )
+        return
+      }
 
     GooglePayLauncherFragment().also {
       it.presentGooglePaySheet(
         clientSecret,
         if (isPaymentIntent) GooglePayLauncherFragment.Mode.ForPayment else GooglePayLauncherFragment.Mode.ForSetup,
         googlePayParams,
-        reactApplicationContext
+        reactApplicationContext,
       ) { launcherResult, errorMap ->
         if (errorMap != null) {
           promise.resolve(errorMap)
@@ -531,30 +738,59 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
           when (launcherResult) {
             GooglePayLauncher.Result.Completed -> {
               if (isPaymentIntent) {
-                stripe.retrievePaymentIntent(clientSecret, stripeAccountId, expand = listOf("payment_method"), object : ApiResultCallback<PaymentIntent> {
-                  override fun onError(e: Exception) {
-                    promise.resolve(createResult("paymentIntent", WritableNativeMap()))
-                  }
-                  override fun onSuccess(result: PaymentIntent) {
-                    promise.resolve(createResult("paymentIntent", mapFromPaymentIntentResult(result)))
-                  }
-                })
+                stripe.retrievePaymentIntent(
+                  clientSecret,
+                  stripeAccountId,
+                  expand = listOf("payment_method"),
+                  object : ApiResultCallback<PaymentIntent> {
+                    override fun onError(e: Exception) {
+                      promise.resolve(createResult("paymentIntent", WritableNativeMap()))
+                    }
+
+                    override fun onSuccess(result: PaymentIntent) {
+                      promise.resolve(
+                        createResult(
+                          "paymentIntent",
+                          mapFromPaymentIntentResult(result),
+                        ),
+                      )
+                    }
+                  },
+                )
               } else {
-                stripe.retrieveSetupIntent(clientSecret, stripeAccountId, expand = listOf("payment_method"),  object : ApiResultCallback<SetupIntent> {
-                  override fun onError(e: Exception) {
-                    promise.resolve(createResult("setupIntent", WritableNativeMap()))
-                  }
-                  override fun onSuccess(result: SetupIntent) {
-                    promise.resolve(createResult("setupIntent", mapFromSetupIntentResult(result)))
-                  }
-                })
+                stripe.retrieveSetupIntent(
+                  clientSecret,
+                  stripeAccountId,
+                  expand = listOf("payment_method"),
+                  object : ApiResultCallback<SetupIntent> {
+                    override fun onError(e: Exception) {
+                      promise.resolve(createResult("setupIntent", WritableNativeMap()))
+                    }
+
+                    override fun onSuccess(result: SetupIntent) {
+                      promise.resolve(createResult("setupIntent", mapFromSetupIntentResult(result)))
+                    }
+                  },
+                )
               }
             }
+
             GooglePayLauncher.Result.Canceled -> {
-              promise.resolve(createError(GooglePayErrorType.Canceled.toString(), "Google Pay has been canceled"))
+              promise.resolve(
+                createError(
+                  GooglePayErrorType.Canceled.toString(),
+                  "Google Pay has been canceled",
+                ),
+              )
             }
+
             is GooglePayLauncher.Result.Failed -> {
-              promise.resolve(createError(GooglePayErrorType.Failed.toString(), launcherResult.error))
+              promise.resolve(
+                createError(
+                  GooglePayErrorType.Failed.toString(),
+                  launcherResult.error,
+                ),
+              )
             }
           }
         }
@@ -563,73 +799,108 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   }
 
   @ReactMethod
-  fun createPlatformPayPaymentMethod(params: ReadableMap, usesDeprecatedTokenFlow: Boolean, promise: Promise) {
-    val googlePayParams: ReadableMap = params.getMap("googlePay") ?: run {
-      promise.resolve(createError(GooglePayErrorType.Failed.toString(), "You must provide the `googlePay` parameter."))
-      return
-    }
+  fun createPlatformPayPaymentMethod(
+    params: ReadableMap,
+    usesDeprecatedTokenFlow: Boolean,
+    promise: Promise,
+  ) {
+    val googlePayParams: ReadableMap =
+      params.getMap("googlePay") ?: run {
+        promise.resolve(
+          createError(
+            GooglePayErrorType.Failed.toString(),
+            "You must provide the `googlePay` parameter.",
+          ),
+        )
+        return
+      }
     platformPayUsesDeprecatedTokenFlow = usesDeprecatedTokenFlow
     createPlatformPayPaymentMethodPromise = promise
     getCurrentActivityOrResolveWithError(promise)?.let {
-      val request = GooglePayRequestHelper.createPaymentRequest(
-        it,
-        GooglePayJsonFactory(reactApplicationContext),
-        googlePayParams
-      )
+      val request =
+        GooglePayRequestHelper.createPaymentRequest(
+          it,
+          GooglePayJsonFactory(reactApplicationContext),
+          googlePayParams,
+        )
       GooglePayRequestHelper.createPaymentMethod(request, it)
     }
   }
 
   @ReactMethod
-  fun canAddCardToWallet(params: ReadableMap, promise: Promise) {
-    val last4 = getValOr(params, "cardLastFour", null) ?: run {
-      promise.resolve(createError("Failed", "You must provide cardLastFour"))
-      return
-    }
+  fun canAddCardToWallet(
+    params: ReadableMap,
+    promise: Promise,
+  ) {
+    val last4 =
+      getValOr(params, "cardLastFour", null) ?: run {
+        promise.resolve(createError("Failed", "You must provide cardLastFour"))
+        return
+      }
 
-    if (params.getBooleanOr("supportsTapToPay", true) && !PushProvisioningProxy.isNFCEnabled(reactApplicationContext)) {
+    if (params.getBooleanOr("supportsTapToPay", true) &&
+      !PushProvisioningProxy.isNFCEnabled(
+        reactApplicationContext,
+      )
+    ) {
       promise.resolve(createCanAddCardResult(false, "UNSUPPORTED_DEVICE"))
       return
     }
 
     getCurrentActivityOrResolveWithError(promise)?.let {
       PushProvisioningProxy.isCardInWallet(it, last4) { isCardInWallet, token, error ->
-        val result = error?.let {
-          createCanAddCardResult(false, "MISSING_CONFIGURATION", null)
-        } ?: run {
-          val status = if (isCardInWallet) "CARD_ALREADY_EXISTS" else null
-          createCanAddCardResult(!isCardInWallet, status, token)
-        }
+        val result =
+          error?.let {
+            createCanAddCardResult(false, "MISSING_CONFIGURATION", null)
+          } ?: run {
+            val status = if (isCardInWallet) "CARD_ALREADY_EXISTS" else null
+            createCanAddCardResult(!isCardInWallet, status, token)
+          }
         promise.resolve(result)
       }
     }
   }
 
   @ReactMethod
-  fun isCardInWallet(params: ReadableMap, promise: Promise) {
-    val last4 = getValOr(params, "cardLastFour", null) ?: run {
-      promise.resolve(createError("Failed", "You must provide cardLastFour"))
-      return
-    }
+  fun isCardInWallet(
+    params: ReadableMap,
+    promise: Promise,
+  ) {
+    val last4 =
+      getValOr(params, "cardLastFour", null) ?: run {
+        promise.resolve(createError("Failed", "You must provide cardLastFour"))
+        return
+      }
     getCurrentActivityOrResolveWithError(promise)?.let {
       PushProvisioningProxy.isCardInWallet(it, last4) { isCardInWallet, token, error ->
-        val result: WritableMap = error ?: run {
-          val map = WritableNativeMap()
-          map.putBoolean("isInWallet", isCardInWallet)
-          map.putMap("token", token)
-          map
-        }
+        val result: WritableMap =
+          error ?: run {
+            val map = WritableNativeMap()
+            map.putBoolean("isInWallet", isCardInWallet)
+            map.putMap("token", token)
+            map
+          }
         promise.resolve(result)
       }
     }
   }
 
   @ReactMethod
-  fun collectBankAccount(isPaymentIntent: Boolean, clientSecret: String, params: ReadableMap, promise: Promise) {
+  fun collectBankAccount(
+    isPaymentIntent: Boolean,
+    clientSecret: String,
+    params: ReadableMap,
+    promise: Promise,
+  ) {
     val paymentMethodData = getMapOrNull(params, "paymentMethodData")
     val paymentMethodType = mapToPaymentMethodType(getValOr(params, "paymentMethodType", null))
     if (paymentMethodType != PaymentMethod.Type.USBankAccount) {
-      promise.resolve(createError(ErrorType.Failed.toString(), "collectBankAccount currently only accepts the USBankAccount payment method type."))
+      promise.resolve(
+        createError(
+          ErrorType.Failed.toString(),
+          "collectBankAccount currently only accepts the USBankAccount payment method type.",
+        ),
+      )
       return
     }
 
@@ -637,27 +908,35 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
 
     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."))
+      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 collectParams =
+      CollectBankAccountConfiguration.USBankAccount(
+        name,
+        billingDetails.getString("email"),
+      )
 
-    collectBankAccountLauncherFragment = CollectBankAccountLauncherFragment(
-      reactApplicationContext,
-      publishableKey,
-      stripeAccountId,
-      clientSecret,
-      isPaymentIntent,
-      collectParams,
-      promise
-    )
+    collectBankAccountLauncherFragment =
+      CollectBankAccountLauncherFragment(
+        reactApplicationContext,
+        publishableKey,
+        stripeAccountId,
+        clientSecret,
+        isPaymentIntent,
+        collectParams,
+        promise,
+      )
     getCurrentActivityOrResolveWithError(promise)?.let {
       try {
-        it.supportFragmentManager.beginTransaction()
+        it.supportFragmentManager
+          .beginTransaction()
           .add(collectBankAccountLauncherFragment!!, "collect_bank_account_launcher_fragment")
           .commit()
       } catch (error: IllegalStateException) {
@@ -667,38 +946,55 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   }
 
   @ReactMethod
-  fun verifyMicrodeposits(isPaymentIntent: Boolean, clientSecret: String, params: ReadableMap, promise: Promise) {
+  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."))
+      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))
-      }
+    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)))
+        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))
-      }
+    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)))
+        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()}"))
+        promise.resolve(
+          createError(
+            ErrorType.Failed.toString(),
+            "Expected 2 integers in the amounts array, but received ${it.size()}",
+          ),
+        )
         return
       }
 
@@ -707,14 +1003,14 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
           clientSecret,
           it.getInt(0),
           it.getInt(1),
-          paymentCallback
+          paymentCallback,
         )
       } else {
         stripe.verifySetupIntentWithMicrodeposits(
           clientSecret,
           it.getInt(0),
           it.getInt(1),
-          setupCallback
+          setupCallback,
         )
       }
     } ?: descriptorCode?.let {
@@ -722,42 +1018,66 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
         stripe.verifyPaymentIntentWithMicrodeposits(
           clientSecret,
           it,
-          paymentCallback
+          paymentCallback,
         )
       } else {
         stripe.verifySetupIntentWithMicrodeposits(
           clientSecret,
           it,
-          setupCallback
+          setupCallback,
         )
       }
     }
   }
 
   @ReactMethod
-  fun collectBankAccountToken(clientSecret: String, promise: Promise) {
+  fun collectBankAccountToken(
+    clientSecret: String,
+    promise: Promise,
+  ) {
     if (!::stripe.isInitialized) {
       promise.resolve(createMissingInitError())
       return
     }
     FinancialConnectionsSheetFragment().also {
-      it.presentFinancialConnectionsSheet(clientSecret, FinancialConnectionsSheetFragment.Mode.ForToken, publishableKey, stripeAccountId, promise, reactApplicationContext)
+      it.presentFinancialConnectionsSheet(
+        clientSecret,
+        FinancialConnectionsSheetFragment.Mode.ForToken,
+        publishableKey,
+        stripeAccountId,
+        promise,
+        reactApplicationContext,
+      )
     }
   }
 
   @ReactMethod
-  fun collectFinancialConnectionsAccounts(clientSecret: String, promise: Promise) {
+  fun collectFinancialConnectionsAccounts(
+    clientSecret: String,
+    promise: Promise,
+  ) {
     if (!::stripe.isInitialized) {
       promise.resolve(createMissingInitError())
       return
     }
     FinancialConnectionsSheetFragment().also {
-      it.presentFinancialConnectionsSheet(clientSecret, FinancialConnectionsSheetFragment.Mode.ForSession, publishableKey, stripeAccountId, promise, reactApplicationContext)
+      it.presentFinancialConnectionsSheet(
+        clientSecret,
+        FinancialConnectionsSheetFragment.Mode.ForSession,
+        publishableKey,
+        stripeAccountId,
+        promise,
+        reactApplicationContext,
+      )
     }
   }
 
   @ReactMethod
-  fun initCustomerSheet(params: ReadableMap, customerAdapterOverrides: ReadableMap, promise: Promise) {
+  fun initCustomerSheet(
+    params: ReadableMap,
+    customerAdapterOverrides: ReadableMap,
+    promise: Promise,
+  ) {
     if (!::stripe.isInitialized) {
       promise.resolve(createMissingInitError())
       return
@@ -765,15 +1085,17 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
 
     getCurrentActivityOrResolveWithError(promise)?.let { activity ->
       customerSheetFragment?.removeFragment(reactApplicationContext)
-      customerSheetFragment = CustomerSheetFragment().also {
-        it.context = reactApplicationContext
-        it.initPromise = promise
-        val bundle = toBundleObject(params)
-        bundle.putBundle("customerAdapter", toBundleObject(customerAdapterOverrides))
-        it.arguments = bundle
-      }
+      customerSheetFragment =
+        CustomerSheetFragment().also {
+          it.context = reactApplicationContext
+          it.initPromise = promise
+          val bundle = toBundleObject(params)
+          bundle.putBundle("customerAdapter", toBundleObject(customerAdapterOverrides))
+          it.arguments = bundle
+        }
       try {
-        activity.supportFragmentManager.beginTransaction()
+        activity.supportFragmentManager
+          .beginTransaction()
           .add(customerSheetFragment!!, CustomerSheetFragment.TAG)
           .commit()
       } catch (error: IllegalStateException) {
@@ -783,7 +1105,10 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   }
 
   @ReactMethod
-  fun presentCustomerSheet(params: ReadableMap, promise: Promise) {
+  fun presentCustomerSheet(
+    params: ReadableMap,
+    promise: Promise,
+  ) {
     var timeout: Long? = null
     if (params.hasKey("timeout")) {
       timeout = params.getInt("timeout").toLong()
@@ -801,14 +1126,20 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   }
 
   @ReactMethod
-  fun customerAdapterFetchPaymentMethodsCallback(paymentMethodJsonObjects: ReadableArray, promise: Promise) {
+  fun customerAdapterFetchPaymentMethodsCallback(
+    paymentMethodJsonObjects: ReadableArray,
+    promise: Promise,
+  ) {
     customerSheetFragment?.let { fragment ->
       val paymentMethods = mutableListOf<PaymentMethod>()
       for (paymentMethodJson in paymentMethodJsonObjects.toArrayList()) {
         PaymentMethod.fromJson(JSONObject((paymentMethodJson as HashMap<*, *>)))?.let {
           paymentMethods.add(it)
         } ?: run {
-          Log.e("StripeReactNative", "There was an error converting Payment Method JSON to a Stripe Payment Method")
+          Log.e(
+            "StripeReactNative",
+            "There was an error converting Payment Method JSON to a Stripe Payment Method",
+          )
         }
       }
       fragment.customerAdapter?.fetchPaymentMethodsCallback?.complete(paymentMethods)
@@ -819,11 +1150,18 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   }
 
   @ReactMethod
-  fun customerAdapterAttachPaymentMethodCallback(paymentMethodJson: ReadableMap, promise: Promise) {
+  fun customerAdapterAttachPaymentMethodCallback(
+    paymentMethodJson: ReadableMap,
+    promise: Promise,
+  ) {
     customerSheetFragment?.let {
-      val paymentMethod = PaymentMethod.fromJson(JSONObject(paymentMethodJson.toHashMap() as HashMap<*, *>))
+      val paymentMethod =
+        PaymentMethod.fromJson(JSONObject(paymentMethodJson.toHashMap() as HashMap<*, *>))
       if (paymentMethod == null) {
-        Log.e("StripeReactNative", "There was an error converting Payment Method JSON to a Stripe Payment Method")
+        Log.e(
+          "StripeReactNative",
+          "There was an error converting Payment Method JSON to a Stripe Payment Method",
+        )
         return
       }
       it.customerAdapter?.attachPaymentMethodCallback?.complete(paymentMethod)
@@ -834,11 +1172,18 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   }
 
   @ReactMethod
-  fun customerAdapterDetachPaymentMethodCallback(paymentMethodJson: ReadableMap, promise: Promise) {
+  fun customerAdapterDetachPaymentMethodCallback(
+    paymentMethodJson: ReadableMap,
+    promise: Promise,
+  ) {
     customerSheetFragment?.let {
-      val paymentMethod = PaymentMethod.fromJson(JSONObject(paymentMethodJson.toHashMap() as HashMap<*, *>))
+      val paymentMethod =
+        PaymentMethod.fromJson(JSONObject(paymentMethodJson.toHashMap() as HashMap<*, *>))
       if (paymentMethod == null) {
-        Log.e("StripeReactNative", "There was an error converting Payment Method JSON to a Stripe Payment Method")
+        Log.e(
+          "StripeReactNative",
+          "There was an error converting Payment Method JSON to a Stripe Payment Method",
+        )
         return
       }
       it.customerAdapter?.detachPaymentMethodCallback?.complete(paymentMethod)
@@ -859,7 +1204,10 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   }
 
   @ReactMethod
-  fun customerAdapterFetchSelectedPaymentOptionCallback(paymentOption: String?, promise: Promise) {
+  fun customerAdapterFetchSelectedPaymentOptionCallback(
+    paymentOption: String?,
+    promise: Promise,
+  ) {
     customerSheetFragment?.let {
       it.customerAdapter?.fetchSelectedPaymentOptionCallback?.complete(paymentOption)
     } ?: run {
@@ -869,7 +1217,10 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   }
 
   @ReactMethod
-  fun customerAdapterSetupIntentClientSecretForCustomerAttachCallback(clientSecret: String, promise: Promise) {
+  fun customerAdapterSetupIntentClientSecretForCustomerAttachCallback(
+    clientSecret: String,
+    promise: Promise,
+  ) {
     customerSheetFragment?.let {
       it.customerAdapter?.setupIntentClientSecretForCustomerAttachCallback?.complete(clientSecret)
     } ?: run {
@@ -891,7 +1242,11 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
     }
   }
 
-  internal fun sendEvent(reactContext: ReactContext, eventName: String, params: WritableMap) {
+  internal fun sendEvent(
+    reactContext: ReactContext,
+    eventName: String,
+    params: WritableMap,
+  ) {
     reactContext
       .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
       .emit(eventName, params)