@stripe/stripe-react-native 0.5.0 → 0.8.0

package/ios/StripeSdk.swift

@@ -33,6 +33,15 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
         return false
     }
     
+    @objc override func constantsToExport() -> [AnyHashable : Any] {
+        return [
+            "API_VERSIONS": [
+                "CORE": STPAPIClient.apiVersion,
+                "ISSUING": STPAPIClient.apiVersion,
+            ]
+        ]
+    }
+    
     @objc(initialise:resolver:rejecter:)
     func initialise(params: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
         let publishableKey = params["publishableKey"] as! String
@@ -72,7 +81,7 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
                 configuration.applePay = .init(merchantId: merchantIdentifier,
                                                merchantCountryCode: merchantCountryCode)
             } else {
-                resolve(Errors.createError(PaymentSheetErrorType.Failed.rawValue, "Either merchantIdentifier or merchantCountryCode is missing"))
+                resolve(Errors.createError(ErrorType.Failed, "Either merchantIdentifier or merchantCountryCode is missing"))
                 return
             }
         }
@@ -113,7 +122,7 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
         if let customerId = params["customerId"] as? String {
             if let customerEphemeralKeySecret = params["customerEphemeralKeySecret"] as? String {
                 if (!Errors.isEKClientSecretValid(clientSecret: customerEphemeralKeySecret)) {
-                    resolve(Errors.createError(PaymentSheetErrorType.Failed.rawValue, "`customerEphemeralKeySecret` format does not match expected client secret formatting."))
+                    resolve(Errors.createError(ErrorType.Failed, "`customerEphemeralKeySecret` format does not match expected client secret formatting."))
                     return
                 }
                 configuration.customer = .init(id: customerId, ephemeralKeySecret: customerEphemeralKeySecret)
@@ -129,7 +138,7 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
         func handlePaymentSheetFlowControllerResult(result: Result<PaymentSheet.FlowController, Error>, stripeSdk: StripeSdk?) {
             switch result {
             case .failure(let error):
-                resolve(Errors.createError("Failed", error as NSError))
+                resolve(Errors.createError(ErrorType.Failed, error as NSError))
             case .success(let paymentSheetFlowController):
                 self.paymentSheetFlowController = paymentSheetFlowController
                 if let paymentOption = stripeSdk?.paymentSheetFlowController?.paymentOption {
@@ -146,7 +155,7 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
         
         if let paymentIntentClientSecret = params["paymentIntentClientSecret"] as? String {
             if (!Errors.isPIClientSecretValid(clientSecret: paymentIntentClientSecret)) {
-                resolve(Errors.createError(PaymentSheetErrorType.Failed.rawValue, "`secret` format does not match expected client secret formatting."))
+                resolve(Errors.createError(ErrorType.Failed, "`secret` format does not match expected client secret formatting."))
                 return
             }
             
@@ -161,7 +170,7 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
             }
         } else if let setupIntentClientSecret = params["setupIntentClientSecret"] as? String {
             if (!Errors.isSetiClientSecretValid(clientSecret: setupIntentClientSecret)) {
-                resolve(Errors.createError(PaymentSheetErrorType.Failed.rawValue, "`secret` format does not match expected client secret formatting."))
+                resolve(Errors.createError(ErrorType.Failed, "`secret` format does not match expected client secret formatting."))
                 return
             }
             
@@ -175,7 +184,7 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
                 resolve([])
             }
         } else {
-            resolve(Errors.createError(PaymentSheetErrorType.Failed.rawValue, "You must provide either paymentIntentClientSecret or setupIntentClientSecret"))
+            resolve(Errors.createError(ErrorType.Failed, "You must provide either paymentIntentClientSecret or setupIntentClientSecret"))
         }
         
     }
@@ -191,14 +200,14 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
                         resolve([])
                         self.paymentSheetFlowController = nil
                     case .canceled:
-                        resolve(Errors.createError(PaymentSheetErrorType.Canceled.rawValue, "The payment has been canceled"))
+                        resolve(Errors.createError(ErrorType.Canceled, "The payment has been canceled"))
                     case .failed(let error):
-                        resolve(Errors.createError(PaymentSheetErrorType.Failed.rawValue, error.localizedDescription))
+                        resolve(Errors.createError(ErrorType.Failed, error.localizedDescription))
                     }
                    
                 }
             } else {
-                resolve(Errors.createError(PaymentSheetErrorType.Failed.rawValue, "No payment sheet has been initialized yet"))
+                resolve(Errors.createError(ErrorType.Failed, "No payment sheet has been initialized yet"))
             }
         }
     }
@@ -231,13 +240,13 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
                         resolve([])
                         self.paymentSheet = nil
                     case .canceled:
-                        resolve(Errors.createError(PaymentSheetErrorType.Canceled.rawValue, "The payment has been canceled"))
+                        resolve(Errors.createError(ErrorType.Canceled, "The payment has been canceled"))
                     case .failed(let error):
-                        resolve(Errors.createError(PaymentSheetErrorType.Failed.rawValue, error as NSError))
+                        resolve(Errors.createError(ErrorType.Failed, error as NSError))
                     }
                 }
             } else {
-                resolve(Errors.createError(PaymentSheetErrorType.Failed.rawValue, "No payment sheet has been initialized yet"))
+                resolve(Errors.createError(ErrorType.Failed, "No payment sheet has been initialized yet"))
             }
         }
     }
@@ -245,13 +254,13 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
     @objc(createTokenForCVCUpdate:resolver:rejecter:)
     func createTokenForCVCUpdate(cvc: String?, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
         guard let cvc = cvc else {
-            resolve(Errors.createError("Failed", "You must provide CVC"))
+            resolve(Errors.createError(ErrorType.Failed, "You must provide CVC"))
             return;
         }
         
         STPAPIClient.shared.createToken(forCVCUpdate: cvc) { (token, error) in
             if error != nil || token == nil {
-                resolve(Errors.createError("Failed", error?.localizedDescription ?? ""))
+                resolve(Errors.createError(ErrorType.Failed, error?.localizedDescription ?? ""))
             } else {
                 let tokenId = token?.tokenId
                 resolve(["tokenId": tokenId])
@@ -263,28 +272,37 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
     func confirmSetupIntent (setupIntentClientSecret: String, params: NSDictionary,
                              options: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock,
                              rejecter reject: @escaping RCTPromiseRejectBlock) {
-        let type = Mappers.mapToPaymentMethodType(type: params["type"] as? String)
+        let paymentMethodData = params["paymentMethodData"] as? NSDictionary
+        let type = Mappers.mapToPaymentMethodType(type: params["paymentMethodType"] as? String)
         guard let paymentMethodType = type else {
-            resolve(Errors.createError(ConfirmPaymentErrorType.Failed.rawValue, "You must provide paymentMethodType"))
+            resolve(Errors.createError(ErrorType.Failed, "You must provide paymentMethodType"))
             return
         }
-        var paymentMethodParams: STPPaymentMethodParams?
-        let factory = PaymentMethodFactory.init(params: params, cardFieldView: cardFieldView, cardFormView: cardFormView)
         
-        do {
-            paymentMethodParams = try factory.createParams(paymentMethodType: paymentMethodType)
-        } catch  {
-            resolve(Errors.createError(ConfirmPaymentErrorType.Failed.rawValue, error.localizedDescription))
-            return
-        }
-        guard paymentMethodParams != nil else {
-            resolve(Errors.createError(ConfirmPaymentErrorType.Unknown.rawValue, "Unhandled error occured"))
+        var err: NSDictionary? = nil
+        let setupIntentParams: STPSetupIntentConfirmParams = {
+            // If payment method data is not supplied, assume payment method was attached through via collectBankAccount
+            if (paymentMethodType == .USBankAccount && paymentMethodData == nil) {
+                return STPSetupIntentConfirmParams(clientSecret: setupIntentClientSecret, paymentMethodType: .USBankAccount)
+            } else {
+                let parameters = STPSetupIntentConfirmParams(clientSecret: setupIntentClientSecret)
+                let factory = PaymentMethodFactory.init(paymentMethodData: paymentMethodData, options: options, cardFieldView: cardFieldView, cardFormView: cardFormView)
+                do {
+                    let paymentMethodParams = try factory.createParams(paymentMethodType: paymentMethodType)
+                    parameters.paymentMethodParams = paymentMethodParams
+                } catch  {
+                    err = Errors.createError(ErrorType.Failed, error as NSError?)
+                }
+                
+                return parameters
+            }
+        }()
+        
+        if (err != nil) {
+            resolve(err)
             return
         }
-        
-        let setupIntentParams = STPSetupIntentConfirmParams(clientSecret: setupIntentClientSecret)
-        setupIntentParams.paymentMethodParams = paymentMethodParams
-        
+                
         if let urlScheme = urlScheme {
             setupIntentParams.returnURL = Mappers.mapToReturnURL(urlScheme: urlScheme)
         }
@@ -293,20 +311,20 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
         paymentHandler.confirmSetupIntent(setupIntentParams, with: self) { status, setupIntent, error in
             switch (status) {
             case .failed:
-                resolve(Errors.createError(ConfirmSetupIntentErrorType.Failed.rawValue, error))
+                resolve(Errors.createError(ErrorType.Failed, error))
                 break
             case .canceled:
                 if let lastError = setupIntent?.lastSetupError {
-                    resolve(Errors.createError(ConfirmSetupIntentErrorType.Canceled.rawValue, lastError))
+                    resolve(Errors.createError(ErrorType.Canceled, lastError))
                 } else {
-                    resolve(Errors.createError(ConfirmSetupIntentErrorType.Canceled.rawValue, "The payment has been canceled"))
+                    resolve(Errors.createError(ErrorType.Canceled, "The payment has been canceled"))
                 }
                 break
             case .succeeded:
                 let intent = Mappers.mapFromSetupIntent(setupIntent: setupIntent!)
                 resolve(Mappers.createResult("setupIntent", intent))
             @unknown default:
-                resolve(Errors.createError(ConfirmSetupIntentErrorType.Unknown.rawValue, error))
+                resolve(Errors.createError(ErrorType.Unknown, error))
                 break
             }
         }
@@ -315,7 +333,7 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
     @objc(updateApplePaySummaryItems:errorAddressFields:resolver:rejecter:)
     func updateApplePaySummaryItems(summaryItems: NSArray, errorAddressFields: [NSDictionary], resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
         if (shippingMethodUpdateHandler == nil && shippingContactUpdateHandler == nil) {
-            resolve(Errors.createError(ApplePayErrorType.Failed.rawValue, "You can use this method only after either onDidSetShippingMethod or onDidSetShippingContact events emitted"))
+            resolve(Errors.createError(ErrorType.Failed, "You can use this method only after either onDidSetShippingMethod or onDidSetShippingContact events emitted"))
             return
         }
         var paymentSummaryItems: [PKPaymentSummaryItem] = []
@@ -349,7 +367,7 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
             library.openPaymentSetup()
             resolve([])
         } else {
-            resolve(Errors.createError("Failed", "Cannot open payment setup"))
+            resolve(Errors.createError(ErrorType.Failed, "Cannot open payment setup"))
         }
     }
     
@@ -396,22 +414,22 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
             break
         case .error:
             let message = "Payment not completed"
-            applePayCompletionRejecter?(ApplePayErrorType.Failed.rawValue, message, nil)
-            applePayRequestRejecter?(ApplePayErrorType.Failed.rawValue, message, nil)
+            applePayCompletionRejecter?(ErrorType.Failed, message, nil)
+            applePayRequestRejecter?(ErrorType.Failed, message, nil)
             applePayCompletionRejecter = nil
             applePayRequestRejecter = nil
             break
         case .userCancellation:
             let message = "The payment has been canceled"
-            applePayCompletionRejecter?(ApplePayErrorType.Canceled.rawValue, message, nil)
-            applePayRequestRejecter?(ApplePayErrorType.Canceled.rawValue, message, nil)
+            applePayCompletionRejecter?(ErrorType.Canceled, message, nil)
+            applePayRequestRejecter?(ErrorType.Canceled, message, nil)
             applePayCompletionRejecter = nil
             applePayRequestRejecter = nil
             break
         @unknown default:
             let message = "Payment not completed"
-            applePayCompletionRejecter?(ApplePayErrorType.Unknown.rawValue, message, nil)
-            applePayRequestRejecter?(ApplePayErrorType.Unknown.rawValue, message, nil)
+            applePayCompletionRejecter?(ErrorType.Unknown, message, nil)
+            applePayRequestRejecter?(ErrorType.Unknown, message, nil)
             applePayCompletionRejecter = nil
             applePayRequestRejecter = nil
         }
@@ -446,7 +464,7 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
                          resolver resolve: @escaping RCTPromiseResolveBlock,
                          rejecter reject: @escaping RCTPromiseRejectBlock) {
         if (merchantIdentifier == nil) {
-            reject(ApplePayErrorType.Failed.rawValue, "You must provide merchantIdentifier", nil)
+            reject(ErrorType.Failed, "You must provide merchantIdentifier", nil)
             return
         }
         
@@ -455,15 +473,15 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
         }
         
         guard let summaryItems = params["cartItems"] as? NSArray else {
-            reject(ApplePayErrorType.Failed.rawValue, "You must provide the items for purchase", nil)
+            reject(ErrorType.Failed, "You must provide the items for purchase", nil)
             return
         }
         guard let country = params["country"] as? String else {
-            reject(ApplePayErrorType.Failed.rawValue, "You must provide the country", nil)
+            reject(ErrorType.Failed, "You must provide the country", nil)
             return
         }
         guard let currency = params["currency"] as? String else {
-            reject(ApplePayErrorType.Failed.rawValue, "You must provide the payment currency", nil)
+            reject(ErrorType.Failed, "You must provide the payment currency", nil)
             return
         }
         
@@ -504,7 +522,7 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
                 applePayContext.presentApplePay(completion: nil)
             }
         } else {
-            reject(ApplePayErrorType.Failed.rawValue, "Payment not completed", nil)
+            reject(ErrorType.Failed, "Payment not completed", nil)
         }
     }
 
@@ -522,37 +540,40 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
         resolver resolve: @escaping RCTPromiseResolveBlock,
         rejecter reject: @escaping RCTPromiseRejectBlock
     ) -> Void {
-        let type = Mappers.mapToPaymentMethodType(type: params["type"] as? String)
+        let type = Mappers.mapToPaymentMethodType(type: params["paymentMethodType"] as? String)
         guard let paymentMethodType = type else {
-            resolve(Errors.createError(NextPaymentActionErrorType.Failed.rawValue, "You must provide paymentMethodType"))
+            resolve(Errors.createError(ErrorType.Failed, "You must provide paymentMethodType"))
             return
         }
         
         var paymentMethodParams: STPPaymentMethodParams?
-        let factory = PaymentMethodFactory.init(params: params, cardFieldView: cardFieldView, cardFormView: cardFormView)
-        
+        let factory = PaymentMethodFactory.init(
+            paymentMethodData: params["paymentMethodData"] as? NSDictionary,
+            options: options,
+            cardFieldView: cardFieldView,
+            cardFormView: cardFormView
+        )
         do {
             paymentMethodParams = try factory.createParams(paymentMethodType: paymentMethodType)
         } catch  {
-            resolve(Errors.createError(NextPaymentActionErrorType.Failed.rawValue, error.localizedDescription))
-            return
-        }
-        
-        guard let params = paymentMethodParams else {
-            resolve(Errors.createError(NextPaymentActionErrorType.Unknown.rawValue, "Unhandled error occured"))
+            resolve(Errors.createError(ErrorType.Failed, error.localizedDescription))
             return
         }
         
-        STPAPIClient.shared.createPaymentMethod(with: params) { paymentMethod, error in
-            if let createError = error {
-                resolve(Errors.createError(NextPaymentActionErrorType.Failed.rawValue, createError.localizedDescription))
-                return
-            }
-            
-            if let paymentMethod = paymentMethod {
-                let method = Mappers.mapFromPaymentMethod(paymentMethod)
-                resolve(Mappers.createResult("paymentMethod", method))
+        if let paymentMethodParams = paymentMethodParams {
+            STPAPIClient.shared.createPaymentMethod(with: paymentMethodParams) { paymentMethod, error in
+                if let createError = error {
+                    resolve(Errors.createError(ErrorType.Failed, createError.localizedDescription))
+                    return
+                }
+                
+                if let paymentMethod = paymentMethod {
+                    let method = Mappers.mapFromPaymentMethod(paymentMethod)
+                    resolve(Mappers.createResult("paymentMethod", method))
+                }
             }
+        } else {
+            resolve(Errors.createError(ErrorType.Unknown, "Unhandled error occured"))
         }
     }
     
@@ -563,7 +584,7 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
         rejecter reject: @escaping RCTPromiseRejectBlock
     ) -> Void {
         guard let type = params["type"] as? String else {
-            resolve(Errors.createError(CreateTokenErrorType.Failed.rawValue, "type parameter is required"))
+            resolve(Errors.createError(ErrorType.Failed, "type parameter is required"))
             return
         }
         
@@ -574,7 +595,7 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
         case "Card":
             createTokenFromCard(params: params, resolver: resolve, rejecter: reject)
         default:
-            resolve(Errors.createError(CreateTokenErrorType.Failed.rawValue, type + " type is not supported yet"))
+            resolve(Errors.createError(ErrorType.Failed, type + " type is not supported yet"))
         }
     }
     
@@ -603,7 +624,7 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
             if let token = token {
                 resolve(Mappers.createResult("token", Mappers.mapFromToken(token: token)))
             } else {
-                resolve(Errors.createError(CreateTokenErrorType.Failed.rawValue, error as NSError?))
+                resolve(Errors.createError(ErrorType.Failed, error as NSError?))
             }
         }
     }
@@ -614,7 +635,7 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
         rejecter reject: @escaping RCTPromiseRejectBlock
     ) -> Void {
         guard let cardParams = cardFieldView?.cardParams ?? cardFormView?.cardParams else {
-            resolve(Errors.createError(CreateTokenErrorType.Failed.rawValue, "Card details not complete"))
+            resolve(Errors.createError(ErrorType.Failed, "Card details not complete"))
             return
         }
         
@@ -632,7 +653,7 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
             if let token = token {
                 resolve(Mappers.createResult("token", Mappers.mapFromToken(token: token)))
             } else {
-                resolve(Errors.createError(CreateTokenErrorType.Failed.rawValue, error as NSError?))
+                resolve(Errors.createError(ErrorType.Failed, error as NSError?))
             }
         }
     }
@@ -647,13 +668,13 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
         paymentHandler.handleNextAction(forPayment: paymentIntentClientSecret, with: self, returnURL: nil) { status, paymentIntent, handleActionError in
             switch (status) {
             case .failed:
-                resolve(Errors.createError(NextPaymentActionErrorType.Failed.rawValue, handleActionError))
+                resolve(Errors.createError(ErrorType.Failed, handleActionError))
                 break
             case .canceled:
                 if let lastError = paymentIntent?.lastPaymentError {
-                    resolve(Errors.createError(NextPaymentActionErrorType.Canceled.rawValue, lastError))
+                    resolve(Errors.createError(ErrorType.Canceled, lastError))
                 } else {
-                    resolve(Errors.createError(NextPaymentActionErrorType.Canceled.rawValue, "The payment has been canceled"))
+                    resolve(Errors.createError(ErrorType.Canceled, "The payment has been canceled"))
                 }
                 break
             case .succeeded:
@@ -662,11 +683,92 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
                 }
                 break
             @unknown default:
-                resolve(Errors.createError(NextPaymentActionErrorType.Unknown.rawValue, "Cannot complete payment"))
+                resolve(Errors.createError(ErrorType.Unknown, "Cannot complete payment"))
                 break
             }
         }
     }
+    
+    @objc(collectBankAccount:clientSecret:params:resolver:rejecter:)
+    func collectBankAccount(
+        isPaymentIntent: Bool,
+        clientSecret: NSString,
+        params: NSDictionary,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) -> Void {
+        let paymentMethodData = params["paymentMethodData"] as? NSDictionary
+        let type = Mappers.mapToPaymentMethodType(type: params["paymentMethodType"] as? String)
+        if (type != STPPaymentMethodType.USBankAccount) {
+            resolve(Errors.createError(ErrorType.Failed, "collectBankAccount currently only accepts the USBankAccount payment method type."))
+            return
+        }
+        
+        guard let billingDetails = paymentMethodData?["billingDetails"] as? [String: Any?], let name = billingDetails["name"] as? String else {
+            resolve(Errors.createError(ErrorType.Failed, "You must provide a name when collecting US bank account details."))
+            return
+        }
+        
+        if (name.isEmpty) {
+            resolve(Errors.createError(ErrorType.Failed, "You must provide a name when collecting US bank account details."))
+            return
+        }
+        
+        let collectParams = STPCollectBankAccountParams.collectUSBankAccountParams(
+            with: name,
+            email: billingDetails["email"] as? String
+        )
+        
+        if (isPaymentIntent) {
+            DispatchQueue.main.async {
+                STPBankAccountCollector().collectBankAccountForPayment(
+                    clientSecret: clientSecret as String,
+                    params: collectParams,
+                    from: findViewControllerPresenter(from: UIApplication.shared.delegate?.window??.rootViewController ?? UIViewController())
+                ) { intent, error in
+                    if let error = error {
+                        resolve(Errors.createError(ErrorType.Failed, error as NSError))
+                        return
+                    }
+                    
+                    if let intent = intent {
+                        if (intent.status == .requiresPaymentMethod) {
+                            resolve(Errors.createError(ErrorType.Canceled, "Bank account collection was canceled."))
+                        }
+                        resolve(
+                            Mappers.createResult("paymentIntent", Mappers.mapFromPaymentIntent(paymentIntent: intent))
+                        )
+                    } else {
+                        resolve(Errors.createError(ErrorType.Unknown, "There was unexpected error while collecting bank account information."))
+                    }
+                }
+            }
+        } else {
+            DispatchQueue.main.async {
+                STPBankAccountCollector().collectBankAccountForSetup(
+                    clientSecret: clientSecret as String,
+                    params: collectParams,
+                    from: findViewControllerPresenter(from: UIApplication.shared.delegate?.window??.rootViewController ?? UIViewController())
+                ) { intent, error in
+                    if let error = error {
+                        resolve(Errors.createError(ErrorType.Failed, error as NSError))
+                        return
+                    }
+                    
+                    if let intent = intent {
+                        if (intent.status == .requiresPaymentMethod) {
+                            resolve(Errors.createError(ErrorType.Canceled, "Bank account collection was canceled."))
+                        }
+                        resolve(
+                            Mappers.createResult("setupIntent", Mappers.mapFromSetupIntent(setupIntent: intent))
+                        )
+                    } else {
+                        resolve(Errors.createError(ErrorType.Unknown, "There was unexpected error while collecting bank account information."))
+                    }
+                }
+            }
+        }
+    }
 
     @objc(confirmPayment:data:options:resolver:rejecter:)
     func confirmPayment(
@@ -678,55 +780,73 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
     ) -> Void {
         self.confirmPaymentResolver = resolve
         self.confirmPaymentClientSecret = paymentIntentClientSecret
-                
-        let paymentMethodId = params["paymentMethodId"] as? String
-        let paymentIntentParams = STPPaymentIntentParams(clientSecret: paymentIntentClientSecret)
-        if let setupFutureUsage = params["setupFutureUsage"] as? String {
-            paymentIntentParams.setupFutureUsage = Mappers.mapToPaymentIntentFutureUsage(usage: setupFutureUsage)
-        }
-                
-        let type = Mappers.mapToPaymentMethodType(type: params["type"] as? String)
+        
+        let paymentMethodData = params["paymentMethodData"] as? NSDictionary
+        let type = Mappers.mapToPaymentMethodType(type: params["paymentMethodType"] as? String)
         guard let paymentMethodType = type else {
-            resolve(Errors.createError(ConfirmPaymentErrorType.Failed.rawValue, "You must provide paymentMethodType"))
+            resolve(Errors.createError(ErrorType.Failed, "You must provide paymentMethodType"))
             return
         }
         
-        if (paymentMethodType == STPPaymentMethodType.FPX) {
-            let testOfflineBank = params["testOfflineBank"] as? Bool
+        if (paymentMethodType == .FPX) {
+            let testOfflineBank = paymentMethodData?["testOfflineBank"] as? Bool
             if (testOfflineBank == false || testOfflineBank == nil) {
                 payWithFPX(paymentIntentClientSecret)
                 return
             }
         }
-        if paymentMethodId != nil {
-            paymentIntentParams.paymentMethodId = paymentMethodId
+        
+        let (error, paymentIntentParams) = createPaymentIntentParams(paymentIntentClientSecret: paymentIntentClientSecret, paymentMethodType: paymentMethodType, paymentMethodData: paymentMethodData, options: options)
+        
+        if (error != nil) {
+            resolve(error)
         } else {
-            var paymentMethodParams: STPPaymentMethodParams?
-            var paymentMethodOptions: STPConfirmPaymentMethodOptions?
-            let factory = PaymentMethodFactory.init(params: params, cardFieldView: cardFieldView, cardFormView: cardFormView)
-            
-            do {
-                paymentMethodParams = try factory.createParams(paymentMethodType: paymentMethodType)
-                paymentMethodOptions = try factory.createOptions(paymentMethodType: paymentMethodType)
-            } catch  {
-                resolve(Errors.createError(ConfirmPaymentErrorType.Failed.rawValue, error.localizedDescription))
-                return
-            }
-            guard paymentMethodParams != nil else {
-                resolve(Errors.createError(ConfirmPaymentErrorType.Unknown.rawValue, "Unhandled error occured"))
-                return
+            STPPaymentHandler.shared().confirmPayment(paymentIntentParams, with: self, completion: onCompleteConfirmPayment)
+        }
+    }
+    
+    func createPaymentIntentParams(
+        paymentIntentClientSecret: String,
+        paymentMethodType: STPPaymentMethodType,
+        paymentMethodData: NSDictionary?,
+        options: NSDictionary
+    ) -> (NSDictionary?, STPPaymentIntentParams) {
+        let factory = PaymentMethodFactory.init(paymentMethodData: paymentMethodData, options: options, cardFieldView: cardFieldView, cardFormView: cardFormView)
+        var err: NSDictionary? = nil
+        
+        let paymentIntentParams: STPPaymentIntentParams = {
+            // If payment method data is not supplied, assume payment method was attached through via collectBankAccount
+            if (paymentMethodType == .USBankAccount && paymentMethodData == nil) {
+                return STPPaymentIntentParams(clientSecret: paymentIntentClientSecret, paymentMethodType: .USBankAccount)
+            } else {
+                let paymentMethodId = paymentMethodData?["paymentMethodId"] as? String
+                let parameters = STPPaymentIntentParams(clientSecret: paymentIntentClientSecret)
+                
+                if paymentMethodId != nil {
+                    parameters.paymentMethodId = paymentMethodId
+                } else {
+                    do {
+                        let paymentMethodParams = try factory.createParams(paymentMethodType: paymentMethodType)
+                        let paymentMethodOptions = try factory.createOptions(paymentMethodType: paymentMethodType)
+                        parameters.paymentMethodParams = paymentMethodParams
+                        parameters.paymentMethodOptions = paymentMethodOptions
+                    } catch  {
+                        err = Errors.createError(ErrorType.Failed, error as NSError?)
+                    }
+                }
+                return parameters
             }
-            paymentIntentParams.paymentMethodParams = paymentMethodParams
-            paymentIntentParams.paymentMethodOptions = paymentMethodOptions
-            paymentIntentParams.shipping = Mappers.mapToShippingDetails(shippingDetails: params["shippingDetails"] as? NSDictionary)
+        }()
+                
+        if let setupFutureUsage = options["setupFutureUsage"] as? String {
+            paymentIntentParams.setupFutureUsage = Mappers.mapToPaymentIntentFutureUsage(usage: setupFutureUsage)
         }
-
-         if let urlScheme = urlScheme {
+        if let urlScheme = urlScheme {
             paymentIntentParams.returnURL = Mappers.mapToReturnURL(urlScheme: urlScheme)
         }
+        paymentIntentParams.shipping = Mappers.mapToShippingDetails(shippingDetails: paymentMethodData?["shippingDetails"] as? NSDictionary)
         
-        let paymentHandler = STPPaymentHandler.shared()
-        paymentHandler.confirmPayment(paymentIntentParams, with: self, completion: onCompleteConfirmPayment)
+        return (err, paymentIntentParams)
     }
 
     @objc(retrievePaymentIntent:resolver:rejecter:)
@@ -738,9 +858,9 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
         STPAPIClient.shared.retrievePaymentIntent(withClientSecret: clientSecret) { (paymentIntent, error) in
             guard error == nil else {
                 if let lastPaymentError = paymentIntent?.lastPaymentError {
-                    resolve(Errors.createError(RetrievePaymentIntentErrorType.Unknown.rawValue, lastPaymentError))
+                    resolve(Errors.createError(ErrorType.Unknown, lastPaymentError))
                 } else {
-                    resolve(Errors.createError(RetrievePaymentIntentErrorType.Unknown.rawValue, error?.localizedDescription))
+                    resolve(Errors.createError(ErrorType.Unknown, error?.localizedDescription))
                 }
                
                 return
@@ -749,7 +869,7 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
             if let paymentIntent = paymentIntent {
                 resolve(Mappers.createResult("paymentIntent", Mappers.mapFromPaymentIntent(paymentIntent: paymentIntent)))
             } else {
-                resolve(Errors.createError(RetrievePaymentIntentErrorType.Unknown.rawValue, "Failed to retrieve the PaymentIntent"))
+                resolve(Errors.createError(ErrorType.Unknown, "Failed to retrieve the PaymentIntent"))
             }
         }
     }
@@ -763,9 +883,9 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
         STPAPIClient.shared.retrieveSetupIntent(withClientSecret: clientSecret) { (setupIntent, error) in
             guard error == nil else {
                 if let lastSetupError = setupIntent?.lastSetupError {
-                    resolve(Errors.createError(RetrieveSetupIntentErrorType.Unknown.rawValue, lastSetupError))
+                    resolve(Errors.createError(ErrorType.Unknown, lastSetupError))
                 } else {
-                    resolve(Errors.createError(RetrieveSetupIntentErrorType.Unknown.rawValue, error?.localizedDescription))
+                    resolve(Errors.createError(ErrorType.Unknown, error?.localizedDescription))
                 }
                
                 return
@@ -774,13 +894,102 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
             if let setupIntent = setupIntent {
                 resolve(Mappers.createResult("setupIntent", Mappers.mapFromSetupIntent(setupIntent: setupIntent)))
             } else {
-                resolve(Errors.createError(RetrieveSetupIntentErrorType.Unknown.rawValue, "Failed to retrieve the SetupIntent"))
+                resolve(Errors.createError(ErrorType.Unknown, "Failed to retrieve the SetupIntent"))
+            }
+        }
+    }
+    
+    @objc(verifyMicrodeposits:clientSecret:params:resolver:rejecter:)
+    func verifyMicrodeposits(
+        isPaymentIntent: Bool,
+        clientSecret: NSString,
+        params: NSDictionary,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) -> Void {
+        let amounts = params["amounts"] as? NSArray
+        let descriptorCode = params["descriptorCode"] as? String
+        
+        if (amounts != nil && descriptorCode != nil || amounts == nil && descriptorCode == nil) {
+            resolve(Errors.createError(ErrorType.Failed, "You must provide either amounts OR descriptorCode, not both."))
+            return
+        }
+        
+        if let amounts = amounts {
+            if (amounts.count != 2) {
+                resolve(Errors.createError(ErrorType.Failed, "Expected 2 integers in the amounts array, but received " + String(amounts.count)))
+                return
+            }
+            if (isPaymentIntent) {
+                STPAPIClient.shared.verifyPaymentIntentWithMicrodeposits(
+                    clientSecret: clientSecret as String,
+                    firstAmount: amounts[0] as! Int,
+                    secondAmount: amounts[1] as! Int,
+                    completion: onCompletePaymentVerification
+                )
+            } else {
+                STPAPIClient.shared.verifySetupIntentWithMicrodeposits(
+                    clientSecret: clientSecret as String,
+                    firstAmount: amounts[0] as! Int,
+                    secondAmount: amounts[1] as! Int,
+                    completion: onCompleteSetupVerification
+                )
+            }
+        } else if let descriptorCode = descriptorCode {
+            if (isPaymentIntent) {
+                STPAPIClient.shared.verifyPaymentIntentWithMicrodeposits(
+                    clientSecret: clientSecret as String,
+                    descriptorCode: descriptorCode,
+                    completion: onCompletePaymentVerification
+                )
+            } else {
+                STPAPIClient.shared.verifySetupIntentWithMicrodeposits(
+                    clientSecret: clientSecret as String,
+                    descriptorCode: descriptorCode,
+                    completion: onCompleteSetupVerification
+                )
+            }
+        }
+        
+        func onCompletePaymentVerification(intent: STPPaymentIntent?, error: Error?) {
+            if (error != nil) {
+                resolve(Errors.createError(ErrorType.Failed, error as NSError?))
+            } else {
+                resolve(Mappers.createResult("paymentIntent", Mappers.mapFromPaymentIntent(paymentIntent:intent!)))
+            }
+        }
+        func onCompleteSetupVerification(intent: STPSetupIntent?, error: Error?) {
+            if (error != nil) {
+                resolve(Errors.createError(ErrorType.Failed, error as NSError?))
+            } else {
+                resolve(Mappers.createResult("setupIntent", Mappers.mapFromSetupIntent(setupIntent:intent!)))
             }
         }
     }
     
+    @objc(isCardInWallet:resolver:rejecter:)
+    func isCardInWallet(
+        params: NSDictionary,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) -> Void {
+        guard let last4 = params["cardLastFour"] as? String else {
+            resolve(Errors.createError(ErrorType.Failed, "You must provide `cardLastFour`"))
+            return
+        }
+        
+        let existingPass: PKPass? = {
+            if #available(iOS 13.4, *) {
+                return PKPassLibrary().passes(of: PKPassType.secureElement).first(where: {$0.secureElementPass?.primaryAccountNumberSuffix == last4})
+            } else {
+                return PKPassLibrary().passes(of: PKPassType.payment).first(where: {$0.paymentPass?.primaryAccountNumberSuffix == last4})
+            }
+        }()
+        resolve(["isInWallet": existingPass != nil])
+    }
+    
     func presentationControllerDidDismiss(_ presentationController: UIPresentationController) {
-        confirmPaymentResolver?(Errors.createError(ConfirmPaymentErrorType.Canceled.rawValue, "FPX Payment has been canceled"))
+        confirmPaymentResolver?(Errors.createError(ErrorType.Canceled, "FPX Payment has been canceled"))
     }
             
     func payWithFPX(_ paymentIntentClientSecret: String) {
@@ -798,7 +1007,7 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
     
     func bankSelectionViewController(_ bankViewController: STPBankSelectionViewController, didCreatePaymentMethodParams paymentMethodParams: STPPaymentMethodParams) {
         guard let clientSecret = confirmPaymentClientSecret else {
-            confirmPaymentResolver?(Errors.createError(ConfirmPaymentErrorType.Failed.rawValue, "Missing paymentIntentClientSecret"))
+            confirmPaymentResolver?(Errors.createError(ErrorType.Failed, "Missing paymentIntentClientSecret"))
             return
         }
         let paymentIntentParams = STPPaymentIntentParams(clientSecret: clientSecret)
@@ -816,14 +1025,14 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
         self.confirmPaymentClientSecret = nil
         switch (status) {
         case .failed:
-            confirmPaymentResolver?(Errors.createError(ConfirmPaymentErrorType.Failed.rawValue, error))
+            confirmPaymentResolver?(Errors.createError(ErrorType.Failed, error))
             break
         case .canceled:
             let statusCode: String
             if (paymentIntent?.status == STPPaymentIntentStatus.requiresPaymentMethod) {
-                statusCode = ConfirmPaymentErrorType.Failed.rawValue
+                statusCode = ErrorType.Failed
             } else {
-                statusCode = ConfirmPaymentErrorType.Canceled.rawValue
+                statusCode = ErrorType.Canceled
             }
             if let lastPaymentError = paymentIntent?.lastPaymentError {
                 confirmPaymentResolver?(Errors.createError(statusCode, lastPaymentError))
@@ -838,7 +1047,7 @@ class StripeSdk: RCTEventEmitter, STPApplePayContextDelegate, STPBankSelectionVi
             }
             break
         @unknown default:
-            confirmPaymentResolver?(Errors.createError(ConfirmPaymentErrorType.Unknown.rawValue, "Cannot complete the payment"))
+            confirmPaymentResolver?(Errors.createError(ErrorType.Unknown, "Cannot complete the payment"))
             break
         }
     }