@stripe/stripe-react-native 0.21.0 → 0.22.0

package/ios/ApplePayUtils.swift

@@ -10,6 +10,114 @@ import StripePaymentSheet
 
 class ApplePayUtils {
     
+    internal class func createPaymentRequest(
+        merchantIdentifier: String?,
+        params: NSDictionary
+    ) -> (error: NSDictionary?, paymentRequest: PKPaymentRequest?) {
+        guard let merchantIdentifier = merchantIdentifier else {
+            return (Errors.createError(ErrorType.Failed, "You must provide merchantIdentifier"), nil)
+        }
+
+        if let additionalEnabledNetworks = params["additionalEnabledNetworks"] as? [String] {
+            do {
+                StripeAPI.additionalEnabledApplePayNetworks = try ApplePayUtils.mapToArrayOfPaymentNetworks(arrayOfStrings: additionalEnabledNetworks)
+            } catch {
+                return (Errors.createError(ErrorType.Failed, error.localizedDescription), nil)
+            }
+        } else if (params["jcbEnabled"] as? Bool == true) {
+            StripeAPI.additionalEnabledApplePayNetworks = [.JCB]
+        }
+
+        guard let summaryItems = params["cartItems"] as? NSArray else {
+            return (Errors.createError(ErrorType.Failed, "`cartItems` cannot be null."), nil)
+        }
+        if (summaryItems.count == 0) {
+            return (Errors.createError(ErrorType.Failed, "`cartItems` cannot be empty."), nil)
+        }
+        
+        guard let countryCode = ((params.object(forKey: "merchantCountryCode") != nil) ? params["merchantCountryCode"] : params["country"]) as? String else {
+            return (Errors.createError(ErrorType.Failed, "You must provide the country"), nil)
+        }
+        guard let currencyCode = ((params.object(forKey: "currencyCode") != nil) ? params["currencyCode"] : params["currency"]) as? String else {
+            return (Errors.createError(ErrorType.Failed, "You must provide the payment currency"), nil)
+        }
+
+        let paymentRequest = StripeAPI.paymentRequest(withMerchantIdentifier: merchantIdentifier, country: countryCode, currency: currencyCode)
+
+        let requiredShippingAddressFields = params["requiredShippingAddressFields"] as? NSArray ?? NSArray()
+        let requiredBillingContactFields = params["requiredBillingContactFields"] as? NSArray ?? NSArray()
+        let shippingMethods = params["shippingMethods"] as? NSArray ?? NSArray()
+
+        paymentRequest.requiredShippingContactFields = Set(requiredShippingAddressFields.map {
+            Mappers.mapToPKContactField(field: $0 as! String)
+        })
+
+        paymentRequest.requiredBillingContactFields = Set(requiredBillingContactFields.map {
+            Mappers.mapToPKContactField(field: $0 as! String)
+        })
+
+        paymentRequest.shippingMethods = ApplePayUtils.buildShippingMethods(items: shippingMethods as? [[String : Any]])
+
+        do {
+            paymentRequest.paymentSummaryItems = try ApplePayUtils
+                .buildPaymentSummaryItems(items: summaryItems as? [[String : Any]])
+        } catch  {
+            return (Errors.createError(ErrorType.Failed, error.localizedDescription), nil)
+        }
+        
+        if let capabilities = params["merchantCapabilities"] as? [String] {
+            for capability in capabilities {
+                paymentRequest.merchantCapabilities.update(with: ApplePayUtils.getMerchantCapabilityFrom(string: capability))
+            }
+        }
+        
+        paymentRequest.shippingType = ApplePayUtils.getShippingTypeFrom(string: params["shippingType"] as? String)
+        if let supportedCountries = params["supportedCountries"] as? Set<String> {
+            paymentRequest.supportedCountries = supportedCountries
+        }
+        if #available(iOS 15.0, *) {
+            if (params["supportsCouponCode"] as? Bool == true) {
+                paymentRequest.supportsCouponCode = true
+            }
+            if let couponCode = params["couponCode"] as? String {
+                paymentRequest.supportsCouponCode = true
+                paymentRequest.couponCode = couponCode
+            }
+        }
+        
+        return (nil, paymentRequest)
+    }
+    
+    internal class func getMerchantCapabilityFrom(string: String?) -> PKMerchantCapability {
+        switch string {
+        case "supportsDebit":
+            return .capabilityDebit
+        case "supportsCredit":
+            return .capabilityCredit
+        case "supportsEMV":
+            return .capabilityEMV
+        case "supports3DS":
+            fallthrough
+        default:
+            return .capability3DS
+        }
+    }
+    
+    internal class func getShippingTypeFrom(string: String?) -> PKShippingType {
+        switch string {
+        case "delivery":
+            return .delivery
+        case "storePickup":
+            return .storePickup
+        case "servicePickup":
+            return .servicePickup
+        case "shipping":
+            fallthrough
+        default:
+            return .shipping
+        }
+    }
+    
     @available(iOS 15.0, *)
     internal class func createDeferredPaymentSummaryItem(item: [String : Any]) throws -> PKPaymentSummaryItem {
         let label = item["label"] as? String ?? ""
@@ -111,6 +219,79 @@ class ApplePayUtils {
         }
     }
     
+    public class func buildShippingMethods(items: [[String : Any]]?) -> [PKShippingMethod] {
+        var shippingMethods: [PKShippingMethod] = []
+        if let items = items {
+            for item in items {
+                let shippingMethod = buildShippingMethod(item: item)
+                shippingMethods.append(shippingMethod)
+            }
+        }
+        
+        return shippingMethods
+    }
+    
+    internal class func buildShippingMethod(item: [String : Any]) -> PKShippingMethod {
+        let label = item["label"] as? String ?? ""
+        let amount = NSDecimalNumber(string: item["amount"] as? String ?? "")
+        let shippingMethod = PKShippingMethod(
+            label: label,
+            amount: amount,
+            type: item["isPending"] as? Bool ?? false
+                ? PKPaymentSummaryItemType.pending : PKPaymentSummaryItemType.final
+        )
+        shippingMethod.detail = item["detail"] as? String ?? ""
+        shippingMethod.identifier = item["identifier"] as? String ?? ""
+        if #available(iOS 15.0, *) {
+            if let startDate = item["startDate"] as? Double, let endDate = item["endDate"] as? Double {
+                let startDate = Date(timeIntervalSince1970: startDate)
+                let endDate = Date(timeIntervalSince1970: endDate)
+                shippingMethod.dateComponentsRange = PKDateComponentsRange(
+                    start: Calendar.current.dateComponents([.calendar, .year, .month, .day],
+                                                           from: startDate),
+                    end: Calendar.current.dateComponents([.calendar, .year, .month, .day],
+                                                         from: endDate)
+                )
+            }
+        }
+        return shippingMethod
+    }
+    
+    public class func buildApplePayErrors(errorItems: [NSDictionary]) throws -> (shippingAddressErrors: [Error], couponCodeErrors: [Error]) {
+        var shippingAddressErrors: [Error] = []
+        var couponCodeErrors: [Error] = []
+        
+        for item in errorItems {
+            let type = item["errorType"] as? String
+            let message = item["message"] as? String
+            switch type {
+            case "InvalidShippingAddress":
+                let field = item["field"] as? String ?? "street"
+                shippingAddressErrors.append(PKPaymentRequest.paymentShippingAddressInvalidError(withKey: field, localizedDescription: message))
+            case "UnserviceableShippingAddress":
+                shippingAddressErrors.append(PKPaymentRequest.paymentShippingAddressUnserviceableError(withLocalizedDescription: message))
+            case "ExpiredCouponCode":
+                if #available(iOS 15.0, *) {
+                    couponCodeErrors.append(PKPaymentRequest.paymentCouponCodeExpiredError(localizedDescription: message))
+                }
+            case "InvalidCouponCode":
+                if #available(iOS 15.0, *) {
+                    couponCodeErrors.append(PKPaymentRequest.paymentCouponCodeInvalidError(localizedDescription: message))
+                }
+            default:
+                throw ApplePayUtilsError.invalidErrorType(String(describing: type))
+            }
+        }
+        return (shippingAddressErrors, couponCodeErrors)
+    }
+    
+    internal class func mapToArrayOfPaymentNetworks(arrayOfStrings: [String]) throws -> [PKPaymentNetwork] {
+        let validNetworks: [PKPaymentNetwork?] = try arrayOfStrings.map { networkString in
+            return PKPaymentNetwork.init(rawValue: networkString)
+        }
+        return validNetworks.compactMap { $0 }
+    }
+    
     public class func buildPaymentSheetApplePayConfig(
         merchantIdentifier: String?,
         merchantCountryCode: String?,
@@ -137,6 +318,8 @@ enum ApplePayUtilsError : Error, Equatable {
     case invalidCartSummaryItemType(String)
     case missingParameter(String, String)
     case invalidTimeInterval(String)
+    case invalidPaymentNetwork(String)
+    case invalidErrorType(String)
     case missingMerchantId
     case missingCountryCode
 }
@@ -150,6 +333,10 @@ extension ApplePayUtilsError: LocalizedError {
             return "Failed to create Apple Pay summary item with label: \(label). The \(parameter) item parameter is required, but none was provided."
         case .invalidTimeInterval(let providedInterval):
             return "Failed to create Apple Pay summary item. \(providedInterval) is not a valid timeInterval, must be one of: minute, hour, day, month, or year."
+        case .invalidPaymentNetwork(let network):
+            return "Failed to create Apple Pay summary item. \(network) is not a valid/supported payment network."
+        case .invalidErrorType(let type):
+            return "Error type: '\(type)' is not supported."
         case .missingMerchantId:
             return "`merchantIdentifier` is required, but none was found. Ensure you are passing this to initStripe your StripeProvider."
         case .missingCountryCode:

package/ios/ApplePayViewController.swift

@@ -0,0 +1,279 @@
+//
+//  ApplePayViewController.swift
+//  stripe-react-native
+//
+//  Created by Charles Cruzan on 9/15/22.
+//
+
+import Foundation
+import Stripe
+
+extension StripeSdk : PKPaymentAuthorizationViewControllerDelegate, STPApplePayContextDelegate {
+    func paymentAuthorizationViewController(
+        _ controller: PKPaymentAuthorizationViewController,
+        didAuthorizePayment payment: PKPayment,
+        handler completion: @escaping (PKPaymentAuthorizationResult) -> Void
+    ) {
+        applePaymentMethodFlowCanBeCanceled = false
+        STPAPIClient.shared.createPaymentMethod(with: payment) { paymentMethod, error in
+            if let error = error {
+                self.createPlatformPayPaymentMethodResolver?(Errors.createError(ErrorType.Failed, error))
+            } else {
+                STPAPIClient.shared.createToken(with: payment) { token, error in
+                    if let error = error {
+                        self.createPlatformPayPaymentMethodResolver?(Errors.createError(ErrorType.Failed, error))
+                    } else {
+                        var promiseResult = ["paymentMethod": Mappers.mapFromPaymentMethod(paymentMethod?.splitApplePayAddressByNewline()) ?? [:]]
+                        if let token = token {
+                            promiseResult["token"] = Mappers.mapFromToken(token: token.splitApplePayAddressByNewline())
+                        }
+                        self.createPlatformPayPaymentMethodResolver?(promiseResult)
+                    }
+                }
+            }
+            completion(PKPaymentAuthorizationResult.init(status: .success, errors: nil))
+        }
+    }
+    
+    func paymentAuthorizationViewControllerDidFinish(
+        _ controller: PKPaymentAuthorizationViewController
+    ) {
+        if (applePaymentMethodFlowCanBeCanceled) {
+            self.createPlatformPayPaymentMethodResolver?(Errors.createError(ErrorType.Canceled, "The payment has been canceled"))
+            applePaymentMethodFlowCanBeCanceled = false
+        }
+        _ = maybeDismissApplePay()
+    }
+    
+    func maybeDismissApplePay() -> Bool {
+        if let applePaymentAuthorizationController = applePaymentAuthorizationController {
+            DispatchQueue.main.async {
+                applePaymentAuthorizationController.dismiss(animated: true)
+            }
+            return true
+        }
+        return false
+    }
+    
+    @available(iOS 15.0, *)
+    func paymentAuthorizationViewController(
+        _ controller: PKPaymentAuthorizationViewController,
+        didChangeCouponCode couponCode: String,
+        handler completion: @escaping (PKPaymentRequestCouponCodeUpdate) -> Void
+    ) {
+        if let callback = self.couponCodeEnteredJSCallback {
+            self.couponCodeUpdateCompletion = completion
+            callback(["couponCode": couponCode])
+        } else {
+            completion(
+                PKPaymentRequestCouponCodeUpdate.init(
+                     errors: self.applePayCouponCodeErrors,
+                     paymentSummaryItems: self.applePaySummaryItems,
+                     shippingMethods: self.applePayShippingMethods
+                )
+            )
+        }
+    }
+    
+    func paymentAuthorizationViewController(
+        _ controller: PKPaymentAuthorizationViewController,
+        didSelect shippingMethod: PKShippingMethod,
+        handler completion: @escaping (PKPaymentRequestShippingMethodUpdate) -> Void
+    ) {
+        if let callback = self.shippingMethodUpdateJSCallback {
+            self.shippingMethodUpdateCompletion = completion
+            callback(["shippingMethod": Mappers.mapFromShippingMethod(shippingMethod: shippingMethod)])
+        } else {
+            completion(
+                PKPaymentRequestShippingMethodUpdate.init(paymentSummaryItems: applePaySummaryItems)
+            )
+        }
+    }
+    
+    func paymentAuthorizationViewController(
+        _ controller: PKPaymentAuthorizationViewController,
+        didSelectShippingContact contact: PKContact,
+        handler completion: @escaping (PKPaymentRequestShippingContactUpdate) -> Void
+    ) {
+        if let callback = self.shippingContactUpdateJSCallback {
+            self.shippingContactUpdateCompletion = completion
+            callback(["shippingContact": Mappers.mapFromShippingContact(shippingContact: contact)])
+        } else {
+            completion(
+                PKPaymentRequestShippingContactUpdate.init(
+                    errors: applePayShippingAddressErrors,
+                    paymentSummaryItems: applePaySummaryItems,
+                    shippingMethods: applePayShippingMethods
+                )
+            )
+        }
+    }
+    
+    func applePayContext(
+        _ context: STPApplePayContext,
+        didSelect shippingMethod: PKShippingMethod,
+        handler: @escaping (PKPaymentRequestShippingMethodUpdate) -> Void
+    ) {
+        if let callback = self.shippingMethodUpdateJSCallback {
+            self.shippingMethodUpdateCompletion = handler
+            callback(["shippingMethod": Mappers.mapFromShippingMethod(shippingMethod: shippingMethod)])
+            if (self.hasLegacyApplePayListeners) {
+                // Legacy, remove when useApplePay hook is removed
+                sendEvent(withName: "onDidSetShippingMethod", body: ["shippingMethod": Mappers.mapFromShippingMethod(shippingMethod: shippingMethod)])
+            }
+        } else {
+            handler(
+                PKPaymentRequestShippingMethodUpdate.init(paymentSummaryItems: applePaySummaryItems)
+            )
+        }
+    }
+    
+    func applePayContext(
+        _ context: STPApplePayContext,
+        didSelectShippingContact contact: PKContact,
+        handler: @escaping (PKPaymentRequestShippingContactUpdate) -> Void
+    ) {
+        if let callback = self.shippingContactUpdateJSCallback {
+            self.shippingContactUpdateCompletion = handler
+            callback(["shippingContact": Mappers.mapFromShippingContact(shippingContact: contact)])
+            if (self.hasLegacyApplePayListeners) {
+                // Legacy, remove when useApplePay hook is removed
+                sendEvent(withName: "onDidSetShippingContact", body: ["shippingContact": Mappers.mapFromShippingContact(shippingContact: contact)])
+            }
+        } else {
+            handler(
+                PKPaymentRequestShippingContactUpdate.init(
+                    errors: applePayShippingAddressErrors,
+                    paymentSummaryItems: applePaySummaryItems,
+                    shippingMethods: applePayShippingMethods
+                )
+            )
+        }
+    }
+    
+    func applePayContext(
+        _ context: STPApplePayContext,
+        didCreatePaymentMethod paymentMethod: STPPaymentMethod,
+        paymentInformation: PKPayment,
+        completion: @escaping STPIntentClientSecretCompletionBlock
+    ) {
+        if let clientSecret = self.confirmApplePayPaymentClientSecret {
+            completion(clientSecret, nil)
+        } else {
+            self.applePayCompletionCallback = completion
+            let method = Mappers.mapFromPaymentMethod(paymentMethod.splitApplePayAddressByNewline())
+            self.deprecatedApplePayRequestResolver?(Mappers.createResult("paymentMethod", method))
+            self.deprecatedApplePayRequestRejecter = nil
+        }
+    }
+    
+    func applePayContext(
+        _ context: STPApplePayContext,
+        didCompleteWith status: STPPaymentStatus,
+        error: Error?
+    ) {
+        switch status {
+        case .success:
+            if let resolve = self.confirmApplePayResolver {
+                if let clientSecret = self.confirmApplePayPaymentClientSecret {
+                    STPAPIClient.shared.retrievePaymentIntent(withClientSecret: clientSecret) { (paymentIntent, error) in
+                        guard error == nil else {
+                            if let lastPaymentError = paymentIntent?.lastPaymentError {
+                                resolve(Errors.createError(ErrorType.Unknown, lastPaymentError))
+                            } else {
+                                resolve(Errors.createError(ErrorType.Unknown, error as NSError?))
+                            }
+                            return
+                        }
+
+                        if let paymentIntent = paymentIntent {
+                            resolve(Mappers.createResult("paymentIntent", Mappers.mapFromPaymentIntent(paymentIntent: paymentIntent)))
+                        } else {
+                            resolve(Mappers.createResult("paymentIntent", nil))
+                        }
+                    }
+                } else if let clientSecret = self.confirmApplePaySetupClientSecret {
+                    STPAPIClient.shared.retrieveSetupIntent(withClientSecret: clientSecret) { (setupIntent, error) in
+                        guard error == nil else {
+                            if let lastSetupError = setupIntent?.lastSetupError {
+                                resolve(Errors.createError(ErrorType.Unknown, lastSetupError))
+                            } else {
+                                resolve(Errors.createError(ErrorType.Unknown, error?.localizedDescription))
+                            }
+                            return
+                        }
+
+                        if let setupIntent = setupIntent {
+                            resolve(Mappers.createResult("setupIntent", Mappers.mapFromSetupIntent(setupIntent: setupIntent)))
+                        } else {
+                            resolve(Mappers.createResult("setupIntent", nil))
+                        }
+                    }
+                }
+                
+            } 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
+    }
+    
+}
+
+extension STPPaymentMethod {
+    func splitApplePayAddressByNewline() -> STPPaymentMethod {
+        let address = self.billingDetails?.address?.line1?.split(whereSeparator: \.isNewline)
+        if (address?.indices.contains(0) == true) {
+            self.billingDetails?.address?.line1 = String(address?[0] ?? "")
+        }
+        if (address?.indices.contains(1) == true) {
+            self.billingDetails?.address?.line2 = String(address?[1] ?? "")
+        }
+        return self
+    }
+}
+
+extension STPToken {
+    func splitApplePayAddressByNewline() -> STPToken {
+        let address = self.card?.address?.line1?.split(whereSeparator: \.isNewline)
+        if (address?.indices.contains(0) == true) {
+            self.card?.address?.line1 = String(address?[0] ?? "")
+        }
+        if (address?.indices.contains(1) == true) {
+            self.card?.address?.line2 = String(address?[1] ?? "")
+        }
+        return self
+    }
+}

package/ios/PaymentPassFinder.swift

@@ -0,0 +1,61 @@
+//
+//  PKPaymentPassFinder.swift
+//  stripe-react-native
+//
+//  Created by Charles Cruzan on 10/6/22.
+//
+
+import Foundation
+
+internal class PaymentPassFinder: NSObject {
+    enum PassLocation: String {
+        case CURRENT_DEVICE
+        case PAIRED_DEVICE
+    }
+    
+    class func findPassWithLast4(last4: String, hasPairedAppleWatch: Bool, completion: @escaping ((Bool, [PassLocation]) -> Void)) {
+        let existingPassOnDevice: PKPass? = {
+            if #available(iOS 13.4, *) {
+                return PKPassLibrary().passes(of: PKPassType.secureElement)
+                    .first(where: { $0.secureElementPass?.primaryAccountNumberSuffix == last4 && $0.secureElementPass?.passActivationState != .deactivated && !$0.isRemotePass })
+            } else {
+                return PKPassLibrary().passes(of: PKPassType.payment)
+                    .first(where: { $0.paymentPass?.primaryAccountNumberSuffix == last4 && $0.paymentPass?.passActivationState != .deactivated && !$0.isRemotePass })
+            }
+        }()
+        
+        var passLocations: [PassLocation] = []
+        if (existingPassOnDevice != nil) {
+            passLocations.append(.CURRENT_DEVICE)
+        }
+        
+        // We're done here if the user does not have a paired Apple Watch
+        if (!hasPairedAppleWatch) {
+            completion(
+                passLocations.count < 1,
+                passLocations
+            )
+            return
+        }
+        
+        let existingPassOnPairedDevices: PKPass? = {
+            if #available(iOS 13.4, *) {
+                return PKPassLibrary().remoteSecureElementPasses
+                    .first(where: { $0.secureElementPass?.primaryAccountNumberSuffix == last4 && $0.secureElementPass?.passActivationState != .deactivated })
+            } else {
+                return PKPassLibrary().remotePaymentPasses()
+                    .first(where: { $0.paymentPass?.primaryAccountNumberSuffix == last4 && $0.paymentPass?.passActivationState != .deactivated })
+            }
+        }()
+        
+        
+        if (existingPassOnPairedDevices != nil) {
+            passLocations.append(.PAIRED_DEVICE)
+        }
+        
+        completion(
+            passLocations.count < 2,
+            passLocations
+        )
+    }
+}

package/ios/PushProvisioning/AddToWalletButtonView.swift

@@ -19,20 +19,10 @@ class AddToWalletButtonView: UIView {
     @objc var ephemeralKey: NSDictionary?
     @objc var onCompleteAction: RCTDirectEventBlock?
 
-    override init(frame: CGRect) {
-        super.init(frame: frame)
-    }
-
     required init?(coder: NSCoder) {
         fatalError("init(coder:) has not been implemented")
     }
 
-    override func layoutSubviews() {
-        if let addToWalletButton = self.addToWalletButton {
-            addToWalletButton.frame = self.bounds
-        }
-    }
-
     override func didSetProps(_ changedProps: [String]!) {
         if let addToWalletButton = addToWalletButton {
             addToWalletButton.removeFromSuperview()
@@ -96,6 +86,16 @@ class AddToWalletButtonView: UIView {
         let vc = findViewControllerPresenter(from: UIApplication.shared.delegate?.window??.rootViewController ?? UIViewController())
         vc.present(controller!, animated: true, completion: nil)
     }
+    
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+    }
+    
+    override func layoutSubviews() {
+        if let addToWalletButton = self.addToWalletButton {
+            addToWalletButton.frame = self.bounds
+        }
+    }
 }
 
 

package/ios/PushProvisioning/PushProvisioningUtils.swift

@@ -12,25 +12,33 @@ internal class PushProvisioningUtils {
     class func canAddCardToWallet(
         last4: String,
         primaryAccountIdentifier: String,
-        testEnv: Bool
-    ) -> (canAddCard: Bool, status: AddCardToWalletStatus?) {
+        testEnv: Bool,
+        hasPairedAppleWatch: Bool,
+        completion: @escaping (_ canAddCard: Bool, _ status: AddCardToWalletStatus?) -> Void
+    ) {
         if (!PKAddPassesViewController.canAddPasses()) {
-            return (false, AddCardToWalletStatus.UNSUPPORTED_DEVICE)
+            completion(false, AddCardToWalletStatus.UNSUPPORTED_DEVICE)
         }
         
-        var status : AddCardToWalletStatus? = nil
-        var canAddCard = PushProvisioningUtils.canAddPaymentPass(
+        let canAddCard = canAddPaymentPass(
             primaryAccountIdentifier: primaryAccountIdentifier,
             isTestMode: testEnv)
         
         if (!canAddCard) {
-            status = AddCardToWalletStatus.MISSING_CONFIGURATION
-        } else if (PushProvisioningUtils.passExistsWith(last4: last4)) {
-            canAddCard = false
-            status = AddCardToWalletStatus.CARD_ALREADY_EXISTS
+            completion(canAddCard, AddCardToWalletStatus.MISSING_CONFIGURATION)
+        } else {
+            PaymentPassFinder.findPassWithLast4(last4: last4, hasPairedAppleWatch: hasPairedAppleWatch) { canAddCardToADevice, passLocations in
+                var status: AddCardToWalletStatus? = nil
+                if (!canAddCardToADevice) {
+                    status = AddCardToWalletStatus.CARD_ALREADY_EXISTS
+                } else if (passLocations.contains(.PAIRED_DEVICE)) {
+                    status = AddCardToWalletStatus.CARD_EXISTS_ON_PAIRED_DEVICE
+                } else if (passLocations.contains(.CURRENT_DEVICE)) {
+                    status = AddCardToWalletStatus.CARD_EXISTS_ON_CURRENT_DEVICE
+                }
+                completion(canAddCardToADevice, status)
+            }
         }
-
-        return (canAddCard, status)
     }
     
     class func canAddPaymentPass(primaryAccountIdentifier: String, isTestMode: Bool) -> Bool {
@@ -45,20 +53,35 @@ internal class PushProvisioningUtils {
         }
     }
     
-    class func passExistsWith(last4: String) -> Bool {
-        let existingPass: PKPass? = {
+    class func getPassLocation(last4: String) -> PaymentPassFinder.PassLocation? {
+        let existingPassOnDevice: PKPass? = {
             if #available(iOS 13.4, *) {
-                return PKPassLibrary().passes(of: PKPassType.secureElement).first(where: {$0.secureElementPass?.primaryAccountNumberSuffix == last4})
+                return PKPassLibrary().passes(of: PKPassType.secureElement)
+                    .first(where: { $0.secureElementPass?.primaryAccountNumberSuffix == last4 && $0.secureElementPass?.passActivationState != .suspended && !$0.isRemotePass })
             } else {
-                return PKPassLibrary().passes(of: PKPassType.payment).first(where: {$0.paymentPass?.primaryAccountNumberSuffix == last4})
+                return PKPassLibrary().passes(of: PKPassType.payment)
+                    .first(where: { $0.paymentPass?.primaryAccountNumberSuffix == last4 && $0.paymentPass?.passActivationState != .suspended && !$0.isRemotePass })
             }
         }()
-        return existingPass != nil
+        
+        let existingPassOnPairedDevices: PKPass? = {
+            if #available(iOS 13.4, *) {
+                return PKPassLibrary().remoteSecureElementPasses
+                    .first(where: { $0.secureElementPass?.primaryAccountNumberSuffix == last4 && $0.secureElementPass?.passActivationState != .suspended })
+            } else {
+                return PKPassLibrary().remotePaymentPasses()
+                    .first(where: { $0.paymentPass?.primaryAccountNumberSuffix == last4 && $0.paymentPass?.passActivationState != .suspended })
+            }
+        }()
+        
+        return existingPassOnDevice != nil ? PaymentPassFinder.PassLocation.CURRENT_DEVICE : (existingPassOnPairedDevices != nil ? PaymentPassFinder.PassLocation.PAIRED_DEVICE : nil)
     }
     
     enum AddCardToWalletStatus: String {
         case UNSUPPORTED_DEVICE
         case MISSING_CONFIGURATION
         case CARD_ALREADY_EXISTS
+        case CARD_EXISTS_ON_CURRENT_DEVICE
+        case CARD_EXISTS_ON_PAIRED_DEVICE
     }
 }