@primer-io/react-native 0.15.4 → 0.16.0

package/ios/Headless Universal Checkout/RNTPrimerHeadlessUniversalCheckout.swift

@@ -0,0 +1,241 @@
+//
+//  RNTPrimerHeadlessUniversalCheckout.swift
+//  primer-io-react-native
+//
+//  Created by Evangelos on 8/3/22.
+//
+
+import Foundation
+import PrimerSDK
+
+@objc
+enum PrimerHeadlessUniversalCheckoutEvents: Int, CaseIterable {
+    case clientSessionDidSetUpSuccessfully = 0
+    case preparationStarted
+    case paymentMethodPresented
+    case tokenizationStarted
+    case tokenizationSucceeded
+    case resume
+    case error
+    
+    var stringValue: String {
+        switch self {
+        case .clientSessionDidSetUpSuccessfully:
+            return "clientSessionDidSetUpSuccessfully"
+        case .preparationStarted:
+            return "preparationStarted"
+        case .paymentMethodPresented:
+            return "paymentMethodPresented"
+        case .tokenizationStarted:
+            return "tokenizationStarted"
+        case .tokenizationSucceeded:
+            return "tokenizationSucceeded"
+        case .resume:
+            return "resume"
+        case .error:
+            return "error"
+        }
+    }
+}
+
+@objc(PrimerHeadlessUniversalCheckout)
+class RNTPrimerHeadlessUniversalCheckout: RCTEventEmitter {
+    
+    private var resumeTokenCompletion: ((_ resumeToken: String) -> Void)?
+    
+    override class func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+    
+    override init() {
+        super.init()
+        PrimerHeadlessUniversalCheckout.current.delegate = self
+    }
+    
+    override func supportedEvents() -> [String]! {
+        return PrimerHeadlessUniversalCheckoutEvents.allCases.compactMap({ $0.stringValue })
+    }
+    
+    // MARK: - API
+    
+    @objc
+    public func startWithClientToken(_ clientToken: String,
+                                     settingsStr: String?,
+                                     errorCallback: @escaping RCTResponseSenderBlock,
+                                     successCallback: @escaping RCTResponseSenderBlock)
+    {
+        var settings: PrimerSettings?
+        if let settingsStr = settingsStr {
+            do {
+                let settingsData = settingsStr.data(using: .utf8)!
+                let settingsRN = try JSONDecoder().decode(PrimerSettingsRN.self, from: settingsData)
+                settings = settingsRN.asPrimerSettings()
+            } catch {
+                errorCallback([error.rnError])
+                return
+            }
+        }
+        
+        PrimerHeadlessUniversalCheckout.current.start(withClientToken: clientToken, settings: settings, delegate: self) { paymentMethodTypes, err in
+            if let err = err {
+                errorCallback([err.rnError])
+            } else if let paymentMethodTypes = paymentMethodTypes {
+                successCallback([paymentMethodTypes.compactMap({$0.rawValue})])
+            }
+        }
+    }
+    
+    @objc
+    public func resumeWithClientToken(_ resumeToken: String) {
+        self.resumeTokenCompletion?(resumeToken)
+    }
+    
+    @objc
+    public func getAssetForPaymentMethodType(_ paymentMethodTypeStr: String,
+                                             assetType assetTypeStr: String,
+                                             errorCallback: @escaping RCTResponseSenderBlock,
+                                             successCallback: @escaping RCTResponseSenderBlock)
+    {
+        do {
+            try validate(assetStr: paymentMethodTypeStr, assetTypeStr: assetTypeStr)
+            let paymentMethodType = PaymentMethodConfigType(rawValue: paymentMethodTypeStr)
+            
+            guard let image = PrimerHeadlessUniversalCheckout.getAsset(for: paymentMethodType, assetType: PrimerAsset.ImageType(rawValue: assetTypeStr)!) else {
+                let err = NativeError(errorId: "missing-asset", errorDescription: "Failed to find \(assetTypeStr) for \(paymentMethodTypeStr)", recoverySuggestion: nil)
+                errorCallback([err.rnError])
+                return
+            }
+            
+            
+            let imageURL = try self.tempStoreImage(image: image, name: paymentMethodTypeStr)
+            successCallback([imageURL.absoluteString])
+        } catch {
+            errorCallback([error.rnError])
+        }
+    }
+    
+    @objc
+    public func getAssetForCardNetwork(_ cardNetworkStr: String,
+                                       assetType assetTypeStr: String,
+                                       errorCallback: @escaping RCTResponseSenderBlock,
+                                       successCallback: @escaping RCTResponseSenderBlock)
+    {
+        do {
+            try validate(assetStr: cardNetworkStr, assetTypeStr: assetTypeStr)
+            guard let cardNetwork = CardNetwork(rawValue: cardNetworkStr) else {
+                let err = NativeError(errorId: "invalid-card-network", errorDescription: "Card network for \(cardNetworkStr) does not exist, make sure you don't have any typos.", recoverySuggestion: nil)
+                errorCallback([err.rnError])
+                return
+            }
+            
+            guard let image = PrimerHeadlessUniversalCheckout.getAsset(for: cardNetwork, assetType: PrimerAsset.ImageType(rawValue: assetTypeStr)!) else {
+                let err = NativeError(errorId: "missing-asset", errorDescription: "Failed to find \(assetTypeStr) for \(cardNetworkStr)", recoverySuggestion: nil)
+                errorCallback([err.rnError])
+                return
+            }
+            
+            
+            let imageURL = try self.tempStoreImage(image: image, name: cardNetworkStr)
+            successCallback([imageURL.absoluteString])
+        } catch {
+            errorCallback([error.rnError])
+        }
+    }
+    
+    @objc
+    public func showPaymentMethod(_ paymentMethodTypeStr: String) {
+        let paymentMethodType = PrimerPaymentMethodType(rawValue: paymentMethodTypeStr)
+        PrimerHeadlessUniversalCheckout.current.showPaymentMethod(paymentMethodType)
+    }
+    
+    // MARK: - HELPERS
+    
+    private func validate(assetStr: String, assetTypeStr: String) throws {
+        var errors: [NativeError] = []
+        
+        if PaymentMethodConfigType(rawValue: assetStr) != .other(rawValue: assetStr) {
+            // ...
+        } else if CardNetwork(rawValue: assetStr) != nil {
+            // ...
+        } else {
+            let err = NativeError(errorId: "invalid-payment-method-type", errorDescription: "Asset for \(assetStr) does not exist, make sure you don't have any typos.", recoverySuggestion: nil)
+            errors.append(err)
+        }
+        
+        
+        if PrimerAsset.ImageType(rawValue: assetTypeStr) == nil {
+            let err = NativeError(errorId: "mismatch", errorDescription: "You have provided assetType=\(assetTypeStr), which is not valid", recoverySuggestion: "Use one of the following values: \(PrimerAsset.ImageType.allCases.compactMap({ $0.rawValue }))")
+            errors.append(err)
+        }
+        
+        if errors.isEmpty {
+            return
+        } else if errors.count == 1 {
+            throw errors.first!
+        } else {
+            let errorDescription: String = errors.compactMap({ $0.errorDescription }).joined(separator: "/n")
+            let recoverySuggestion = errors.compactMap({ $0.recoverySuggestion }).joined(separator: "/n")
+            let err = NativeError(errorId: "underlying-errors", errorDescription: errorDescription, recoverySuggestion: recoverySuggestion)
+            throw err
+        }
+    }
+    
+    private func tempStoreImage(image: UIImage, name: String) throws -> URL {
+        guard let imageURL = NSURL(fileURLWithPath: NSTemporaryDirectory()).appendingPathComponent("\(name).png") else {
+            let err = NativeError(errorId: "error", errorDescription: "Failed to create URL for asset", recoverySuggestion: nil)
+            throw err
+        }
+        
+        guard let pngData = image.pngData() else {
+            let err = NativeError(errorId: "error", errorDescription: "Failed to get image's PNG data", recoverySuggestion: nil)
+            throw err
+        }
+        
+        try pngData.write(to: imageURL)
+        return imageURL
+    }
+}
+
+// MARK: - EVENTS
+
+extension RNTPrimerHeadlessUniversalCheckout: PrimerHeadlessUniversalCheckoutDelegate {
+    func primerHeadlessUniversalCheckoutClientSessionDidSetUpSuccessfully() {
+        sendEvent(withName: PrimerHeadlessUniversalCheckoutEvents.clientSessionDidSetUpSuccessfully.stringValue, body: nil)
+    }
+    
+    func primerHeadlessUniversalCheckoutPreparationStarted() {
+        sendEvent(withName: PrimerHeadlessUniversalCheckoutEvents.preparationStarted.stringValue, body: nil)
+    }
+    
+    func primerHeadlessUniversalCheckoutTokenizationStarted() {
+        sendEvent(withName: PrimerHeadlessUniversalCheckoutEvents.tokenizationStarted.stringValue, body: nil)
+    }
+    
+    func primerHeadlessUniversalCheckoutPaymentMethodPresented() {
+        sendEvent(withName: PrimerHeadlessUniversalCheckoutEvents.paymentMethodPresented.stringValue, body: nil)
+    }
+    
+    func primerHeadlessUniversalCheckoutTokenizationSucceeded(paymentMethodToken: PaymentMethodToken, resumeHandler: ResumeHandlerProtocol?) {
+        do {
+            let paymentMethodTokenData = try JSONEncoder().encode(paymentMethodToken)
+            let paymentMethodTokenStr = String(data: paymentMethodTokenData, encoding: .utf8)!
+            
+            self.resumeTokenCompletion = { (resumeToken) in
+                resumeHandler?.handle(newClientToken: resumeToken)
+            }
+            
+            sendEvent(withName: PrimerHeadlessUniversalCheckoutEvents.tokenizationSucceeded.stringValue, body: ["paymentMethodToken": paymentMethodTokenStr])
+            
+        } catch {
+            self.primerHeadlessUniversalCheckoutUniversalCheckoutDidFail(withError: error)
+        }
+    }
+    
+    func primerHeadlessUniversalCheckoutResume(withResumeToken resumeToken: String, resumeHandler: ResumeHandlerProtocol?) {
+        sendEvent(withName: PrimerHeadlessUniversalCheckoutEvents.resume.stringValue, body: ["resumeToken": resumeToken])
+    }
+    
+    func primerHeadlessUniversalCheckoutUniversalCheckoutDidFail(withError err: Error) {
+        sendEvent(withName: PrimerHeadlessUniversalCheckoutEvents.error.stringValue, body: ["error": err.rnError])
+    }
+}

package/ios/Headless Universal Checkout/RNTPrimerHeadlessUniversalCheckoutCardFormUIManager.m

@@ -0,0 +1,14 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+#import <React/RCTUIManager.h>
+#import <React/RCTView.h>
+
+@interface RCT_EXTERN_MODULE(PrimerHeadlessUniversalCheckoutCardFormUIManager, NSObject)
+
+RCT_EXTERN_METHOD(setInputElements:(NSString *)inputElements errorCallback: (RCTResponseSenderBlock)errorCallback successCallback: (RCTResponseSenderBlock)successCallback)
+
+RCT_EXTERN_METHOD(tokenize)
+
+RCT_EXTERN_METHOD(addInput:(NSNumber* __nonnull)tag)
+
+@end

package/ios/Headless Universal Checkout/RNTPrimerHeadlessUniversalCheckoutCardFormUIManager.swift

@@ -0,0 +1,113 @@
+//
+//  RNTPrimerHeadlessUniversalCheckoutCardFormUIManager.swift
+//  primer-io-react-native
+//
+//  Created by Evangelos on 4/3/22.
+//
+
+import Foundation
+import PrimerSDK
+
+@objc(PrimerHeadlessUniversalCheckoutCardFormUIManager)
+class RNTPrimerHeadlessUniversalCheckoutCardFormUIManager: RCTViewManager {
+    
+    @objc
+    override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+    
+    private lazy var cardFormUIManager: PrimerHeadlessUniversalCheckout.CardFormUIManager = {
+        return try! PrimerHeadlessUniversalCheckout.CardFormUIManager()
+    }()
+    private var successCallback: RCTResponseSenderBlock?
+    
+    deinit {
+        print("🧨 deinit: \(self) \(Unmanaged.passUnretained(self).toOpaque())")
+    }
+        
+    override init() {
+        super.init()
+        do {
+            self.cardFormUIManager = try PrimerHeadlessUniversalCheckout.CardFormUIManager()
+            self.cardFormUIManager.cardFormUIManagerDelegate = self
+        } catch {
+            
+        }
+        
+        print("⭐ init: \(self) \(Unmanaged.passUnretained(self).toOpaque())")
+    }
+    
+    @objc
+    override func constantsToExport() -> [AnyHashable : Any]! {
+        return ["message": "Hello from native code"]
+    }
+    
+    func cardFormUIManager(_ cardFormUIManager: PrimerHeadlessUniversalCheckout.CardFormUIManager, isCardFormValid: Bool) {
+        
+    }
+        
+    @objc
+    func setInputElements(_ inputElements: String, errorCallback: RCTResponseSenderBlock, successCallback: @escaping RCTResponseSenderBlock) {
+        print("RNTPrimerHeadlessUniversalCheckoutCardFormUIManager.setInputElements\n\(inputElements)")
+        print("⭐ \(self) \(Unmanaged.passUnretained(self).toOpaque())")
+        self.successCallback = successCallback
+        self.successCallback?(["what??"])
+    }
+    
+    @objc
+    func setInputElementsWithTags(_ tags: [NSNumber]) {
+        RCTUnsafeExecuteOnMainQueueSync {
+            guard let rctUIManager = self.bridge.module(for: RCTUIManager.self) as? RCTUIManager else {
+                return
+            }
+
+            for tag in tags {
+                if let view = rctUIManager.view(forReactTag: tag) {
+                    if let inputElement = view as? PrimerInputElement {
+                        self.cardFormUIManager.inputElements = [inputElement]
+                    }
+                }
+            }
+        }
+    }
+    
+    @objc
+    func addInput(_ tag: NSNumber) {
+        RCTUnsafeExecuteOnMainQueueSync {
+            guard let rctUIManager = self.bridge.module(for: RCTUIManager.self) as? RCTUIManager else {
+                return
+            }
+            
+            if let view = rctUIManager.view(forReactTag: tag) {
+                if let inputElement = view as? PrimerInputElement {
+                    self.cardFormUIManager.inputElements = [inputElement]
+                }
+            }
+            
+        }
+    }
+    
+    @objc
+    func tokenize() {
+        print("RNTPrimerHeadlessUniversalCheckoutCardFormUIManager.tokenize")
+    }
+    
+}
+
+extension RNTPrimerHeadlessUniversalCheckoutCardFormUIManager: PrimerInputElementDelegate {
+    
+    func inputElementDidFocus(_ sender: PrimerInputElement) {
+        
+    }
+    
+    func inputElementDidBlur(_ sender: PrimerInputElement) {
+        
+    }
+    
+}
+
+extension RNTPrimerHeadlessUniversalCheckoutCardFormUIManager: PrimerCardFormDelegate {
+    
+    
+    
+}

package/ios/{Pods/Manifest.lock → Podfile.lock}

@@ -1,3 +1,3 @@
 PODFILE CHECKSUM: 0984f720d2439f86374726bfdebe32d895fdcf46
 
-COCOAPODS: 1.10.1
+COCOAPODS: 1.11.2

package/ios/RNTPrimer.swift

@@ -320,6 +320,20 @@ extension RNTPrimer: PrimerDelegate {
         }
     }
     
+    func tokenAddedToVault(_ token: PaymentMethodToken) {
+        DispatchQueue.main.async {
+            if self.implementedReactNativeCallbacks?.isTokenAddedToVaultImplemented == true {
+                do {
+                    let paymentMethodTokenData = try JSONEncoder().encode(token)
+                    let paymentMethodTokenJson = try JSONSerialization.jsonObject(with: paymentMethodTokenData, options: .allowFragments)
+                    self.sendEvent(withName: PrimerEvents.onVaultSuccess.stringValue, body: paymentMethodTokenJson)
+                } catch {
+                    self.checkoutFailed(with: error)
+                }
+            }
+        }
+    }
+    
     func onTokenizeSuccess(_ paymentMethodToken: PaymentMethodToken, resumeHandler: ResumeHandlerProtocol) {
         DispatchQueue.main.async {
             self.onTokenizeSuccess = { (newClientToken, err) in

package/lib/commonjs/Primer.js

@@ -78,151 +78,107 @@ const resumeHandler = {
     }
   }
 };
-const PrimerNativeMapping = {
-  showUniversalCheckout(clientToken, config) {
-    _RNPrimer.default.removeAllListeners();
 
-    if (config.settings || config.theme) {
-      _RNPrimer.default.configure(config.settings || null, config.theme || null);
-
-      let implementedRNCallbacks = {
-        // isClientTokenCallbackImplemented: (config.onClientTokenCallback !== undefined),
-        isTokenAddedToVaultImplemented: config.onTokenAddedToVault !== undefined,
-        isOnResumeSuccessImplemented: config.onResumeSuccess !== undefined,
-        isOnResumeErrorImplemented: config.onError !== undefined,
-        isOnCheckoutDismissedImplemented: config.onDismiss !== undefined,
-        isCheckoutFailedImplemented: config.onError !== undefined,
-        isClientSessionActionsImplemented: config.onClientSessionActions !== undefined
-      };
+function configureListeners(config) {
+  _RNPrimer.default.removeAllListeners();
 
-      _RNPrimer.default.setImplementedRNCallbacks(implementedRNCallbacks).then(() => {
-        _RNPrimer.default.addListener('onClientSessionActions', data => {
-          const clientSessionActions = data;
-
-          if (config.onClientSessionActions) {
-            config.onClientSessionActions(clientSessionActions, resumeHandler);
-          }
-        });
-
-        _RNPrimer.default.addListener('onTokenizeSuccessCallback', data => {
-          const paymentInstrumentToken = data;
-
-          if (config.onTokenizeSuccess) {
-            config.onTokenizeSuccess(paymentInstrumentToken, resumeHandler);
-          }
-        });
-
-        _RNPrimer.default.addListener('onResumeSuccess', data => {
-          const resumeToken = data.resumeToken;
-
-          if (config.onResumeSuccess) {
-            config.onResumeSuccess(resumeToken, resumeHandler);
-          }
-        });
-
-        _RNPrimer.default.addListener('onCheckoutDismissed', _ => {
-          if (config.onDismiss) {
-            config.onDismiss();
-          }
-        });
-
-        _RNPrimer.default.addListener('onError', data => {
-          const err = data.error;
-
-          if (config.onError) {
-            config.onError(err, resumeHandler);
-          }
-        });
-
-        _RNPrimer.default.showUniversalCheckout(clientToken);
-      }).catch(err => {
-        console.error(err);
-      });
-    } // RNPrimer.addListener('onClientTokenCallback', _ => {
-    //   if (config.onClientTokenCallback) {
-    //     config.onClientTokenCallback(resumeHandler);
-    //   }
-    // });
+  _RNPrimer.default.addListener('onVaultSuccess', data => {
+    const paymentInstrumentToken = data;
 
-  },
+    if (config.onVaultSuccess) {
+      config.onVaultSuccess(paymentInstrumentToken);
+    }
+  });
 
-  showVaultManager(clientToken, config) {
-    _RNPrimer.default.removeAllListeners();
+  _RNPrimer.default.addListener('onClientSessionActions', data => {
+    const clientSessionActions = data;
 
-    if (config.settings || config.theme) {
-      _RNPrimer.default.configure(config.settings || null, config.theme || null);
-
-      let implementedRNCallbacks = {
-        // isClientTokenCallbackImplemented: (config.onClientTokenCallback !== undefined),
-        isTokenAddedToVaultImplemented: config.onTokenAddedToVault !== undefined,
-        isOnResumeSuccessImplemented: config.onResumeSuccess !== undefined,
-        isOnResumeErrorImplemented: config.onError !== undefined,
-        isOnCheckoutDismissedImplemented: config.onDismiss !== undefined,
-        isCheckoutFailedImplemented: config.onError !== undefined,
-        isClientSessionActionsImplemented: config.onClientSessionActions !== undefined
-      };
+    if (config.onClientSessionActions) {
+      config.onClientSessionActions(clientSessionActions, resumeHandler);
+    }
+  });
 
-      _RNPrimer.default.setImplementedRNCallbacks(implementedRNCallbacks);
-    } // RNPrimer.addListener('onClientTokenCallback', _ => {
-    //   if (config.onClientTokenCallback) {
-    //     config.onClientTokenCallback(resumeHandler);
-    //   }
-    // });
+  _RNPrimer.default.addListener('onTokenizeSuccessCallback', data => {
+    const paymentInstrumentToken = data;
 
+    if (config.onTokenizeSuccess) {
+      config.onTokenizeSuccess(paymentInstrumentToken, resumeHandler);
+    }
+  });
 
-    _RNPrimer.default.addListener('onClientSessionActions', data => {
-      const clientSessionActions = data;
+  _RNPrimer.default.addListener('onResumeSuccess', data => {
+    const resumeToken = data.resumeToken;
 
-      if (config.onClientSessionActions) {
-        config.onClientSessionActions(clientSessionActions, resumeHandler);
-      } else {
-        _RNPrimer.default.handleSuccess();
-      }
-    });
+    if (config.onResumeSuccess) {
+      config.onResumeSuccess(resumeToken, resumeHandler);
+    }
+  });
 
-    _RNPrimer.default.addListener('onTokenizeSuccessCallback', data => {
-      const paymentInstrumentToken = data;
+  _RNPrimer.default.addListener('onCheckoutDismissed', _ => {
+    if (config.onDismiss) {
+      config.onDismiss();
+    }
 
-      if (config.onTokenizeSuccess) {
-        config.onTokenizeSuccess(paymentInstrumentToken, resumeHandler);
-      }
-    });
+    _RNPrimer.default.removeAllListeners();
+  });
 
-    _RNPrimer.default.addListener('onResumeSuccess', data => {
-      const resumeToken = data.resumeToken;
+  _RNPrimer.default.addListener('onError', data => {
+    const err = data.error;
 
-      if (config.onResumeSuccess) {
-        config.onResumeSuccess(resumeToken, resumeHandler);
-      }
-    });
+    if (config.onError) {
+      config.onError(err, resumeHandler);
+    }
+  });
+}
 
-    _RNPrimer.default.addListener('onCheckoutDismissed', () => {
-      if (config.onDismiss) {
-        config.onDismiss();
-      }
-    });
+const PrimerNativeMapping = {
+  showUniversalCheckout(clientToken, config) {
+    _RNPrimer.default.configure(config.settings || null, config.theme || null);
 
-    _RNPrimer.default.addListener('onError', data => {
-      const err = data.error;
+    let implementedRNCallbacks = {
+      isTokenAddedToVaultImplemented: config.onVaultSuccess !== undefined,
+      isOnResumeSuccessImplemented: config.onResumeSuccess !== undefined,
+      isOnResumeErrorImplemented: config.onError !== undefined,
+      isOnCheckoutDismissedImplemented: config.onDismiss !== undefined,
+      isCheckoutFailedImplemented: config.onError !== undefined,
+      isClientSessionActionsImplemented: config.onClientSessionActions !== undefined
+    };
 
-      if (config.onError) {
-        config.onError(err, resumeHandler);
-      }
+    _RNPrimer.default.setImplementedRNCallbacks(implementedRNCallbacks).then(() => {
+      configureListeners(config);
+
+      _RNPrimer.default.showUniversalCheckout(clientToken);
+    }).catch(err => {
+      console.error(err);
     });
+  },
+
+  showVaultManager(clientToken, config) {
+    _RNPrimer.default.configure(config.settings || null, config.theme || null);
+
+    let implementedRNCallbacks = {
+      isTokenAddedToVaultImplemented: config.onVaultSuccess !== undefined,
+      isOnResumeSuccessImplemented: config.onResumeSuccess !== undefined,
+      isOnResumeErrorImplemented: config.onError !== undefined,
+      isOnCheckoutDismissedImplemented: config.onDismiss !== undefined,
+      isCheckoutFailedImplemented: config.onError !== undefined,
+      isClientSessionActionsImplemented: config.onClientSessionActions !== undefined
+    };
 
-    _RNPrimer.default.showVaultManager(clientToken);
+    _RNPrimer.default.setImplementedRNCallbacks(implementedRNCallbacks).then(() => {
+      configureListeners(config);
+
+      _RNPrimer.default.showVaultManager(clientToken);
+    }).catch(err => {
+      console.error(err);
+    });
   },
 
   showPaymentMethod(clientToken, intent, config) {
-    _RNPrimer.default.removeAllListeners();
-
-    if (config.settings || config.theme) {
-      _RNPrimer.default.configure(config.settings || null, config.theme || null);
-    }
+    _RNPrimer.default.configure(config.settings || null, config.theme || null);
 
     let implementedRNCallbacks = {
-      // isClientTokenCallbackImplemented: (config.onClientTokenCallback !== undefined),
-      isTokenAddedToVaultImplemented: config.onTokenAddedToVault !== undefined,
+      isTokenAddedToVaultImplemented: config.onVaultSuccess !== undefined,
       isOnResumeSuccessImplemented: config.onResumeSuccess !== undefined,
       isOnResumeErrorImplemented: config.onError !== undefined,
       isOnCheckoutDismissedImplemented: config.onDismiss !== undefined,
@@ -230,9 +186,13 @@ const PrimerNativeMapping = {
       isClientSessionActionsImplemented: config.onClientSessionActions !== undefined
     };
 
-    _RNPrimer.default.setImplementedRNCallbacks(implementedRNCallbacks);
+    _RNPrimer.default.setImplementedRNCallbacks(implementedRNCallbacks).then(() => {
+      configureListeners(config);
 
-    _RNPrimer.default.showPaymentMethod(clientToken, intent.paymentMethod, intent.vault === true ? "vault" : "checkout");
+      _RNPrimer.default.showPaymentMethod(clientToken, intent.paymentMethod, intent.vault === true ? "vault" : "checkout");
+    }).catch(err => {
+      console.error(err);
+    });
   },
 
   dispose() {