@primer-io/react-native 0.16.2 → 2.1.0

package/ios/Headless Universal Checkout/RNTPrimerHeadlessUniversalCheckout.swift

@@ -10,30 +10,43 @@ import PrimerSDK
 
 @objc
 enum PrimerHeadlessUniversalCheckoutEvents: Int, CaseIterable {
-    case clientSessionDidSetUpSuccessfully = 0
-    case preparationStarted
-    case paymentMethodPresented
-    case tokenizationStarted
-    case tokenizationSucceeded
-    case resume
-    case error
+    
+    case onHUCTokenizeStart = 0
+    case onHUCPrepareStart
+    case onHUCAvailablePaymentMethodsLoaded
+    case onHUCPaymentMethodShow
+    case onTokenizeSuccess
+    case onResumeSuccess
+    case onBeforePaymentCreate
+    case onBeforeClientSessionUpdate
+    case onClientSessionUpdate
+    case onCheckoutComplete
+    case onError
     
     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"
+        case .onHUCPrepareStart:
+            return "onHUCPrepareStart"
+        case .onHUCTokenizeStart:
+            return "onHUCTokenizeStart"
+        case .onHUCPaymentMethodShow:
+            return "onHUCPaymentMethodShow"
+        case .onTokenizeSuccess:
+            return "onTokenizeSuccess"
+        case .onResumeSuccess:
+            return "onResumeSuccess"
+        case .onBeforePaymentCreate:
+            return "onBeforePaymentCreate"
+        case .onBeforeClientSessionUpdate:
+            return "onBeforeClientSessionUpdate"
+        case .onClientSessionUpdate:
+            return "onClientSessionUpdate"
+        case .onCheckoutComplete:
+            return "onCheckoutComplete"
+        case .onHUCAvailablePaymentMethodsLoaded:
+            return "onHUCAvailablePaymentMethodsLoaded"
+        case .onError:
+            return "onError"
         }
     }
 }
@@ -41,7 +54,11 @@ enum PrimerHeadlessUniversalCheckoutEvents: Int, CaseIterable {
 @objc(PrimerHeadlessUniversalCheckout)
 class RNTPrimerHeadlessUniversalCheckout: RCTEventEmitter {
     
-    private var resumeTokenCompletion: ((_ resumeToken: String) -> Void)?
+    private var primerWillCreatePaymentWithDataDecisionHandler: ((_ errorMessage: String?) -> Void)?
+    private var primerDidTokenizePaymentMethodDecisionHandler: ((_ resumeToken: String?, _ errorMessage: String?) -> Void)?
+    private var primerDidResumeWithDecisionHandler: ((_ resumeToken: String?, _ errorMessage: String?) -> Void)?
+    private var primerDidFailWithErrorDecisionHandler: ((_ errorMessage: String) -> Void)?
+    private var implementedRNCallbacks: ImplementedRNCallbacks?
     
     override class func requiresMainQueueSetup() -> Bool {
         return true
@@ -67,9 +84,7 @@ class RNTPrimerHeadlessUniversalCheckout: RCTEventEmitter {
         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()
+                settings = try PrimerSettings.initialize(with: settingsStr)
             } catch {
                 errorCallback([error.rnError])
                 return
@@ -85,11 +100,6 @@ class RNTPrimerHeadlessUniversalCheckout: RCTEventEmitter {
         }
     }
     
-    @objc
-    public func resumeWithClientToken(_ resumeToken: String) {
-        self.resumeTokenCompletion?(resumeToken)
-    }
-    
     @objc
     public func getAssetForPaymentMethodType(_ paymentMethodTypeStr: String,
                                              assetType assetTypeStr: String,
@@ -98,7 +108,7 @@ class RNTPrimerHeadlessUniversalCheckout: RCTEventEmitter {
     {
         do {
             try validate(assetStr: paymentMethodTypeStr, assetTypeStr: assetTypeStr)
-            let paymentMethodType = PaymentMethodConfigType(rawValue: paymentMethodTypeStr)
+            let paymentMethodType = PrimerPaymentMethodType(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)
@@ -143,9 +153,18 @@ class RNTPrimerHeadlessUniversalCheckout: RCTEventEmitter {
     }
     
     @objc
-    public func showPaymentMethod(_ paymentMethodTypeStr: String) {
+    public func showPaymentMethod(_ paymentMethodTypeStr: String,
+                                  resolver: RCTPromiseResolveBlock,
+                                  rejecter: RCTPromiseRejectBlock)
+    {
         let paymentMethodType = PrimerPaymentMethodType(rawValue: paymentMethodTypeStr)
         PrimerHeadlessUniversalCheckout.current.showPaymentMethod(paymentMethodType)
+        resolver(nil)
+    }
+    
+    @objc
+    public func disposePrimerHeadlessUniversalCheckout() {
+        
     }
     
     // MARK: - HELPERS
@@ -153,7 +172,7 @@ class RNTPrimerHeadlessUniversalCheckout: RCTEventEmitter {
     private func validate(assetStr: String, assetTypeStr: String) throws {
         var errors: [NativeError] = []
         
-        if PaymentMethodConfigType(rawValue: assetStr) != .other(rawValue: assetStr) {
+        if PrimerPaymentMethodType(rawValue: assetStr) != .other(rawValue: assetStr) {
             // ...
         } else if CardNetwork(rawValue: assetStr) != nil {
             // ...
@@ -194,48 +213,281 @@ class RNTPrimerHeadlessUniversalCheckout: RCTEventEmitter {
         try pngData.write(to: imageURL)
         return imageURL
     }
+    
+    // MARK: - DECISION HANDLERS
+    
+    // MARK: Tokenization
+    
+    @objc
+    public func handleTokenizationNewClientToken(_ newClientToken: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            self.primerDidTokenizePaymentMethodDecisionHandler?(newClientToken, nil)
+            self.primerDidTokenizePaymentMethodDecisionHandler = nil
+            resolver(nil)
+        }
+    }
+    
+    @objc
+    public func handleTokenizationSuccess(_ resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            self.primerDidTokenizePaymentMethodDecisionHandler?(nil, nil)
+            self.primerDidTokenizePaymentMethodDecisionHandler = nil
+            let err = NSError(domain: "native-bridge", code: 0, userInfo: [NSLocalizedDescriptionKey: "PrimerTokenizationHandler's handleSuccess function is not available on HUC."])
+            rejecter(err.rnError["errorId"]!, err.rnError["description"], err)
+        }
+    }
+    
+    @objc
+    public func handleTokenizationFailure(_ errorMessage: String?, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            self.primerDidTokenizePaymentMethodDecisionHandler?(nil, errorMessage ?? "")
+            self.primerDidTokenizePaymentMethodDecisionHandler = nil
+            let err = NSError(domain: "native-bridge", code: 0, userInfo: [NSLocalizedDescriptionKey: "PrimerTokenizationHandler's handleFailure function is not available on HUC."])
+            rejecter(err.rnError["errorId"]!, err.rnError["description"], err)
+        }
+    }
+    
+    // MARK: Resume Payment
+    
+    @objc
+    public func handleResumeWithNewClientToken(_ newClientToken: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            self.primerDidResumeWithDecisionHandler?(newClientToken, nil)
+            self.primerDidResumeWithDecisionHandler = nil
+            resolver(nil)
+        }
+    }
+    
+    @objc
+    public func handleResumeSuccess(_ resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            let err = NSError(domain: "native-bridge", code: 0, userInfo: [NSLocalizedDescriptionKey: "PrimerResumeHandler's handleSuccess function is not available on HUC."])
+            rejecter(err.rnError["errorId"]!, err.rnError["description"], err)
+        }
+    }
+    
+    @objc
+    public func handleResumeFailure(_ errorMessage: String?, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            let err = NSError(domain: "native-bridge", code: 0, userInfo: [NSLocalizedDescriptionKey: "PrimerResumeHandler's handleFailure function is not available on HUC."])
+            rejecter(err.rnError["errorId"]!, err.rnError["description"], err)
+        }
+    }
+    
+    // MARK: Payment Creation
+    
+    @objc
+    public func handlePaymentCreationAbort(_ errorMessage: String?, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            self.primerWillCreatePaymentWithDataDecisionHandler?(errorMessage ?? "")
+            self.primerWillCreatePaymentWithDataDecisionHandler = nil
+            resolver(nil)
+        }
+    }
+    
+    @objc
+    public func handlePaymentCreationContinue(_ resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            self.primerWillCreatePaymentWithDataDecisionHandler?(nil)
+            self.primerWillCreatePaymentWithDataDecisionHandler = nil
+            resolver(nil)
+        }
+    }
+    
+    // MARK: Helpers
+    
+    private func detectImplemetedCallbacks() {
+        sendEvent(withName: PrimerEvents.detectImplementedRNCallbacks.stringValue, body: nil)
+    }
+    
+    @objc
+    public func setImplementedRNCallbacks(_ implementedRNCallbacksStr: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            do {
+                guard let implementedRNCallbacksData = implementedRNCallbacksStr.data(using: .utf8) else {
+                    let err = NSError(domain: "native-bridge", code: 0, userInfo: [NSLocalizedDescriptionKey: "Failed to convert string to data"])
+                    throw err
+                }
+                self.implementedRNCallbacks = try JSONDecoder().decode(ImplementedRNCallbacks.self, from: implementedRNCallbacksData)
+                resolver(nil)
+            } catch {
+                self.handleRNBridgeError(error, checkoutData: nil, stopOnDebug: false)
+                rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
+            }
+        }
+    }
+    
+    private func handleRNBridgeError(_ error: Error, checkoutData: PrimerCheckoutData?, stopOnDebug: Bool) {
+        DispatchQueue.main.async {
+            if stopOnDebug {
+                assertionFailure(error.localizedDescription)
+            }
+            
+            var body: [String: Any] = ["error": error.rnError]
+            if let checkoutData = checkoutData,
+               let data = try? JSONEncoder().encode(checkoutData),
+               let json = try? JSONSerialization.jsonObject(with: data){
+                body["checkoutData"] = json
+            }
+
+            self.sendEvent(withName: PrimerHeadlessUniversalCheckoutEvents.onError.stringValue, body: body)
+        }
+    }
 }
 
 // MARK: - EVENTS
 
 extension RNTPrimerHeadlessUniversalCheckout: PrimerHeadlessUniversalCheckoutDelegate {
-    func primerHeadlessUniversalCheckoutClientSessionDidSetUpSuccessfully() {
-        sendEvent(withName: PrimerHeadlessUniversalCheckoutEvents.clientSessionDidSetUpSuccessfully.stringValue, body: nil)
+    
+    func primerHeadlessUniversalCheckoutPreparationDidStart(for paymentMethodType: String) {
+        sendEvent(withName: PrimerHeadlessUniversalCheckoutEvents.onHUCPrepareStart.stringValue, body: ["paymentMethodType": paymentMethodType])
     }
     
-    func primerHeadlessUniversalCheckoutPreparationStarted() {
-        sendEvent(withName: PrimerHeadlessUniversalCheckoutEvents.preparationStarted.stringValue, body: nil)
+    func primerHeadlessUniversalCheckoutTokenizationDidStart(for paymentMethodType: String) {
+        sendEvent(withName: PrimerHeadlessUniversalCheckoutEvents.onHUCTokenizeStart.stringValue, body: ["paymentMethodType": paymentMethodType])
     }
     
-    func primerHeadlessUniversalCheckoutTokenizationStarted() {
-        sendEvent(withName: PrimerHeadlessUniversalCheckoutEvents.tokenizationStarted.stringValue, body: nil)
+    func primerHeadlessUniversalCheckoutDidLoadAvailablePaymentMethods(_ paymentMethodTypes: [String]) {
+        sendEvent(withName: PrimerHeadlessUniversalCheckoutEvents.onHUCAvailablePaymentMethodsLoaded.stringValue, body: ["paymentMethodTypes": paymentMethodTypes])
     }
     
-    func primerHeadlessUniversalCheckoutPaymentMethodPresented() {
-        sendEvent(withName: PrimerHeadlessUniversalCheckoutEvents.paymentMethodPresented.stringValue, body: nil)
+    func primerHeadlessUniversalCheckoutPaymentMethodDidShow(for paymentMethodType: String) {
+        sendEvent(withName: PrimerHeadlessUniversalCheckoutEvents.onHUCPaymentMethodShow.stringValue, body: ["paymentMethodType": paymentMethodType])
     }
     
-    func primerHeadlessUniversalCheckoutTokenizationSucceeded(paymentMethodToken: PaymentMethodToken, resumeHandler: ResumeHandlerProtocol?) {
-        do {
-            let paymentMethodTokenData = try JSONEncoder().encode(paymentMethodToken)
-            let paymentMethodTokenStr = String(data: paymentMethodTokenData, encoding: .utf8)!
+    func primerHeadlessUniversalCheckoutDidTokenizePaymentMethod(_ paymentMethodTokenData: PrimerPaymentMethodTokenData, decisionHandler: @escaping (PrimerResumeDecision) -> Void) {
+        if self.implementedRNCallbacks?.isOnTokenizeSuccessImplemented == true {
+            self.primerDidTokenizePaymentMethodDecisionHandler = { (newClientToken, errorMessage) in
+                DispatchQueue.main.async {
+                    if let errorMessage = errorMessage {
+                        decisionHandler(.fail(withErrorMessage: errorMessage.isEmpty ? nil : errorMessage))
+                    } else if let newClientToken = newClientToken {
+                        decisionHandler(.continueWithNewClientToken(newClientToken))
+                    } else {
+                        decisionHandler(.succeed())
+                    }
+                }
+            }
             
-            self.resumeTokenCompletion = { (resumeToken) in
-                resumeHandler?.handle(newClientToken: resumeToken)
+            do {
+                let data = try JSONEncoder().encode(paymentMethodTokenData)
+                let json = try JSONSerialization.jsonObject(with: data, options: .allowFragments)
+                DispatchQueue.main.async {
+                    self.sendEvent(withName: PrimerHeadlessUniversalCheckoutEvents.onTokenizeSuccess.stringValue, body: json)
+                }
+            } catch {
+                self.handleRNBridgeError(error, checkoutData: nil, stopOnDebug: true)
+            }
+        } else {
+            // RN dev hasn't opted in on listening the tokenization callback.
+            // Throw an error if it's the manual flow, ignore if it's the
+            // auto flow.
+        }
+    }
+    
+    func primerHeadlessUniversalCheckoutDidResumeWith(_ resumeToken: String, decisionHandler: @escaping (PrimerResumeDecision) -> Void) {
+        if self.implementedRNCallbacks?.isOnResumeSuccessImplemented == true {
+            self.primerDidResumeWithDecisionHandler = { (resumeToken, errorMessage) in
+                DispatchQueue.main.async {
+                    if let errorMessage = errorMessage {
+                        decisionHandler(.fail(withErrorMessage: errorMessage.isEmpty ? nil : errorMessage))
+                    } else if let resumeToken = resumeToken {
+                        decisionHandler(.continueWithNewClientToken(resumeToken))
+                    } else {
+                        decisionHandler(.succeed())
+                    }
+                }
             }
             
-            sendEvent(withName: PrimerHeadlessUniversalCheckoutEvents.tokenizationSucceeded.stringValue, body: ["paymentMethodToken": paymentMethodTokenStr])
+            DispatchQueue.main.async {
+                self.sendEvent(withName: PrimerHeadlessUniversalCheckoutEvents.onResumeSuccess.stringValue, body: ["resumeToken": resumeToken])
+            }
+        } else {
+            // RN dev hasn't opted in on listening the tokenization callback.
+            // Throw an error if it's the manual flow.
+        }
+    }
+    
+    func primerHeadlessUniversalCheckoutDidFail(withError err: Error) {
+        if self.implementedRNCallbacks?.isOnErrorImplemented == true {
+            // Send the error message to the RN bridge.
+            self.handleRNBridgeError(err, checkoutData: nil, stopOnDebug: false)
             
-        } catch {
-            self.primerHeadlessUniversalCheckoutUniversalCheckoutDidFail(withError: error)
+        } else {
+            // RN dev hasn't opted in on listening SDK dismiss.
+            // Ignore!
+        }
+    }
+    
+    func primerHeadlessUniversalCheckoutDidCompleteCheckoutWithData(_ data: PrimerCheckoutData) {
+        DispatchQueue.main.async {
+            if self.implementedRNCallbacks?.isOnCheckoutCompleteImplemented == true {
+                do {
+                    let checkoutData = try JSONEncoder().encode(data)
+                    let checkoutJson = try JSONSerialization.jsonObject(with: checkoutData, options: .allowFragments)
+                    self.sendEvent(withName: PrimerHeadlessUniversalCheckoutEvents.onCheckoutComplete.stringValue, body: checkoutJson)
+                } catch {
+                    self.handleRNBridgeError(error, checkoutData: data, stopOnDebug: true)
+                }
+            } else {
+                let err = NSError(domain: "native-bridge", code: 1, userInfo: [NSLocalizedDescriptionKey: "Callback [onCheckoutComplete] should be implemented."])
+                self.handleRNBridgeError(err, checkoutData: data, stopOnDebug: false)
+            }
+        }
+    }
+    
+    func primerHeadlessUniversalCheckoutClientSessionWillUpdate() {
+        if self.implementedRNCallbacks?.isOnBeforeClientSessionUpdateImplemented == true {
+            DispatchQueue.main.async {
+                self.sendEvent(withName: PrimerHeadlessUniversalCheckoutEvents.onBeforeClientSessionUpdate.stringValue, body: nil)
+            }
+        } else {
+            // RN Dev hasn't implemented this callback, ignore.
         }
     }
     
-    func primerHeadlessUniversalCheckoutResume(withResumeToken resumeToken: String, resumeHandler: ResumeHandlerProtocol?) {
-        sendEvent(withName: PrimerHeadlessUniversalCheckoutEvents.resume.stringValue, body: ["resumeToken": resumeToken])
+    func primerHeadlessUniversalCheckoutClientSessionDidUpdate(_ clientSession: PrimerClientSession) {
+        if self.implementedRNCallbacks?.isOnClientSessionUpdateImplemented == true {
+            do {
+                let data = try JSONEncoder().encode(clientSession)
+                let json = try JSONSerialization.jsonObject(with: data, options: .allowFragments)
+                DispatchQueue.main.async {
+                    self.sendEvent(withName: PrimerHeadlessUniversalCheckoutEvents.onClientSessionUpdate.stringValue, body: json)
+                }
+            } catch {
+                self.handleRNBridgeError(error, checkoutData: nil, stopOnDebug: true)
+            }
+        } else {
+            // RN Dev hasn't implemented this callback, ignore.
+        }
     }
     
-    func primerHeadlessUniversalCheckoutUniversalCheckoutDidFail(withError err: Error) {
-        sendEvent(withName: PrimerHeadlessUniversalCheckoutEvents.error.stringValue, body: ["error": err.rnError])
+    func primerHeadlessUniversalCheckoutWillCreatePaymentWithData(_ data: PrimerCheckoutPaymentMethodData, decisionHandler: @escaping (PrimerPaymentCreationDecision) -> Void) {
+        if self.implementedRNCallbacks?.isOnBeforePaymentCreateImplemented == true {
+            self.primerWillCreatePaymentWithDataDecisionHandler = { errorMessage in
+                DispatchQueue.main.async {
+                    if let errorMessage = errorMessage {
+                        decisionHandler(.abortPaymentCreation(withErrorMessage: errorMessage.isEmpty ? nil : errorMessage))
+                    } else {
+                        decisionHandler(.continuePaymentCreation())
+                    }
+                }
+            }
+            
+            DispatchQueue.main.async {
+                do {
+                    let checkoutPaymentmethodData = try JSONEncoder().encode(data)
+                    let checkoutPaymentmethodJson = try JSONSerialization.jsonObject(with: checkoutPaymentmethodData, options: .allowFragments)
+                    self.sendEvent(withName: PrimerHeadlessUniversalCheckoutEvents.onBeforePaymentCreate.stringValue, body: checkoutPaymentmethodJson)
+                } catch {
+                    self.handleRNBridgeError(error, checkoutData: nil, stopOnDebug: true)
+                }
+            }
+        } else {
+            // RN Dev hasn't implemented this callback, send a decision to continue the flow.
+            DispatchQueue.main.async {
+                decisionHandler(.continuePaymentCreation())
+            }
+        }
     }
 }

package/ios/Headless Universal Checkout/RNTPrimerHeadlessUniversalCheckoutCardFormUIManager.swift

@@ -19,7 +19,11 @@ class RNTPrimerHeadlessUniversalCheckoutCardFormUIManager: RCTViewManager {
     private lazy var cardFormUIManager: PrimerHeadlessUniversalCheckout.CardFormUIManager = {
         return try! PrimerHeadlessUniversalCheckout.CardFormUIManager()
     }()
-    private var successCallback: RCTResponseSenderBlock?
+    private var successCallback: RCTResponseSenderBlock? {
+        didSet {
+            
+        }
+    }
     
     deinit {
         print("🧨 deinit: \(self) \(Unmanaged.passUnretained(self).toOpaque())")

package/ios/RNTPrimer.m

@@ -10,34 +10,50 @@
 
 @interface RCT_EXTERN_MODULE(NativePrimer, RCTEventEmitter)
 
-RCT_EXTERN_METHOD(configureWithSettings:(NSString *)settingsStr resolver:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
+// MARK: - PRIMER SDK API
 
-RCT_EXTERN_METHOD(configureWithTheme:(NSString *)themeStr resolver:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
-
-RCT_EXTERN_METHOD(showUniversalCheckout:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
+RCT_EXTERN_METHOD(configure:(NSString *)settingsStr resolver:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
 
 RCT_EXTERN_METHOD(showUniversalCheckoutWithClientToken:(NSString *)clientToken resolver:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
 
-RCT_EXTERN_METHOD(showVaultManager:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
+RCT_EXTERN_METHOD(showVaultManagerWithClientToken: (NSString *)clientToken resolver:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
 
-RCT_EXTERN_METHOD(showVaultManager:(NSString *)clientToken resolver:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
+RCT_EXTERN_METHOD(showPaymentMethod:(NSString *)paymentMethodStr intent:(NSString *)intentStr clientToken:(NSString *)clientToken resolver:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
 
+RCT_EXTERN_METHOD(dismiss)
 
+RCT_EXTERN_METHOD(dispose)
 
-RCT_EXTERN_METHOD(handleNewClientToken:(NSString *)clientToken resolver:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
+// MARK: - HELPERS
 
-RCT_EXTERN_METHOD(handleError:(NSString *)errorStr resolver:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
+RCT_EXTERN_METHOD(setImplementedRNCallbacks:(NSString *)implementedRNCallbacksStr resolver:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
 
-RCT_EXTERN_METHOD(handleSuccess:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
+// MARK: - DECISION HANDLERS
 
-RCT_EXTERN_METHOD(setImplementedRNCallbacks:(NSString *)implementedRNCallbacksStr resolver:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
+// MARK: Tokenization Handlers
 
+RCT_EXTERN_METHOD(handleTokenizationNewClientToken:(NSString *)newClientToken resolver:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
 
+RCT_EXTERN_METHOD(handleTokenizationSuccess:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
 
+RCT_EXTERN_METHOD(handleTokenizationFailure:(NSString *)errorMessage resolver:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
 
+// MARK: Resume Handlers
 
+RCT_EXTERN_METHOD(handleResumeWithNewClientToken:(NSString *)newClientToken resolver:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
 
-RCT_EXTERN_METHOD(showPaymentMethod:(NSString *)clientToken paymentMethodStr:(NSString *)paymentMethodStr intentStr:(NSString *)intentStr resolver:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
+RCT_EXTERN_METHOD(handleResumeSuccess:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
 
-@end
+RCT_EXTERN_METHOD(handleResumeFailure:(NSString *)errorMessage resolver:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
+
+// MARK: Payment Creation Handlers
 
+RCT_EXTERN_METHOD(handlePaymentCreationAbort:(NSString *)errorMessage resolver:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(handlePaymentCreationContinue:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
+
+// MARK: Error Handler
+
+RCT_EXTERN_METHOD(showErrorMessage:(NSString *)errorMessage resolver:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
+
+@end