@stripe/stripe-react-native 0.28.0 → 0.30.0

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

@@ -17,16 +17,15 @@ import android.widget.FrameLayout
 import androidx.appcompat.content.res.AppCompatResources
 import androidx.core.graphics.drawable.DrawableCompat
 import androidx.fragment.app.Fragment
-import com.facebook.react.bridge.Promise
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.WritableMap
-import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.bridge.*
 import com.reactnativestripesdk.addresssheet.AddressSheetView
 import com.reactnativestripesdk.utils.*
 import com.reactnativestripesdk.utils.createError
 import com.reactnativestripesdk.utils.createResult
 import com.stripe.android.paymentsheet.*
+import kotlinx.coroutines.CompletableDeferred
 import java.io.ByteArrayOutputStream
+import kotlin.Exception
 
 class PaymentSheetFragment(
   private val context: ReactApplicationContext,
@@ -36,10 +35,12 @@ class PaymentSheetFragment(
   private var flowController: PaymentSheet.FlowController? = null
   private var paymentIntentClientSecret: String? = null
   private var setupIntentClientSecret: String? = null
+  private var intentConfiguration: PaymentSheet.IntentConfiguration? = null
   private lateinit var paymentSheetConfiguration: PaymentSheet.Configuration
   private var confirmPromise: Promise? = null
   private var presentPromise: Promise? = null
   private var paymentSheetTimedOut = false
+  internal val paymentSheetIntentCreationCallback = CompletableDeferred<ReadableMap>()
 
   override fun onCreateView(
     inflater: LayoutInflater,
@@ -67,6 +68,12 @@ class PaymentSheetFragment(
     val billingConfigParams = arguments?.getBundle("billingDetailsCollectionConfiguration")
     paymentIntentClientSecret = arguments?.getString("paymentIntentClientSecret").orEmpty()
     setupIntentClientSecret = arguments?.getString("setupIntentClientSecret").orEmpty()
+    intentConfiguration = try {
+      buildIntentConfiguration(arguments?.getBundle("intentConfiguration"))
+    } catch (error: PaymentSheetException) {
+      initPromise.resolve(createError(ErrorType.Failed.toString(), error))
+      return
+    }
     val appearance = try {
       buildPaymentSheetAppearance(arguments?.getBundle("appearance"), context)
     } catch (error: PaymentSheetAppearanceException) {
@@ -120,6 +127,34 @@ class PaymentSheetFragment(
       }
     }
 
+    val createIntentCallback = CreateIntentCallback {  paymentMethod, shouldSavePaymentMethod ->
+      val stripeSdkModule: StripeSdkModule? = context.getNativeModule(StripeSdkModule::class.java)
+      if (stripeSdkModule == null || stripeSdkModule.eventListenerCount == 0) {
+        return@CreateIntentCallback CreateIntentResult.Failure(
+          cause = Exception("Tried to call confirmHandler, but no callback was found. Please file an issue: https://github.com/stripe/stripe-react-native/issues"),
+          displayMessage = "An unexpected error occurred"
+          )
+      }
+      val params = Arguments.createMap().apply {
+        putMap("paymentMethod", mapFromPaymentMethod(paymentMethod))
+        putBoolean("shouldSavePaymentMethod", shouldSavePaymentMethod)
+      }
+
+      stripeSdkModule.sendEvent(context, "onConfirmHandlerCallback", params)
+
+      val resultFromJavascript = paymentSheetIntentCreationCallback.await()
+
+      return@CreateIntentCallback resultFromJavascript.getString("clientSecret")?.let {
+        CreateIntentResult.Success(clientSecret = it)
+      } ?: run {
+        val errorMap = resultFromJavascript.getMap("error")
+        CreateIntentResult.Failure(
+          cause = Exception(errorMap?.getString("message")),
+          displayMessage = errorMap?.getString("localizedMessage")
+        )
+      }
+    }
+
     val billingDetailsConfig = PaymentSheet.BillingDetailsCollectionConfiguration(
       name = mapToCollectionMode(billingConfigParams?.getString("name")),
       phone = mapToCollectionMode(billingConfigParams?.getString("phone")),
@@ -162,10 +197,34 @@ class PaymentSheetFragment(
     )
 
     if (arguments?.getBoolean("customFlow") == true) {
-      flowController = PaymentSheet.FlowController.create(this, paymentOptionCallback, paymentResultCallback)
+      flowController = if (intentConfiguration != null) {
+        PaymentSheet.FlowController.create(
+          this,
+          paymentOptionCallback = paymentOptionCallback,
+          createIntentCallback = createIntentCallback,
+          paymentResultCallback = paymentResultCallback
+        )
+      } else {
+        PaymentSheet.FlowController.create(
+          this,
+          paymentOptionCallback = paymentOptionCallback,
+          paymentResultCallback = paymentResultCallback
+        )
+      }
       configureFlowController()
     } else {
-      paymentSheet = PaymentSheet(this, paymentResultCallback)
+      paymentSheet = if (intentConfiguration != null) {
+        PaymentSheet(
+          this,
+          createIntentCallback = createIntentCallback,
+          paymentResultCallback = paymentResultCallback
+        )
+      } else {
+        PaymentSheet(
+          this,
+          callback = paymentResultCallback
+        )
+      }
       initPromise.resolve(WritableNativeMap())
     }
   }
@@ -177,6 +236,11 @@ class PaymentSheetFragment(
         paymentSheet?.presentWithPaymentIntent(paymentIntentClientSecret!!, paymentSheetConfiguration)
       } else if (!setupIntentClientSecret.isNullOrEmpty()) {
         paymentSheet?.presentWithSetupIntent(setupIntentClientSecret!!, paymentSheetConfiguration)
+      } else if (intentConfiguration != null) {
+        paymentSheet?.presentWithIntentConfiguration(
+          intentConfiguration = intentConfiguration!!,
+          configuration = paymentSheetConfiguration
+        )
       }
     } else if(flowController != null) {
       flowController?.presentPaymentOptions()
@@ -253,6 +317,15 @@ class PaymentSheetFragment(
         configuration = paymentSheetConfiguration,
         callback = onFlowControllerConfigure
       )
+    } else if (intentConfiguration != null) {
+      flowController?.configureWithIntentConfiguration(
+        intentConfiguration = intentConfiguration!!,
+        configuration = paymentSheetConfiguration,
+        callback = onFlowControllerConfigure
+      )
+    } else {
+      initPromise.resolve(createError(ErrorType.Failed.toString(), "One of `paymentIntentClientSecret`, `setupIntentClientSecret`, or `intentConfiguration` is required"))
+      return
     }
   }
 
@@ -287,6 +360,41 @@ class PaymentSheetFragment(
         currencyCode = currencyCode
       )
     }
+
+    @Throws(PaymentSheetException::class)
+    private fun buildIntentConfiguration(intentConfigurationParams: Bundle?): PaymentSheet.IntentConfiguration? {
+      if (intentConfigurationParams == null) {
+        return null
+      }
+      val modeParams = intentConfigurationParams.getBundle("mode")
+              ?: throw PaymentSheetException("If `intentConfiguration` is provided, `intentConfiguration.mode` is required")
+
+      return PaymentSheet.IntentConfiguration(
+        mode = buildIntentConfigurationMode(modeParams),
+        paymentMethodTypes = intentConfigurationParams.getStringArrayList("paymentMethodTypes")?.toList() ?: emptyList(),
+      )
+    }
+
+    private fun buildIntentConfigurationMode(modeParams: Bundle): PaymentSheet.IntentConfiguration.Mode {
+      val currencyCode = modeParams.getString("currencyCode")
+        ?: throw PaymentSheetException("You must provide a value to intentConfiguration.mode.currencyCode")
+
+      return if (modeParams.containsKey("amount")) {
+        PaymentSheet.IntentConfiguration.Mode.Payment(
+          amount = modeParams.getInt("amount").toLong(),
+          currency = currencyCode,
+          setupFutureUse = mapToSetupFutureUse(modeParams.getString("setupFutureUsage")),
+          captureMethod = mapToCaptureMethod(modeParams.getString("captureMethod")),
+        )
+      } else {
+        val setupFutureUsage = mapToSetupFutureUse(modeParams.getString("setupFutureUsage"))
+          ?: throw PaymentSheetException("You must provide a value to intentConfiguration.mode.setupFutureUsage")
+        PaymentSheet.IntentConfiguration.Mode.Setup(
+          currency = currencyCode,
+          setupFutureUse = setupFutureUsage
+        )
+      }
+    }
   }
 }
 
@@ -329,3 +437,20 @@ fun mapToAddressCollectionMode(str: String?): PaymentSheet.BillingDetailsCollect
     else -> PaymentSheet.BillingDetailsCollectionConfiguration.AddressCollectionMode.Automatic
   }
 }
+
+fun mapToSetupFutureUse(type: String?): PaymentSheet.IntentConfiguration.SetupFutureUse? {
+  return when (type) {
+    "OffSession" ->  PaymentSheet.IntentConfiguration.SetupFutureUse.OffSession
+    "OnSession" ->  PaymentSheet.IntentConfiguration.SetupFutureUse.OnSession
+    else ->  null
+  }
+}
+
+fun mapToCaptureMethod(type: String?): PaymentSheet.IntentConfiguration.CaptureMethod {
+  return when (type) {
+    "Automatic" ->  PaymentSheet.IntentConfiguration.CaptureMethod.Automatic
+    "Manual" ->  PaymentSheet.IntentConfiguration.CaptureMethod.Manual
+    "AutomaticAsync" ->  PaymentSheet.IntentConfiguration.CaptureMethod.AutomaticAsync
+    else ->  PaymentSheet.IntentConfiguration.CaptureMethod.Automatic
+  }
+}

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

@@ -7,6 +7,7 @@ import android.util.Log
 import androidx.fragment.app.FragmentActivity
 import com.facebook.react.bridge.*
 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.*
@@ -47,6 +48,8 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   private var paymentLauncherFragment: PaymentLauncherFragment? = null
   private var collectBankAccountLauncherFragment: CollectBankAccountLauncherFragment? = null
 
+  internal var eventListenerCount = 0
+
   // 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>
@@ -204,6 +207,16 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
     promise.resolve(null)
   }
 
+  @ReactMethod
+  fun intentCreationCallback(params: ReadableMap, promise: Promise) {
+    if (paymentSheetFragment == null) {
+      promise.resolve(PaymentSheetFragment.createMissingInitError())
+      return
+    }
+
+    paymentSheetFragment?.paymentSheetIntentCreationCallback?.complete(params)
+  }
+
   private fun payWithFpx() {
     getCurrentActivityOrResolveWithError(confirmPromise)?.let {
       AddPaymentMethodActivityStarter(it)
@@ -393,7 +406,7 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
 
   @ReactMethod
   fun handleNextAction(paymentIntentClientSecret: String, promise: Promise) {
-    paymentLauncherFragment = PaymentLauncherFragment.forNextAction(
+    paymentLauncherFragment = PaymentLauncherFragment.forNextActionPayment(
       context = reactApplicationContext,
       stripe,
       publishableKey,
@@ -403,6 +416,18 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
     )
   }
 
+  @ReactMethod
+  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
 //  private fun payWithWeChatPay(paymentIntentClientSecret: String, appId: String) {
 //    val activity = currentActivity as ComponentActivity
@@ -866,14 +891,24 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
     }
   }
 
-  /**
-   * We need the following in order to avoid some annoying console.warns() from our Apple Pay event listeners. Otherwise,
-   * we'd have to put our users through some annoying (if Platform.OS...) logic & null-handling logic.
-   */
   @ReactMethod
-  fun addListener(eventName: String) {}
+  fun addListener(eventName: String) {
+    eventListenerCount++
+  }
+
   @ReactMethod
-  fun removeListeners(count: Int) {}
+  fun removeListeners(count: Int) {
+    eventListenerCount -= count
+    if (eventListenerCount < 0) {
+      eventListenerCount = 0
+    }
+  }
+
+  internal fun sendEvent(reactContext: ReactContext, eventName: String, params: WritableMap) {
+    reactContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(eventName, params)
+  }
 
   /**
    * Safely get and cast the current activity as an AppCompatActivity. If that fails, the promise

package/android/src/main/java/com/reactnativestripesdk/pushprovisioning/TapAndPayProxy.kt

@@ -91,9 +91,16 @@ object TapAndPayProxy {
         result.putString(
           "id",
           tokenInfoClass.getMethod("getIssuerTokenId").invoke(it) as String)
+        val fpan = tokenInfoClass.getMethod("getFpanLastFour").invoke(it) as String
         result.putString(
           "cardLastFour",
-          tokenInfoClass.getMethod("getFpanLastFour").invoke(it) as String)
+          fpan)
+        result.putString(
+          "fpanLastFour",
+          fpan)
+        result.putString(
+          "dpanLastFour",
+          tokenInfoClass.getMethod("getDpanLastFour").invoke(it) as String)
         result.putString(
           "issuer",
           tokenInfoClass.getMethod("getIssuerName").invoke(it) as String)

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

@@ -43,6 +43,8 @@ enum class GooglePayErrorType {
 
 class PaymentSheetAppearanceException(message: String) : Exception(message)
 
+class PaymentSheetException(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()

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

@@ -856,7 +856,20 @@ fun toBundleObject(readableMap: ReadableMap?): Bundle {
       }
       ReadableType.String -> result.putString(key, readableMap.getString(key))
       ReadableType.Map -> result.putBundle(key, toBundleObject(readableMap.getMap(key)))
-      ReadableType.Array -> Log.e("toBundleException", "Cannot put arrays of objects into bundles. Failed on: $key.")
+      ReadableType.Array -> {
+        val list = readableMap.getArray(key)?.toArrayList()
+        if (list == null) {
+          result.putString(key, null)
+        } else if (list.isEmpty()) {
+          result.putStringArrayList(key, ArrayList())
+        } else {
+          when (list.first()) {
+            is String -> result.putStringArrayList(key, list as java.util.ArrayList<String>)
+            is Int -> result.putIntegerArrayList(key, list as java.util.ArrayList<Int>)
+            else -> Log.e("toBundleException", "Cannot put arrays of objects into bundles. Failed on: $key.")
+          }
+        }
+      }
       else -> Log.e("toBundleException", "Could not convert object with key: $key.")
     }
   }

package/ios/ApplePayButtonView.swift

@@ -17,25 +17,11 @@ class ApplePayButtonView: UIView {
     @objc var borderRadius: NSNumber?
     @objc var disabled = false
     
-    func doesNothing(_: Optional<Dictionary<AnyHashable, Any>>) {
-        return
-    }
-    
     @objc func handleApplePayButtonTapped() {
-        if onPressAction != nil {
-            onPressAction!(["true": true])
-            // JS Callbacks are all no-ops since in legacy code (useApplePay hook),
-            // this behavior is controlled via the onDidSetShippingMethod and onDidSetShippingContact
-            // events
-            stripeSdk?.shippingMethodUpdateJSCallback = doesNothing
-            stripeSdk?.shippingContactUpdateJSCallback = doesNothing
-            stripeSdk?.couponCodeEnteredJSCallback = doesNothing
-        } else {
-            stripeSdk?.shippingMethodUpdateJSCallback = onShippingMethodSelectedAction
-            stripeSdk?.shippingContactUpdateJSCallback = onShippingContactSelectedAction
-            stripeSdk?.couponCodeEnteredJSCallback = onCouponCodeEnteredAction
-            stripeSdk?.platformPayOrderTrackingJSCallback = onOrderTrackingAction
-        }
+        stripeSdk?.shippingMethodUpdateJSCallback = onShippingMethodSelectedAction
+        stripeSdk?.shippingContactUpdateJSCallback = onShippingContactSelectedAction
+        stripeSdk?.couponCodeEnteredJSCallback = onCouponCodeEnteredAction
+        stripeSdk?.platformPayOrderTrackingJSCallback = onOrderTrackingAction
     }
     
     override func didSetProps(_ changedProps: [String]!) {

package/ios/ApplePayViewController.swift

@@ -122,10 +122,6 @@ extension StripeSdk : PKPaymentAuthorizationViewControllerDelegate, STPApplePayC
         didSelect shippingMethod: PKShippingMethod,
         handler: @escaping (PKPaymentRequestShippingMethodUpdate) -> Void
     ) {
-        if (self.hasLegacyApplePayListeners) {
-            // Legacy, remove when useApplePay hook is removed
-            sendEvent(withName: "onDidSetShippingMethod", body: ["shippingMethod": Mappers.mapFromShippingMethod(shippingMethod: shippingMethod)])
-        }
         if let callback = self.shippingMethodUpdateJSCallback {
             self.shippingMethodUpdateCompletion = handler
             callback(["shippingMethod": Mappers.mapFromShippingMethod(shippingMethod: shippingMethod)])
@@ -141,10 +137,6 @@ extension StripeSdk : PKPaymentAuthorizationViewControllerDelegate, STPApplePayC
         didSelectShippingContact contact: PKContact,
         handler: @escaping (PKPaymentRequestShippingContactUpdate) -> Void
     ) {
-        if (self.hasLegacyApplePayListeners) {
-            // Legacy, remove when useApplePay hook is removed
-            sendEvent(withName: "onDidSetShippingContact", body: ["shippingContact": Mappers.mapFromShippingContact(shippingContact: contact)])
-        }
         if let callback = self.shippingContactUpdateJSCallback {
             self.shippingContactUpdateCompletion = handler
             callback(["shippingContact": Mappers.mapFromShippingContact(shippingContact: contact)])
@@ -170,10 +162,7 @@ extension StripeSdk : PKPaymentAuthorizationViewControllerDelegate, STPApplePayC
         } else if let clientSecret = self.confirmApplePaySetupClientSecret {
             completion(clientSecret, nil)
         } else {
-            self.applePayCompletionCallback = completion
-            let method = Mappers.mapFromPaymentMethod(paymentMethod.splitApplePayAddressByNewline())
-            self.deprecatedApplePayRequestResolver?(Mappers.createResult("paymentMethod", method))
-            self.deprecatedApplePayRequestRejecter = nil
+            RCTMakeAndLogError("Tried to complete Apple Pay payment, but no client secret was found.", nil, nil)
         }
     }
     
@@ -233,44 +222,28 @@ extension StripeSdk : PKPaymentAuthorizationViewControllerDelegate, STPApplePayC
                         }
                     }
                 }
-                
-            } else {
-                deprecatedConfirmApplePayPaymentResolver?([])
             }
             break
         case .error:
             if let resolve = self.confirmApplePayResolver {
                 resolve(Errors.createError(ErrorType.Failed, error as NSError?))
-            } else {
-                let message = "Payment not completed"
-                deprecatedApplePayCompletionRejecter?(ErrorType.Failed, message, nil)
-                deprecatedApplePayRequestRejecter?(ErrorType.Failed, message, nil)
             }
             break
         case .userCancellation:
             let message = "The payment has been canceled"
             if let resolve = self.confirmApplePayResolver {
                 resolve(Errors.createError(ErrorType.Canceled, message))
-            } else {
-                deprecatedApplePayCompletionRejecter?(ErrorType.Canceled, message, nil)
-                deprecatedApplePayRequestRejecter?(ErrorType.Canceled, message, nil)
             }
             break
         @unknown default:
             if let resolve = self.confirmApplePayResolver {
                 resolve(Errors.createError(ErrorType.Unknown, error as NSError?))
-            } else {
-                let message = "Payment not completed"
-                deprecatedApplePayCompletionRejecter?(ErrorType.Unknown, message, nil)
-                deprecatedApplePayRequestRejecter?(ErrorType.Unknown, message, nil)
             }
             break
         }
         confirmApplePayResolver = nil
         confirmApplePayPaymentClientSecret = nil
         confirmApplePaySetupClientSecret = nil
-        deprecatedApplePayCompletionRejecter = nil
-        deprecatedApplePayRequestRejecter = nil
     }
     
 }

package/ios/Mappers.swift

@@ -357,6 +357,7 @@ class Mappers {
         if let address = shipping.address {
             addressDetails = [
                 "city": address.city ?? NSNull(),
+                "state": address.state ?? NSNull(),
                 "country": address.country ?? NSNull(),
                 "line1": address.line1 ?? NSNull(),
                 "line2":address.line2 ?? NSNull(),

package/ios/StripeSdk+PaymentSheet.swift

@@ -9,7 +9,9 @@ import Foundation
 import StripePaymentSheet
 
 extension StripeSdk {
-    internal func buildPaymentSheetConfiguration(params: NSDictionary, orderTrackingCallback: RCTResponseSenderBlock? = nil) -> (error: NSDictionary?, configuration: PaymentSheet.Configuration?) {
+    internal func buildPaymentSheetConfiguration(
+            params: NSDictionary
+    ) -> (error: NSDictionary?, configuration: PaymentSheet.Configuration?) {
         var configuration = PaymentSheet.Configuration()
         
         configuration.primaryButtonLabel = params["primaryButtonLabel"] as? String
@@ -29,7 +31,7 @@ extension StripeSdk {
                     merchantCountryCode: applePayParams["merchantCountryCode"] as? String,
                     paymentSummaryItems: applePayParams["cartItems"] as? [[String : Any]],
                     buttonType: applePayParams["buttonType"] as? NSNumber,
-                    customHandlers: buildCustomerHandlersForPaymentSheet(applePayParams: applePayParams, orderTrackingCallback: orderTrackingCallback)
+                    customHandlers: buildCustomerHandlersForPaymentSheet(applePayParams: applePayParams)
                 )
             } catch {
                 return(error: Errors.createError(ErrorType.Failed, error.localizedDescription), configuration: nil)
@@ -96,8 +98,13 @@ extension StripeSdk {
         return (nil, configuration)
     }
     
-    internal func preparePaymentSheetInstance(params: NSDictionary, configuration: PaymentSheet.Configuration, resolve: @escaping RCTPromiseResolveBlock) {
-    
+    internal func preparePaymentSheetInstance(
+        params: NSDictionary,
+        configuration: PaymentSheet.Configuration,
+        resolve: @escaping RCTPromiseResolveBlock
+    ) {
+        self.paymentSheetFlowController = nil
+        
         func handlePaymentSheetFlowControllerResult(result: Result<PaymentSheet.FlowController, Error>, stripeSdk: StripeSdk?) {
             switch result {
             case .failure(let error):
@@ -146,12 +153,91 @@ extension StripeSdk {
                 resolve([])
             }
         } else {
-            resolve(Errors.createError(ErrorType.Failed, "You must provide either paymentIntentClientSecret or setupIntentClientSecret"))
+            guard let intentConfiguration = params["intentConfiguration"] as? NSDictionary else {
+                resolve(Errors.createError(ErrorType.Failed, "One of `paymentIntentClientSecret`, `setupIntentClientSecret`, or `intentConfiguration` is required"))
+                return
+            }
+            guard let modeParams =  intentConfiguration["mode"] as? NSDictionary else {
+                resolve(Errors.createError(ErrorType.Failed, "One of `paymentIntentClientSecret`, `setupIntentClientSecret`, or `intentConfiguration.mode` is required"))
+                return
+            }
+            if (intentConfiguration.object(forKey: "confirmHandler") == nil) {
+                resolve(Errors.createError(ErrorType.Failed, "You must provide `intentConfiguration.confirmHandler` if you are not passing an intent client secret"))
+                return
+            }
+            let captureMethodString = intentConfiguration["captureMethod"] as? String
+            let intentConfig = buildIntentConfiguration(
+                modeParams: modeParams,
+                paymentMethodTypes: intentConfiguration["paymentMethodTypes"] as? [String],
+                captureMethod: mapCaptureMethod(captureMethodString)
+            )
+            
+            if params["customFlow"] as? Bool == true {
+                PaymentSheet.FlowController.create(intentConfiguration: intentConfig, configuration: configuration) { [weak self] result in
+                    handlePaymentSheetFlowControllerResult(result: result, stripeSdk: self)
+                }
+            } else {
+                self.paymentSheet = PaymentSheet(
+                    intentConfiguration: intentConfig,
+                    configuration: configuration
+                )
+                resolve([])
+            }
+        }
+    }
+    
+    private func mapCaptureMethod(_ captureMethod: String?) -> PaymentSheet.IntentConfiguration.CaptureMethod {
+        if let captureMethod = captureMethod {
+            switch captureMethod {
+            case "Automatic": return PaymentSheet.IntentConfiguration.CaptureMethod.automatic
+            case "Manual": return PaymentSheet.IntentConfiguration.CaptureMethod.manual
+            case "AutomaticAsync": return PaymentSheet.IntentConfiguration.CaptureMethod.automaticAsync
+            default: return PaymentSheet.IntentConfiguration.CaptureMethod.automatic
+            }
+        }
+        return PaymentSheet.IntentConfiguration.CaptureMethod.automatic
+    }
+    
+    private func buildIntentConfiguration(
+        modeParams: NSDictionary,
+        paymentMethodTypes: [String]?,
+        captureMethod: PaymentSheet.IntentConfiguration.CaptureMethod
+    ) -> PaymentSheet.IntentConfiguration {
+        var mode: PaymentSheet.IntentConfiguration.Mode
+        if let amount = modeParams["amount"] as? Int {
+            mode = PaymentSheet.IntentConfiguration.Mode.payment(
+                amount: amount,
+                currency: modeParams["currencyCode"] as? String ?? "",
+                setupFutureUsage: modeParams["setupFutureUsage"] != nil
+                    ? (modeParams["setupFutureUsage"] as? String == "OffSession" ? .offSession : .onSession)
+                    : nil,
+            captureMethod: captureMethod
+            )
+        } else {
+            mode = PaymentSheet.IntentConfiguration.Mode.setup(
+                currency: modeParams["currencyCode"] as? String,
+                setupFutureUsage: modeParams["setupFutureUsage"] as? String == "OffSession" ? .offSession : .onSession
+            )
         }
+
+        return PaymentSheet.IntentConfiguration.init(
+            mode: mode,
+            paymentMethodTypes: paymentMethodTypes,
+            confirmHandler: { paymentMethod, shouldSavePaymentMethod, intentCreationCallback in
+                if (self.hasEventListeners) {
+                    self.paymentSheetIntentCreationCallback = intentCreationCallback
+                    self.sendEvent(withName: "onConfirmHandlerCallback", body: [
+                        "paymentMethod": Mappers.mapFromPaymentMethod(paymentMethod) ?? NSNull(),
+                        "shouldSavePaymentMethod": shouldSavePaymentMethod
+                    ])
+                } else {
+                    RCTMakeAndLogError("Tried to call confirmHandler, but no callback was found. Please file an issue: https://github.com/stripe/stripe-react-native/issues", nil, nil)
+                }
+            })
     }
     
-    private func buildCustomerHandlersForPaymentSheet(applePayParams: NSDictionary, orderTrackingCallback: RCTResponseSenderBlock?) -> PaymentSheet.ApplePayConfiguration.Handlers? {
-        if (applePayParams["request"] == nil && orderTrackingCallback == nil) {
+    private func buildCustomerHandlersForPaymentSheet(applePayParams: NSDictionary) -> PaymentSheet.ApplePayConfiguration.Handlers? {
+        if (applePayParams["request"] == nil) {
             return nil
         }
         return PaymentSheet.ApplePayConfiguration.Handlers(paymentRequestHandler: { request in
@@ -163,9 +249,13 @@ extension StripeSdk {
             }
             return request
         }, authorizationResultHandler: { result, completion in
-            if let orderTrackingCallback = orderTrackingCallback {
-                self.orderTrackingHandler = (result, completion)
-                orderTrackingCallback(nil)
+            if applePayParams.object(forKey: "setOrderTracking") != nil {
+                if (self.hasEventListeners) {
+                    self.orderTrackingHandler = (result, completion)
+                    self.sendEvent(withName: "onOrderTrackingCallback", body: [:])
+                } else {
+                    RCTMakeAndLogError("Order tracking is enabled, but no callback was found. Please file an issue: https://github.com/stripe/stripe-react-native/issues", nil, nil)
+                }
             } else {
                 completion(result)
             }