@stripe/stripe-react-native 0.4.0 → 0.7.0

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

@@ -0,0 +1,177 @@
+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.fragment.app.Fragment
+import com.facebook.react.bridge.Promise
+import com.stripe.android.ApiResultCallback
+import com.stripe.android.Stripe
+import com.stripe.android.model.*
+import com.stripe.android.payments.paymentlauncher.PaymentLauncher
+import com.stripe.android.payments.paymentlauncher.PaymentResult
+
+class PaymentLauncherFragment(
+  private val stripe: Stripe,
+  private val publishableKey: String,
+  private val stripeAccountId: String?,
+) : Fragment() {
+  private lateinit var paymentLauncher: PaymentLauncher
+  private var clientSecret: String? = null
+  private var promise: Promise? = null
+  private var isPaymentIntent: Boolean = true
+
+  override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?,
+                            savedInstanceState: Bundle?): View {
+    paymentLauncher = createPaymentLauncher()
+    return FrameLayout(requireActivity()).also {
+      it.visibility = View.GONE
+    }
+  }
+
+  fun handleNextActionForPaymentIntent(clientSecret: String, promise: Promise) {
+    this.clientSecret = clientSecret
+    this.promise = promise
+    paymentLauncher.handleNextActionForPaymentIntent(clientSecret)
+  }
+
+  fun confirm(params: ConfirmPaymentIntentParams, clientSecret: String, promise: Promise) {
+    this.clientSecret = clientSecret
+    this.promise = promise
+    this.isPaymentIntent = true
+    paymentLauncher.confirm(params)
+  }
+
+  fun confirm(params: ConfirmSetupIntentParams, clientSecret: String, promise: Promise) {
+    this.clientSecret = clientSecret
+    this.promise = promise
+    this.isPaymentIntent = false
+    paymentLauncher.confirm(params)
+  }
+
+  private fun createPaymentLauncher(): PaymentLauncher {
+    return PaymentLauncher.create(this, publishableKey, stripeAccountId) { paymentResult ->
+      when (paymentResult) {
+        is PaymentResult.Completed -> {
+          clientSecret?.let {
+            if (isPaymentIntent) retrievePaymentIntent(it, stripeAccountId)
+            else retrieveSetupIntent(it, stripeAccountId)
+          } ?: run {
+            promise?.resolve(
+              createError(ConfirmPaymentErrorType.Failed.toString(), "Client secret must be set before responding to payment results.")
+            )
+              ?: throw Exception("Client secret must be set before responding to payment results.")
+          }
+        }
+        is PaymentResult.Canceled -> {
+          promise?.resolve(createError(ConfirmPaymentErrorType.Canceled.toString(), message = null))
+            ?: throw Exception("No promise is set to handle payment results.")
+        }
+        is PaymentResult.Failed -> {
+          promise?.resolve(createError(ConfirmPaymentErrorType.Failed.toString(), paymentResult.throwable.localizedMessage))
+            ?: throw Exception("No promise is set to handle payment results.")
+        }
+      }
+    }
+  }
+
+  private fun retrieveSetupIntent(clientSecret: String, stripeAccountId: String?) {
+    val promise = promise ?: throw Exception("No promise is set to handle payment results.")
+    stripe.retrieveSetupIntent(clientSecret, stripeAccountId, object : ApiResultCallback<SetupIntent> {
+      override fun onError(e: Exception) {
+        promise.resolve(createError(ConfirmSetupIntentErrorType.Failed.toString(), e))
+      }
+
+      override fun onSuccess(result: SetupIntent) {
+        when (result.status) {
+          StripeIntent.Status.Succeeded,
+          StripeIntent.Status.Processing,
+          StripeIntent.Status.RequiresConfirmation,
+          StripeIntent.Status.RequiresCapture -> {
+            promise.resolve(createResult("setupIntent", mapFromSetupIntentResult(result)))
+          }
+          StripeIntent.Status.RequiresAction -> {
+            if (isNextActionSuccessState(result.nextActionType)) {
+              promise.resolve(createResult("setupIntent", mapFromSetupIntentResult(result)))
+            } else {
+              (result.lastSetupError)?.let {
+                promise.resolve(createError(ConfirmSetupIntentErrorType.Canceled.toString(), it))
+              } ?: run {
+                promise.resolve(createError(ConfirmSetupIntentErrorType.Canceled.toString(), "Setup has been canceled"))
+              }
+            }
+          }
+          StripeIntent.Status.RequiresPaymentMethod -> {
+            promise.resolve(createError(ConfirmSetupIntentErrorType.Failed.toString(), result.lastSetupError))
+          }
+          StripeIntent.Status.Canceled -> {
+            promise.resolve(createError(ConfirmSetupIntentErrorType.Canceled.toString(), result.lastSetupError))
+          }
+          else -> {
+            promise.resolve(createError(ConfirmSetupIntentErrorType.Unknown.toString(), "unhandled error: ${result.status}"))
+          }
+        }
+      }
+    })
+  }
+
+  private fun retrievePaymentIntent(clientSecret: String, stripeAccountId: String?) {
+    val promise = promise ?: throw Exception("No promise is set to handle payment results.")
+    stripe.retrievePaymentIntent(clientSecret, stripeAccountId, object : ApiResultCallback<PaymentIntent> {
+      override fun onError(e: Exception) {
+        promise.resolve(createError(ConfirmPaymentErrorType.Failed.toString(), e))
+      }
+
+      override fun onSuccess(result: PaymentIntent) {
+        when (result.status) {
+          StripeIntent.Status.Succeeded,
+          StripeIntent.Status.Processing,
+          StripeIntent.Status.RequiresConfirmation,
+          StripeIntent.Status.RequiresCapture -> {
+            promise.resolve(createResult("paymentIntent", mapFromPaymentIntentResult(result)))
+          }
+          StripeIntent.Status.RequiresAction -> {
+            if (isNextActionSuccessState(result.nextActionType)) {
+              promise.resolve(createResult("paymentIntent", mapFromPaymentIntentResult(result)))
+            } else {
+              (result.lastPaymentError)?.let {
+                promise.resolve(createError(ConfirmPaymentErrorType.Canceled.toString(), it))
+              } ?: run {
+                promise.resolve(createError(ConfirmPaymentErrorType.Canceled.toString(), "The payment has been canceled"))
+              }
+            }
+          }
+          StripeIntent.Status.RequiresPaymentMethod -> {
+            promise.resolve(createError(ConfirmPaymentErrorType.Failed.toString(), result.lastPaymentError))
+          }
+          StripeIntent.Status.Canceled -> {
+            promise.resolve(createError(ConfirmPaymentErrorType.Canceled.toString(), result.lastPaymentError))
+          }
+          else -> {
+            promise.resolve(createError(ConfirmPaymentErrorType.Unknown.toString(), "unhandled error: ${result.status}"))
+          }
+        }
+      }
+    })
+  }
+
+  /**
+   * Check if paymentIntent.nextAction is out-of-band, such as voucher-based or waiting
+   * on customer verification. If it is, then being in this state is considered "successful".
+   */
+  private fun isNextActionSuccessState(nextAction: StripeIntent.NextActionType?): Boolean {
+    return when (nextAction) {
+      StripeIntent.NextActionType.DisplayOxxoDetails,
+      StripeIntent.NextActionType.VerifyWithMicrodeposits -> true
+      StripeIntent.NextActionType.RedirectToUrl,
+      StripeIntent.NextActionType.UseStripeSdk,
+      StripeIntent.NextActionType.AlipayRedirect,
+      StripeIntent.NextActionType.BlikAuthorize,
+      StripeIntent.NextActionType.WeChatPayRedirect,
+      null -> false
+    }
+  }
+}
+

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

@@ -6,7 +6,7 @@ import com.stripe.android.model.*
 class PaymentMethodCreateParamsFactory(
   private val clientSecret: String,
   private val params: ReadableMap,
-  private val cardFieldView: StripeSdkCardView?,
+  private val cardFieldView: CardFieldView?,
   private val cardFormView: CardFormView?,
 ) {
   private val billingDetailsParams = mapToBillingDetails(getMapOrNull(params, "billingDetails"), cardFieldView?.cardAddress ?: cardFormView?.cardAddress)
@@ -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")
         }
@@ -77,17 +79,17 @@ class PaymentMethodCreateParamsFactory(
 
   @Throws(PaymentMethodCreateParamsException::class)
   private fun createP24PaymentConfirmParams(): ConfirmPaymentIntentParams {
-    val billingDetails = billingDetailsParams?.let { it } ?: run {
-      throw PaymentMethodCreateParamsException("You must provide billing details")
-    }
+    billingDetailsParams?.let {
+      val params = PaymentMethodCreateParams.createP24(it)
 
-    val params = PaymentMethodCreateParams.createP24(billingDetails)
+      return ConfirmPaymentIntentParams
+        .createWithPaymentMethodCreateParams(
+          paymentMethodCreateParams = params,
+          clientSecret = clientSecret,
+        )
+    }
 
-    return ConfirmPaymentIntentParams
-      .createWithPaymentMethodCreateParams(
-        paymentMethodCreateParams = params,
-        clientSecret = clientSecret,
-      )
+    throw PaymentMethodCreateParamsException("You must provide billing details")
   }
 
   @Throws(PaymentMethodCreateParamsException::class)
@@ -146,27 +148,31 @@ class PaymentMethodCreateParamsFactory(
 
   @Throws(PaymentMethodCreateParamsException::class)
   private fun createSepaPaymentSetupParams(): ConfirmSetupIntentParams {
-    val billingDetails = billingDetailsParams?.let { it } ?: run {
-      throw PaymentMethodCreateParamsException("You must provide billing details")
-    }
-    val iban = getValOr(params, "iban", null)?.let { it } ?: run {
-      throw PaymentMethodCreateParamsException("You must provide IBAN")
-    }
+    billingDetailsParams?.let {
+      val iban = getValOr(params, "iban", null) ?: run {
+        throw PaymentMethodCreateParamsException("You must provide IBAN")
+      }
 
-    val sepaParams = PaymentMethodCreateParams.SepaDebit(iban)
-    val createParams =
-      PaymentMethodCreateParams.create(sepaDebit = sepaParams, billingDetails = billingDetails)
+      val sepaParams = PaymentMethodCreateParams.SepaDebit(iban)
+      val createParams =
+        PaymentMethodCreateParams.create(
+          sepaDebit = sepaParams,
+          billingDetails = it
+        )
 
-    return ConfirmSetupIntentParams.create(
-      paymentMethodCreateParams = createParams,
-      clientSecret = clientSecret
-    )
+      return ConfirmSetupIntentParams.create(
+        paymentMethodCreateParams = createParams,
+        clientSecret = clientSecret
+      )
+    }
+
+    throw PaymentMethodCreateParamsException("You must provide billing details")
   }
 
   @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)
@@ -182,7 +188,7 @@ class PaymentMethodCreateParamsFactory(
 
   @Throws(PaymentMethodCreateParamsException::class)
   private fun createSofortPaymentConfirmParams(): ConfirmPaymentIntentParams {
-    val country = getValOr(params, "country", null)?.let { it } ?: run {
+    val country = getValOr(params, "country", null) ?: run {
       throw PaymentMethodCreateParamsException("You must provide bank account country")
     }
     val setupFutureUsage = mapToPaymentIntentFutureUsage(getValOr(params, "setupFutureUsage"))
@@ -230,100 +236,101 @@ class PaymentMethodCreateParamsFactory(
 
   @Throws(PaymentMethodCreateParamsException::class)
   private fun createBancontactPaymentConfirmParams(): ConfirmPaymentIntentParams {
-    val billingDetails = billingDetailsParams?.let { it } ?: run {
-      throw PaymentMethodCreateParamsException("You must provide billing details")
-    }
+    billingDetailsParams?.let {
+      val setupFutureUsage = mapToPaymentIntentFutureUsage(getValOr(params, "setupFutureUsage", null))
+      val params = PaymentMethodCreateParams.createBancontact(it)
 
-    val setupFutureUsage = mapToPaymentIntentFutureUsage(getValOr(params, "setupFutureUsage"))
-    val params = PaymentMethodCreateParams.createBancontact(billingDetails)
+      return ConfirmPaymentIntentParams
+        .createWithPaymentMethodCreateParams(
+          paymentMethodCreateParams = params,
+          clientSecret = clientSecret,
+          setupFutureUsage = setupFutureUsage,
+        )
+    }
 
-    return ConfirmPaymentIntentParams
-      .createWithPaymentMethodCreateParams(
-        paymentMethodCreateParams = params,
-        clientSecret = clientSecret,
-        setupFutureUsage = setupFutureUsage,
-      )
+    throw PaymentMethodCreateParamsException("You must provide billing details")
   }
 
   private fun createBancontactPaymentSetupParams(): ConfirmSetupIntentParams {
-    val billingDetails = billingDetailsParams?.let { it } ?: run {
-      throw PaymentMethodCreateParamsException("You must provide billing details")
-    }
+    billingDetailsParams?.let {
+      val params = PaymentMethodCreateParams.createBancontact(it)
 
-    val params = PaymentMethodCreateParams.createBancontact(billingDetails)
+      return ConfirmSetupIntentParams
+        .create(
+          paymentMethodCreateParams = params,
+          clientSecret = clientSecret,
+        )
+    }
 
-    return ConfirmSetupIntentParams
-      .create(
-        paymentMethodCreateParams = params,
-        clientSecret = clientSecret,
-      )
+    throw PaymentMethodCreateParamsException("You must provide billing details")
   }
 
   @Throws(PaymentMethodCreateParamsException::class)
   private fun createOXXOPaymentConfirmParams(): ConfirmPaymentIntentParams {
-    val billingDetails = billingDetailsParams?.let { it } ?: run {
-      throw PaymentMethodCreateParamsException("You must provide billing details")
-    }
+    billingDetailsParams?.let {
+      val params = PaymentMethodCreateParams.createOxxo(it)
 
-    val params = PaymentMethodCreateParams.createOxxo(billingDetails)
+      return ConfirmPaymentIntentParams
+        .createWithPaymentMethodCreateParams(
+          paymentMethodCreateParams = params,
+          clientSecret = clientSecret,
+        )
+    }
 
-    return ConfirmPaymentIntentParams
-      .createWithPaymentMethodCreateParams(
-        paymentMethodCreateParams = params,
-        clientSecret = clientSecret,
-      )
+    throw PaymentMethodCreateParamsException("You must provide billing details")
   }
 
   @Throws(PaymentMethodCreateParamsException::class)
   private fun createEPSPaymentConfirmParams(): ConfirmPaymentIntentParams {
-    val billingDetails = billingDetailsParams?.let { it } ?: run {
-      throw PaymentMethodCreateParamsException("You must provide billing details")
-    }
+    billingDetailsParams?.let {
+      val params = PaymentMethodCreateParams.createEps(it)
 
-    val params = PaymentMethodCreateParams.createEps(billingDetails)
+      return ConfirmPaymentIntentParams
+        .createWithPaymentMethodCreateParams(
+          paymentMethodCreateParams = params,
+          clientSecret = clientSecret,
+        )
+    }
 
-    return ConfirmPaymentIntentParams
-      .createWithPaymentMethodCreateParams(
-        paymentMethodCreateParams = params,
-        clientSecret = clientSecret,
-      )
+    throw PaymentMethodCreateParamsException("You must provide billing details")
   }
 
   @Throws(PaymentMethodCreateParamsException::class)
   private fun createGiropayPaymentConfirmParams(): ConfirmPaymentIntentParams {
-    val billingDetails = billingDetailsParams?.let { it } ?: run {
-      throw PaymentMethodCreateParamsException("You must provide billing details")
-    }
+    billingDetailsParams?.let {
+      val params = PaymentMethodCreateParams.createGiropay(it)
 
-    val params = PaymentMethodCreateParams.createGiropay(billingDetails)
+      return ConfirmPaymentIntentParams
+        .createWithPaymentMethodCreateParams(
+          paymentMethodCreateParams = params,
+          clientSecret = clientSecret,
+        )
+    }
 
-    return ConfirmPaymentIntentParams
-      .createWithPaymentMethodCreateParams(
-        paymentMethodCreateParams = params,
-        clientSecret = clientSecret,
-      )
+    throw PaymentMethodCreateParamsException("You must provide billing details")
   }
 
   @Throws(PaymentMethodCreateParamsException::class)
   private fun createSepaPaymentConfirmParams(): ConfirmPaymentIntentParams {
-    val billingDetails = billingDetailsParams?.let { it } ?: run {
-      throw PaymentMethodCreateParamsException("You must provide billing details")
-    }
-    val iban = getValOr(params, "iban", null)?.let { it } ?: run {
-      throw PaymentMethodCreateParamsException("You must provide IBAN")
+    billingDetailsParams?.let {
+      val iban = getValOr(params, "iban", null) ?: run {
+        throw PaymentMethodCreateParamsException("You must provide IBAN")
+      }
+      val setupFutureUsage = mapToPaymentIntentFutureUsage(getValOr(params, "setupFutureUsage"))
+      val params = PaymentMethodCreateParams.create(
+        sepaDebit = PaymentMethodCreateParams.SepaDebit(iban),
+        billingDetails = it
+      )
+
+      return ConfirmPaymentIntentParams
+        .createWithPaymentMethodCreateParams(
+          paymentMethodCreateParams = params,
+          clientSecret = clientSecret,
+          setupFutureUsage = setupFutureUsage
+        )
     }
-    val setupFutureUsage = mapToPaymentIntentFutureUsage(getValOr(params, "setupFutureUsage"))
-    val params = PaymentMethodCreateParams.create(
-      sepaDebit = PaymentMethodCreateParams.SepaDebit(iban),
-      billingDetails = billingDetails
-    )
 
-    return ConfirmPaymentIntentParams
-      .createWithPaymentMethodCreateParams(
-        paymentMethodCreateParams = params,
-        clientSecret = clientSecret,
-        setupFutureUsage = setupFutureUsage
-      )
+    throw PaymentMethodCreateParamsException("You must provide billing details")
   }
 
   @Throws(PaymentMethodCreateParamsException::class)
@@ -342,22 +349,22 @@ class PaymentMethodCreateParamsFactory(
 
   @Throws(PaymentMethodCreateParamsException::class)
   private fun createAfterpayClearpayPaymentConfirmParams(): ConfirmPaymentIntentParams {
-    val billingDetails = billingDetailsParams?.let { it } ?: run {
-      throw PaymentMethodCreateParamsException("You must provide billing details")
-    }
+    billingDetailsParams?.let {
+      val params = PaymentMethodCreateParams.createAfterpayClearpay(it)
 
-    val params = PaymentMethodCreateParams.createAfterpayClearpay(billingDetails)
+      return ConfirmPaymentIntentParams
+        .createWithPaymentMethodCreateParams(
+          paymentMethodCreateParams = params,
+          clientSecret = clientSecret,
+        )
+    }
 
-    return ConfirmPaymentIntentParams
-      .createWithPaymentMethodCreateParams(
-        paymentMethodCreateParams = params,
-        clientSecret = clientSecret,
-      )
+    throw PaymentMethodCreateParamsException("You must provide billing details")
   }
 
   @Throws(PaymentMethodCreateParamsException::class)
   private fun createAuBecsDebitPaymentConfirmParams(): ConfirmPaymentIntentParams {
-    val formDetails = getMapOrNull(params, "formDetails")?.let { it } ?: run {
+    val formDetails = getMapOrNull(params, "formDetails") ?: run {
       throw PaymentMethodCreateParamsException("You must provide form details")
     }
 
@@ -388,7 +395,7 @@ class PaymentMethodCreateParamsFactory(
 
   @Throws(PaymentMethodCreateParamsException::class)
   private fun createAuBecsDebitPaymentSetupParams(): ConfirmSetupIntentParams {
-    val formDetails = getMapOrNull(params, "formDetails")?.let { it } ?: run {
+    val formDetails = getMapOrNull(params, "formDetails") ?: run {
       throw PaymentMethodCreateParamsException("You must provide form details")
     }
 
@@ -417,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")
     }
@@ -434,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)