@stripe/stripe-react-native 0.8.0 → 0.11.0

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

@@ -41,6 +41,8 @@ enum class GooglePayErrorType {
   Failed, Canceled
 }
 
+class PaymentSheetAppearanceException(message: String) : Exception(message)
+
 internal fun mapError(code: String, message: String?, localizedMessage: String?, declineCode: String?, type: String?, stripeErrorCode: String?): WritableMap {
   val map: WritableMap = WritableNativeMap()
   val details: WritableMap = WritableNativeMap()
@@ -96,5 +98,16 @@ internal fun createError(code: String, error: Exception): WritableMap {
 }
 
 internal fun createError(code: String, error: Throwable): WritableMap {
-  return mapError(code, error.message, error.localizedMessage, null, null, null)
+  (error as? Exception)?.let {
+    return createError(
+      code,
+      it)
+  }
+  return mapError(
+    code,
+    error.message,
+    error.localizedMessage,
+    null,
+    null,
+    null)
 }

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

@@ -1,44 +1,30 @@
 package com.reactnativestripesdk
 
-import android.content.Intent
 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 androidx.localbroadcastmanager.content.LocalBroadcastManager
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.WritableNativeMap
 import com.stripe.android.googlepaylauncher.GooglePayEnvironment
 import com.stripe.android.googlepaylauncher.GooglePayLauncher
 import com.stripe.android.googlepaylauncher.GooglePayPaymentMethodLauncher
 
-class GooglePayFragment : Fragment() {
+class GooglePayFragment(private val initPromise: Promise) : Fragment() {
   private var googlePayLauncher: GooglePayLauncher? = null
   private var googlePayMethodLauncher: GooglePayPaymentMethodLauncher? = null
   private var isGooglePayMethodLauncherReady: Boolean = false
   private var isGooglePayLauncherReady: Boolean = false
-  private lateinit var localBroadcastManager: LocalBroadcastManager
-
-  private fun onGooglePayMethodLauncherReady(isReady: Boolean) {
-    isGooglePayMethodLauncherReady = true
-    if (isGooglePayLauncherReady) {
-      onGooglePayReady(isReady)
-    }
-  }
-
-  private fun onGooglePayLauncherReady(isReady: Boolean) {
-    isGooglePayLauncherReady = true
-    if (isGooglePayMethodLauncherReady) {
-      onGooglePayReady(isReady)
-    }
-  }
+  private var presentPromise: Promise? = null
+  private var createPaymentMethodPromise: Promise? = null
 
   override fun onCreateView(
     inflater: LayoutInflater,
     container: ViewGroup?,
     savedInstanceState: Bundle?
   ): View {
-    localBroadcastManager = LocalBroadcastManager.getInstance(requireContext())
     return FrameLayout(requireActivity()).also {
       it.visibility = View.GONE
     }
@@ -89,74 +75,104 @@ class GooglePayFragment : Fragment() {
     )
   }
 
-  fun presentForPaymentIntent(clientSecret: String) {
+  private fun onGooglePayMethodLauncherReady(isReady: Boolean) {
+    isGooglePayMethodLauncherReady = true
+    if (isGooglePayLauncherReady) {
+      onGooglePayReady(isReady)
+    }
+  }
+
+  private fun onGooglePayLauncherReady(isReady: Boolean) {
+    isGooglePayLauncherReady = true
+    if (isGooglePayMethodLauncherReady) {
+      onGooglePayReady(isReady)
+    }
+  }
+
+  private fun onGooglePayReady(isReady: Boolean) {
+    if (isReady) {
+      initPromise.resolve(WritableNativeMap())
+    } else {
+      initPromise.resolve(
+        createError(
+          GooglePayErrorType.Failed.toString(),
+          "Google Pay is not available on this device. You can use isGooglePaySupported to preemptively check for Google Pay support."
+        )
+      )
+    }
+  }
+
+  fun presentForPaymentIntent(clientSecret: String, promise: Promise) {
     val launcher = googlePayLauncher ?: run {
-      val intent = Intent(ON_GOOGLE_PAY_RESULT)
-      intent.putExtra("error", "GooglePayLauncher is not initialized.")
-      localBroadcastManager.sendBroadcast(intent)
+      promise.resolve(createError(GooglePayErrorType.Failed.toString(), "GooglePay is not initialized."))
       return
     }
     runCatching {
+      presentPromise = promise
       launcher.presentForPaymentIntent(clientSecret)
     }.onFailure {
-      val intent = Intent(ON_GOOGLE_PAY_RESULT)
-      intent.putExtra("error", it.localizedMessage)
-      localBroadcastManager.sendBroadcast(intent)
+      promise.resolve(createError(GooglePayErrorType.Failed.toString(), it))
     }
   }
 
-  fun presentForSetupIntent(clientSecret: String, currencyCode: String) {
+  fun presentForSetupIntent(clientSecret: String, currencyCode: String, promise: Promise) {
     val launcher = googlePayLauncher ?: run {
-      val intent = Intent(ON_GOOGLE_PAY_RESULT)
-      intent.putExtra("error", "GooglePayLauncher is not initialized.")
-      localBroadcastManager.sendBroadcast(intent)
+      promise.resolve(createError(GooglePayErrorType.Failed.toString(), "GooglePay is not initialized."))
       return
     }
     runCatching {
+      presentPromise = promise
       launcher.presentForSetupIntent(clientSecret, currencyCode)
     }.onFailure {
-      val intent = Intent(ON_GOOGLE_PAY_RESULT)
-      intent.putExtra("error", it.localizedMessage)
-      localBroadcastManager.sendBroadcast(intent)
+      promise.resolve(createError(GooglePayErrorType.Failed.toString(), it))
     }
   }
 
-  fun createPaymentMethod(currencyCode: String, amount: Int) {
+  fun createPaymentMethod(currencyCode: String, amount: Int, promise: Promise) {
     val launcher = googlePayMethodLauncher ?: run {
-      val intent = Intent(ON_GOOGLE_PAYMENT_METHOD_RESULT)
-      intent.putExtra("error", "GooglePayPaymentMethodLauncher is not initialized.")
-      localBroadcastManager.sendBroadcast(intent)
+      promise.resolve(createError(GooglePayErrorType.Failed.toString(), "GooglePayPaymentMethodLauncher is not initialized."))
       return
     }
 
     runCatching {
+      createPaymentMethodPromise = promise
       launcher.present(
         currencyCode = currencyCode,
         amount = amount
       )
     }.onFailure {
-      val intent = Intent(ON_GOOGLE_PAYMENT_METHOD_RESULT)
-      intent.putExtra("error", it.localizedMessage)
-      localBroadcastManager.sendBroadcast(intent)
+      promise.resolve(createError(GooglePayErrorType.Failed.toString(), it))
     }
   }
 
-  private fun onGooglePayReady(isReady: Boolean) {
-    val intent = Intent(ON_INIT_GOOGLE_PAY)
-    intent.putExtra("isReady", isReady)
-    localBroadcastManager.sendBroadcast(intent)
-  }
-
   private fun onGooglePayResult(result: GooglePayLauncher.Result) {
-    val intent = Intent(ON_GOOGLE_PAY_RESULT)
-    intent.putExtra("paymentResult", result)
-    localBroadcastManager.sendBroadcast(intent)
+    when (result) {
+      GooglePayLauncher.Result.Completed -> {
+        presentPromise?.resolve(WritableNativeMap())
+      }
+      GooglePayLauncher.Result.Canceled -> {
+        presentPromise?.resolve(createError(GooglePayErrorType.Canceled.toString(), "Google Pay has been canceled"))
+      }
+      is GooglePayLauncher.Result.Failed -> {
+        presentPromise?.resolve(createError(GooglePayErrorType.Failed.toString(), result.error))
+      }
+    }
+    presentPromise = null
   }
 
   private fun onGooglePayResult(result: GooglePayPaymentMethodLauncher.Result) {
-    val intent = Intent(ON_GOOGLE_PAYMENT_METHOD_RESULT)
-    intent.putExtra("paymentResult", result)
-    localBroadcastManager.sendBroadcast(intent)
+    when (result) {
+      is GooglePayPaymentMethodLauncher.Result.Completed -> {
+        createPaymentMethodPromise?.resolve(createResult("paymentMethod", mapFromPaymentMethod(result.paymentMethod)))
+      }
+      GooglePayPaymentMethodLauncher.Result.Canceled -> {
+        createPaymentMethodPromise?.resolve(createError(GooglePayErrorType.Canceled.toString(), "Google Pay has been canceled"))
+      }
+      is GooglePayPaymentMethodLauncher.Result.Failed -> {
+        createPaymentMethodPromise?.resolve(createError(GooglePayErrorType.Failed.toString(), result.error))
+      }
+    }
+    createPaymentMethodPromise = null
   }
 
   private fun mapToGooglePayLauncherBillingAddressConfig(formatString: String, isRequired: Boolean, isPhoneNumberRequired: Boolean): GooglePayLauncher.BillingAddressConfig {

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

@@ -37,7 +37,7 @@ class GooglePayPaymentMethodLauncherFragment(
       ),
       readyCallback = {
         promise.resolve(it)
-        (context.currentActivity as? AppCompatActivity)?.supportFragmentManager?.beginTransaction()?.remove(this)?.commit()
+        (context.currentActivity as? AppCompatActivity)?.supportFragmentManager?.beginTransaction()?.remove(this)?.commitAllowingStateLoss()
       },
       resultCallback = {}
     )

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

@@ -107,6 +107,7 @@ internal fun mapPaymentMethodType(type: PaymentMethod.Type?): String {
     PaymentMethod.Type.WeChatPay -> "WeChatPay"
     PaymentMethod.Type.Klarna -> "Klarna"
     PaymentMethod.Type.USBankAccount -> "USBankAccount"
+    PaymentMethod.Type.PayPal -> "PayPal"
     else -> "Unknown"
   }
 }
@@ -134,6 +135,7 @@ internal fun mapToPaymentMethodType(type: String?): PaymentMethod.Type? {
     "WeChatPay" -> PaymentMethod.Type.WeChatPay
     "Klarna" -> PaymentMethod.Type.Klarna
     "USBankAccount" -> PaymentMethod.Type.USBankAccount
+    "PayPal" -> PaymentMethod.Type.PayPal
     else -> null
   }
 }
@@ -317,7 +319,6 @@ internal fun mapFromPaymentMethod(paymentMethod: PaymentMethod): WritableMap {
 
   card.putString("brand", mapCardBrand(paymentMethod.card?.brand))
   card.putString("country", paymentMethod.card?.country)
-
   paymentMethod.card?.expiryYear?.let {
     card.putInt("expYear", it)
   }
@@ -326,6 +327,7 @@ internal fun mapFromPaymentMethod(paymentMethod: PaymentMethod): WritableMap {
   }
   card.putString("funding", paymentMethod.card?.funding)
   card.putString("last4", paymentMethod.card?.last4)
+  card.putString("fingerprint", paymentMethod.card?.fingerprint)
 
   sepaDebit.putString("bankCode", paymentMethod.sepaDebit?.bankCode)
   sepaDebit.putString("country", paymentMethod.sepaDebit?.country)
@@ -504,24 +506,25 @@ fun getValOr(map: ReadableMap?, key: String, default: String? = ""): String? {
   } ?: default
 }
 
-internal fun mapToAddress(addressMap: ReadableMap?, cardAddress: Address?): Address? {
-  if (addressMap == null) {
-    return null
-  }
+internal fun mapToAddress(addressMap: ReadableMap?, cardAddress: Address?): Address {
   val address = Address.Builder()
-    .setPostalCode(getValOr(addressMap, "postalCode"))
-    .setCity(getValOr(addressMap, "city"))
-    .setCountry(getValOr(addressMap, "country"))
-    .setLine1(getValOr(addressMap, "line1"))
-    .setLine2(getValOr(addressMap, "line2"))
-    .setState(getValOr(addressMap, "state"))
-
-  cardAddress?.let { ca ->
-    ca.postalCode?.let {
-      address.setPostalCode(it)
+
+  addressMap?.let {
+    address
+      .setPostalCode(getValOr(it, "postalCode"))
+      .setCity(getValOr(it, "city"))
+      .setCountry(getValOr(it, "country"))
+      .setLine1(getValOr(it, "line1"))
+      .setLine2(getValOr(it, "line2"))
+      .setState(getValOr(it, "state"))
+  }
+
+  cardAddress?.let {
+    if (!it.postalCode.isNullOrEmpty()) {
+      address.setPostalCode(it.postalCode)
     }
-    ca.country?.let {
-      address.setCountry(it)
+    if (!it.country.isNullOrEmpty()) {
+      address.setCountry(it.country)
     }
   }
 
@@ -532,19 +535,17 @@ internal fun mapToBillingDetails(billingDetails: ReadableMap?, cardAddress: Addr
   if (billingDetails == null && cardAddress == null) {
     return null
   }
-  var address: Address? = null
+  val address = mapToAddress(getMapOrNull(billingDetails, "address"), cardAddress)
   val paymentMethodBillingDetailsBuilder =  PaymentMethod.BillingDetails.Builder()
 
   if (billingDetails != null) {
-    address = mapToAddress(getMapOrNull(billingDetails, "address"), cardAddress)
-
     paymentMethodBillingDetailsBuilder
       .setName(getValOr(billingDetails, "name"))
       .setPhone(getValOr(billingDetails, "phone"))
       .setEmail(getValOr(billingDetails, "email"))
   }
 
-  paymentMethodBillingDetailsBuilder.setAddress(address ?: Address.Builder().build())
+  paymentMethodBillingDetailsBuilder.setAddress(address)
   return paymentMethodBillingDetailsBuilder.build()
 }
 
@@ -554,7 +555,6 @@ internal fun mapToShippingDetails(shippingDetails: ReadableMap?): ConfirmPayment
   }
 
   val address = mapToAddress(getMapOrNull(shippingDetails, "address"), null)
-    ?: Address.Builder().build()
 
   return ConfirmPaymentIntentParams.Shipping(
     name = getValOr(shippingDetails, "name") ?: "",

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

@@ -70,7 +70,7 @@ class PaymentLauncherFragment(
             ?: throw Exception("No promise is set to handle payment results.")
         }
         is PaymentResult.Failed -> {
-          promise?.resolve(createError(ConfirmPaymentErrorType.Failed.toString(), paymentResult.throwable.localizedMessage))
+          promise?.resolve(createError(ConfirmPaymentErrorType.Failed.toString(), paymentResult.throwable))
             ?: throw Exception("No promise is set to handle payment results.")
         }
       }

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

@@ -32,6 +32,7 @@ class PaymentMethodCreateParamsFactory(
         PaymentMethod.Type.AuBecsDebit -> createAuBecsDebitPaymentConfirmParams()
         PaymentMethod.Type.Klarna -> createKlarnaPaymentConfirmParams()
         PaymentMethod.Type.USBankAccount -> createUSBankAccountPaymentConfirmParams()
+        PaymentMethod.Type.PayPal -> createPayPalPaymentConfirmParams()
         else -> {
           throw Exception("This paymentMethodType is not supported yet")
         }
@@ -52,6 +53,7 @@ class PaymentMethodCreateParamsFactory(
         PaymentMethod.Type.SepaDebit -> createSepaPaymentSetupParams()
         PaymentMethod.Type.AuBecsDebit -> createAuBecsDebitPaymentSetupParams()
         PaymentMethod.Type.USBankAccount -> createUSBankAccountPaymentSetupParams()
+        PaymentMethod.Type.PayPal -> createPayPalPaymentSetupParams()
         else -> {
           throw Exception("This paymentMethodType is not supported yet")
         }
@@ -172,14 +174,31 @@ class PaymentMethodCreateParamsFactory(
 
   @Throws(PaymentMethodCreateParamsException::class)
   private fun createCardPaymentSetupParams(): ConfirmSetupIntentParams {
+    val paymentMethodId = getValOr(paymentMethodData, "paymentMethodId", null)
+    val token = getValOr(paymentMethodData, "token", null)
     val cardParams = cardFieldView?.cardParams ?: cardFormView?.cardParams
-    ?: throw PaymentMethodCreateParamsException("Card details not complete")
 
-    val paymentMethodCreateParams =
-      PaymentMethodCreateParams.create(cardParams, billingDetailsParams)
+    if (paymentMethodId != null) {
+      return ConfirmSetupIntentParams.create(
+        paymentMethodId,
+        clientSecret
+      )
+    }
 
-    return ConfirmSetupIntentParams
-      .create(paymentMethodCreateParams, clientSecret)
+    val paymentMethodCreateParams =
+      if (token != null)
+        PaymentMethodCreateParams.create(PaymentMethodCreateParams.Card.create(token), billingDetailsParams)
+      else if (cardParams != null)
+        PaymentMethodCreateParams.create(cardParams, billingDetailsParams)
+      else
+        null
+
+    if (paymentMethodCreateParams != null) {
+      return ConfirmSetupIntentParams
+        .create(paymentMethodCreateParams, clientSecret)
+    } else {
+      throw PaymentMethodCreateParamsException("Card details not complete")
+    }
   }
 
   @Throws(PaymentMethodCreateParamsException::class)
@@ -450,6 +469,10 @@ class PaymentMethodCreateParamsFactory(
     }
   }
 
+  @Throws(PaymentMethodCreateParamsException::class)
+  private fun createPayPalPaymentSetupParams(): ConfirmSetupIntentParams {
+    throw PaymentMethodCreateParamsException("PayPal is not yet supported through SetupIntents.")
+  }
 
   @Throws(PaymentMethodCreateParamsException::class)
   private fun createKlarnaPaymentConfirmParams(): ConfirmPaymentIntentParams {
@@ -492,6 +515,14 @@ class PaymentMethodCreateParamsFactory(
     }
   }
 
+  @Throws(PaymentMethodCreateParamsException::class)
+  private fun createPayPalPaymentConfirmParams(): ConfirmPaymentIntentParams {
+    return ConfirmPaymentIntentParams.createWithPaymentMethodCreateParams(
+      paymentMethodCreateParams = PaymentMethodCreateParams.createPayPal(null),
+      clientSecret = clientSecret,
+    )
+  }
+
   @Throws(PaymentMethodCreateParamsException::class)
   private fun createUSBankAccountParams(params: ReadableMap): PaymentMethodCreateParams {
     val accountNumber = getValOr(params, "accountNumber", null)

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

@@ -0,0 +1,173 @@
+package com.reactnativestripesdk
+
+import android.graphics.Color
+import android.os.Bundle
+import com.stripe.android.paymentsheet.PaymentSheet
+
+fun PaymentSheetFragment.buildPaymentSheetAppearance(userParams: Bundle?): PaymentSheet.Appearance {
+  val colorParams = userParams?.getBundle(PaymentSheetAppearanceKeys.COLORS)
+  val lightColorParams = colorParams?.getBundle(PaymentSheetAppearanceKeys.LIGHT) ?: colorParams
+  val darkColorParams = colorParams?.getBundle(PaymentSheetAppearanceKeys.DARK) ?: colorParams
+
+  return PaymentSheet.Appearance(
+    typography = buildTypography(userParams?.getBundle(PaymentSheetAppearanceKeys.FONT)),
+    colorsLight = buildColors(lightColorParams, PaymentSheet.Colors.defaultLight),
+    colorsDark = buildColors(darkColorParams, PaymentSheet.Colors.defaultDark),
+    shapes = buildShapes(userParams?.getBundle(PaymentSheetAppearanceKeys.SHAPES)),
+    primaryButton = buildPrimaryButton(userParams?.getBundle(PaymentSheetAppearanceKeys.PRIMARY_BUTTON))
+  )
+}
+
+private fun PaymentSheetFragment.buildTypography(fontParams: Bundle?): PaymentSheet.Typography {
+  return PaymentSheet.Typography.default.copy(
+    sizeScaleFactor = getFloatOr(fontParams, PaymentSheetAppearanceKeys.SCALE, PaymentSheet.Typography.default.sizeScaleFactor),
+    fontResId = getFontResId(fontParams, PaymentSheetAppearanceKeys.FAMILY, PaymentSheet.Typography.default.fontResId)
+  )
+}
+
+@Throws(PaymentSheetAppearanceException::class)
+private fun colorFromHexOrDefault(hexString: String?, default: Int): Int {
+  return hexString?.trim()?.replace("#","")?.let {
+    if (it.length == 6 || it.length == 8) {
+      return Color.parseColor("#$it")
+    } else throw PaymentSheetAppearanceException("Failed to set Payment Sheet appearance. Expected hex string of length 6 or 8, but received: $it")
+  } ?: run {
+    return default
+  }
+}
+
+private fun buildColors(colorParams: Bundle?, default: PaymentSheet.Colors): PaymentSheet.Colors {
+  if (colorParams == null) {
+    return default
+  }
+
+  return default.copy(
+    primary = colorFromHexOrDefault(colorParams.getString(PaymentSheetAppearanceKeys.PRIMARY), default.primary),
+    surface = colorFromHexOrDefault(colorParams.getString(PaymentSheetAppearanceKeys.BACKGROUND), default.surface),
+    component = colorFromHexOrDefault(colorParams.getString(PaymentSheetAppearanceKeys.COMPONENT_BACKGROUND), default.component),
+    componentBorder = colorFromHexOrDefault(colorParams.getString(PaymentSheetAppearanceKeys.COMPONENT_BORDER), default.componentBorder),
+    componentDivider = colorFromHexOrDefault(colorParams.getString(PaymentSheetAppearanceKeys.COMPONENT_DIVIDER), default.componentDivider),
+    onComponent = colorFromHexOrDefault(colorParams.getString(PaymentSheetAppearanceKeys.COMPONENT_TEXT), default.onComponent),
+    onSurface = colorFromHexOrDefault(colorParams.getString(PaymentSheetAppearanceKeys.PRIMARY_TEXT), default.onSurface),
+    subtitle = colorFromHexOrDefault(colorParams.getString(PaymentSheetAppearanceKeys.SECONDARY_TEXT), default.subtitle),
+    placeholderText = colorFromHexOrDefault(colorParams.getString(PaymentSheetAppearanceKeys.PLACEHOLDER_TEXT), default.placeholderText),
+    appBarIcon = colorFromHexOrDefault(colorParams.getString(PaymentSheetAppearanceKeys.ICON), default.appBarIcon),
+    error = colorFromHexOrDefault(colorParams.getString(PaymentSheetAppearanceKeys.ERROR), default.error),
+  )
+}
+
+private fun buildShapes(shapeParams: Bundle?): PaymentSheet.Shapes {
+  return PaymentSheet.Shapes.default.copy(
+    cornerRadiusDp = getFloatOr(shapeParams, PaymentSheetAppearanceKeys.BORDER_RADIUS, PaymentSheet.Shapes.default.cornerRadiusDp),
+    borderStrokeWidthDp = getFloatOr(shapeParams, PaymentSheetAppearanceKeys.BORDER_WIDTH, PaymentSheet.Shapes.default.borderStrokeWidthDp)
+  )
+}
+
+private fun PaymentSheetFragment.buildPrimaryButton(params: Bundle?): PaymentSheet.PrimaryButton {
+  if (params == null) {
+    return PaymentSheet.PrimaryButton()
+  }
+
+  val fontParams = params.getBundle(PaymentSheetAppearanceKeys.FONT) ?: Bundle.EMPTY
+  val shapeParams = params.getBundle(PaymentSheetAppearanceKeys.SHAPES) ?: Bundle.EMPTY
+  val colorParams = params.getBundle(PaymentSheetAppearanceKeys.COLORS) ?: Bundle.EMPTY
+  val lightColorParams = colorParams.getBundle(PaymentSheetAppearanceKeys.LIGHT) ?: colorParams
+  val darkColorParams = colorParams.getBundle(PaymentSheetAppearanceKeys.DARK) ?: colorParams
+
+  return PaymentSheet.PrimaryButton(
+    colorsLight = buildPrimaryButtonColors(lightColorParams, PaymentSheet.PrimaryButtonColors.defaultLight),
+    colorsDark = buildPrimaryButtonColors(darkColorParams, PaymentSheet.PrimaryButtonColors.defaultDark),
+    shape = PaymentSheet.PrimaryButtonShape(
+      cornerRadiusDp = getFloatOrNull(shapeParams, PaymentSheetAppearanceKeys.BORDER_RADIUS),
+      borderStrokeWidthDp = getFloatOrNull(shapeParams, PaymentSheetAppearanceKeys.BORDER_WIDTH),
+    ),
+    typography = PaymentSheet.PrimaryButtonTypography(
+      fontResId = getFontResId(fontParams, PaymentSheetAppearanceKeys.FAMILY, null)
+    )
+  )
+}
+
+@Throws(PaymentSheetAppearanceException::class)
+private fun buildPrimaryButtonColors(colorParams: Bundle, default: PaymentSheet.PrimaryButtonColors): PaymentSheet.PrimaryButtonColors {
+  return PaymentSheet.PrimaryButtonColors(
+    background = colorParams.getString(PaymentSheetAppearanceKeys.BACKGROUND)?.trim()?.replace("#", "")?.let {
+      if (it.length == 6 || it.length == 8) {
+        Color.parseColor("#$it")
+      } else throw PaymentSheetAppearanceException("Failed to set Payment Sheet appearance. Expected hex string of length 6 or 8, but received: $it")
+    } ?: run {
+      null
+    },
+    onBackground = colorFromHexOrDefault(colorParams.getString(PaymentSheetAppearanceKeys.TEXT), default.onBackground),
+    border = colorFromHexOrDefault(colorParams.getString(PaymentSheetAppearanceKeys.BORDER), default.border),
+  )
+}
+
+private fun getFloatOr(bundle: Bundle?, key: String, defaultValue: Float): Float {
+  return if (bundle?.containsKey(key) == true) {
+    bundle.getFloat(key, bundle.getInt(key).toFloat())
+  } else {
+    defaultValue
+  }
+}
+
+private fun getFloatOrNull(bundle: Bundle?, key: String): Float? {
+  return if (bundle?.containsKey(key) == true) {
+    bundle.getFloat(key, bundle.getInt(key).toFloat())
+  } else {
+    null
+  }
+}
+
+@Throws(PaymentSheetAppearanceException::class)
+private fun PaymentSheetFragment.getFontResId(bundle: Bundle?, key: String, defaultValue: Int?): Int? {
+  val fontErrorPrefix = "Encountered an error when setting a custom font:"
+  if (bundle?.containsKey(key) != true) {
+    return defaultValue
+  }
+
+  val fontFileName = bundle.getString(key)
+          ?: throw PaymentSheetAppearanceException("$fontErrorPrefix expected String for font.$key, but received null.")
+  if (Regex("[^a-z0-9]").containsMatchIn(fontFileName)) {
+    throw PaymentSheetAppearanceException(
+      "$fontErrorPrefix appearance.font.$key should only contain lowercase alphanumeric characters on Android, but received '$fontFileName'. This value must match the filename in android/app/src/main/res/font"
+    )
+  }
+
+  val id = resources.getIdentifier(fontFileName, "font", context?.packageName)
+  if (id == 0) {
+    throw PaymentSheetAppearanceException("$fontErrorPrefix Failed to find font: $fontFileName")
+  } else {
+    return id
+  }
+}
+
+private class PaymentSheetAppearanceKeys {
+  companion object {
+    const val COLORS = "colors"
+    const val LIGHT = "light"
+    const val DARK = "dark"
+    const val PRIMARY = "primary"
+    const val BACKGROUND = "background"
+    const val COMPONENT_BACKGROUND = "componentBackground"
+    const val COMPONENT_BORDER = "componentBorder"
+    const val COMPONENT_DIVIDER = "componentDivider"
+    const val COMPONENT_TEXT = "componentText"
+    const val PRIMARY_TEXT = "primaryText"
+    const val SECONDARY_TEXT = "secondaryText"
+    const val PLACEHOLDER_TEXT = "placeholderText"
+    const val ICON = "icon"
+    const val ERROR = "error"
+
+    const val FONT = "font"
+    const val FAMILY = "family"
+    const val SCALE = "scale"
+
+    const val SHAPES = "shapes"
+    const val BORDER_RADIUS = "borderRadius"
+    const val BORDER_WIDTH = "borderWidth"
+
+    const val PRIMARY_BUTTON = "primaryButton"
+    const val TEXT = "text"
+    const val BORDER = "border"
+  }
+}