@yuno-payments/yuno-sdk-react-native 1.0.16 → 1.0.17-rc.2

package/YunoSdk.podspec

@@ -0,0 +1,48 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
+
+Pod::Spec.new do |s|
+  s.name         = "YunoSdk"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => "14.0" }
+  s.source       = { :git => "https://github.com/yuno-payments/yuno-sdk-react-native.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift}"
+
+  # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
+  # See https://github.com/facebook/react-native/blob/febf6b7f33fdb4904669f99d795eba4c0f95d7bf/scripts/cocoapods/new_architecture.rb#L79.
+  if respond_to?(:install_modules_dependencies, true)
+    install_modules_dependencies(s)
+  else
+    s.dependency "React-Core"
+
+    # Don't install the dependencies when we run `pod install` in the old architecture.
+    if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
+      s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
+      s.pod_target_xcconfig    = {
+        "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
+        "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
+        "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
+      }
+      s.dependency "React-Codegen"
+      s.dependency "RCT-Folly"
+      s.dependency "RCTRequired"
+      s.dependency "RCTTypeSafety"
+      s.dependency "ReactCommon/turbomodule/core"
+    end
+  end
+
+  # Yuno iOS SDK
+  s.dependency "YunoSDK", "2.7.1"
+  
+  s.swift_version = '5.0'
+  s.static_framework = true
+end
+

package/android/src/main/java/com/yunosdkreactnative/YunoSdkModule.kt

@@ -2,6 +2,7 @@ package com.yunosdkreactnative
 
 import android.app.Activity
 import android.content.Context
+import android.util.Log
 import androidx.activity.ComponentActivity
 import com.facebook.react.bridge.*
 import com.facebook.react.modules.core.DeviceEventManagerModule
@@ -51,6 +52,14 @@ class YunoSdkModule(private val reactContext: ReactApplicationContext) :
         @Volatile
         private var lastOneTimeTokenInfo: OneTimeTokenModel? = null
         
+        // Store the last payment status to prevent stale status from previous flows
+        @Volatile
+        private var lastPaymentStatus: String? = null
+        
+        // Flag to track if we're starting a fresh payment flow
+        @Volatile
+        private var isPaymentFlowCleared: Boolean = false
+        
         // Gson instance for JSON serialization
         private val gson = Gson()
         
@@ -612,6 +621,24 @@ class YunoSdkModule(private val reactContext: ReactApplicationContext) :
         }
     }
 
+    /**
+     * Clears the last stored payment status.
+     * This should be called at the start of each new payment flow
+     * to prevent stale status from previous flows.
+     */
+    @ReactMethod
+    fun clearLastPaymentStatus(promise: Promise) {
+        try {
+            // Don't set to null - keep the last status to compare against stale events
+            // Just mark that we're starting a fresh flow
+            isPaymentFlowCleared = true
+            Log.d(TAG, "💫 Payment status cleared - fresh flow starting (last status was: $lastPaymentStatus)")
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("CLEAR_STATUS_ERROR", "Error clearing last payment status: ${e.message}", e)
+        }
+    }
+
     // Lifecycle Methods
     override fun onHostResume() {}
     override fun onHostPause() {}
@@ -651,6 +678,26 @@ class YunoSdkModule(private val reactContext: ReactApplicationContext) :
 
     internal fun sendPaymentStatusEvent(status: String?) {
         val convertedStatus = convertPaymentStatus(status)
+        
+        // If we just cleared the status and this is the same status as before,
+        // it's a stale event from the native SDK - ignore it
+        if (isPaymentFlowCleared && convertedStatus == lastPaymentStatus) {
+            Log.d(TAG, "🚫 Ignoring stale payment status: $convertedStatus (from previous flow)")
+            isPaymentFlowCleared = false
+            lastPaymentStatus = null  // Clear it now that we've ignored the stale event
+            return
+        }
+        
+        // Reset the cleared flag after processing first real new event
+        if (isPaymentFlowCleared) {
+            Log.d(TAG, "✅ First new status after clear: $convertedStatus (previous was: $lastPaymentStatus)")
+            isPaymentFlowCleared = false
+        }
+        
+        // Store the current status for future comparison
+        lastPaymentStatus = convertedStatus
+        
+        Log.d(TAG, "✅ Emitting payment status: $convertedStatus")
         val params = Arguments.createMap().apply {
             putString("status", convertedStatus)
         }
@@ -774,4 +821,182 @@ class YunoSdkModule(private val reactContext: ReactApplicationContext) :
         }
         return array
     }
+
+    // ==================== HEADLESS PAYMENT FLOW ====================
+
+    /**
+     * Generate a one-time token (OTT) from collected payment data using the headless flow.
+     * This method mirrors the native SDK's generateToken() API.
+     * 
+     * @param tokenCollectedData Map containing checkout_session, customer_session, and payment_method data
+     * @param checkoutSession The checkout session ID
+     * @param countryCode The country code for the payment
+     * @param promise Promise to resolve with token or error
+     */
+    @ReactMethod
+    fun generateToken(
+        tokenCollectedData: ReadableMap,
+        checkoutSession: String,
+        countryCode: String,
+        promise: Promise
+    ) {
+        try {
+            Log.d(TAG, "generateToken called with checkoutSession: $checkoutSession")
+            
+            // Convert ReadableMap to TokenCollectedData using Gson
+            val gson = Gson()
+            val jsonString = convertReadableMapToJson(tokenCollectedData)
+            val collectedData = gson.fromJson(jsonString, TokenCollectedData::class.java)
+            
+            // Create API client
+            val apiClient = Yuno.apiClientPayment(
+                checkoutSession = checkoutSession,
+                countryCode = countryCode,
+                context = reactContext
+            )
+            
+            // Generate token
+            apiClient.generateToken(collectedData, reactContext).observe { result ->
+                try {
+                    when {
+                        result.containsKey("token") && result["token"] != null -> {
+                            val token = result["token"] as String
+                            Log.d(TAG, "✅ Token generated successfully")
+                            
+                            val response = Arguments.createMap().apply {
+                                putString("token", token)
+                            }
+                            promise.resolve(response)
+                        }
+                        result.containsKey("error") && result["error"] != null -> {
+                            val error = result["error"] as String
+                            Log.e(TAG, "❌ Token generation failed: $error")
+                            promise.reject("TOKEN_GENERATION_ERROR", error)
+                        }
+                        else -> {
+                            Log.e(TAG, "❌ Unknown response from token generation")
+                            promise.reject("TOKEN_GENERATION_ERROR", "Unknown error occurred")
+                        }
+                    }
+                } catch (e: Exception) {
+                    Log.e(TAG, "❌ Error processing token generation result: ${e.message}")
+                    promise.reject("TOKEN_GENERATION_ERROR", e.message)
+                }
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ Error in generateToken: ${e.message}")
+            promise.reject("TOKEN_GENERATION_ERROR", e.message)
+        }
+    }
+
+    /**
+     * Get the 3D Secure challenge URL for a checkout session.
+     * This method mirrors the native SDK's getThreeDSecureChallenge() API.
+     * 
+     * @param checkoutSession The checkout session ID
+     * @param countryCode The country code for the payment
+     * @param promise Promise to resolve with URL or error
+     */
+    @ReactMethod
+    fun getThreeDSecureChallenge(
+        checkoutSession: String,
+        countryCode: String,
+        promise: Promise
+    ) {
+        try {
+            Log.d(TAG, "getThreeDSecureChallenge called with checkoutSession: $checkoutSession")
+            
+            // Create API client
+            val apiClient = Yuno.apiClientPayment(
+                checkoutSession = checkoutSession,
+                countryCode = countryCode,
+                context = reactContext
+            )
+            
+            // Get 3DS challenge
+            apiClient.getThreeDSecureChallenge(reactContext, checkoutSession).observe { result ->
+                try {
+                    val response = Arguments.createMap().apply {
+                        putString("type", result.type)
+                        putString("data", result.data)
+                    }
+                    
+                    if (result.type == "URL") {
+                        Log.d(TAG, "✅ 3DS Challenge URL retrieved successfully")
+                        promise.resolve(response)
+                    } else {
+                        Log.e(TAG, "❌ 3DS Challenge failed: ${result.data}")
+                        promise.reject("THREE_DS_ERROR", result.data)
+                    }
+                } catch (e: Exception) {
+                    Log.e(TAG, "❌ Error processing 3DS challenge result: ${e.message}")
+                    promise.reject("THREE_DS_ERROR", e.message)
+                }
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ Error in getThreeDSecureChallenge: ${e.message}")
+            promise.reject("THREE_DS_ERROR", e.message)
+        }
+    }
+
+    /**
+     * Helper function to convert ReadableMap to JSON string.
+     */
+    private fun convertReadableMapToJson(readableMap: ReadableMap): String {
+        val json = JSONObject()
+        val iterator = readableMap.keySetIterator()
+        
+        while (iterator.hasNextKey()) {
+            val key = iterator.nextKey()
+            val value = when (readableMap.getType(key)) {
+                ReadableType.Boolean -> readableMap.getBoolean(key)
+                ReadableType.Number -> readableMap.getDouble(key)
+                ReadableType.String -> readableMap.getString(key)
+                ReadableType.Map -> convertReadableMapToJsonObject(readableMap.getMap(key)!!)
+                ReadableType.Array -> convertReadableArrayToJsonArray(readableMap.getArray(key)!!)
+                ReadableType.Null -> JSONObject.NULL
+            }
+            json.put(key, value)
+        }
+        
+        return json.toString()
+    }
+
+    private fun convertReadableMapToJsonObject(readableMap: ReadableMap): JSONObject {
+        val json = JSONObject()
+        val iterator = readableMap.keySetIterator()
+        
+        while (iterator.hasNextKey()) {
+            val key = iterator.nextKey()
+            val value = when (readableMap.getType(key)) {
+                ReadableType.Boolean -> readableMap.getBoolean(key)
+                ReadableType.Number -> readableMap.getDouble(key)
+                ReadableType.String -> readableMap.getString(key)
+                ReadableType.Map -> convertReadableMapToJsonObject(readableMap.getMap(key)!!)
+                ReadableType.Array -> convertReadableArrayToJsonArray(readableMap.getArray(key)!!)
+                ReadableType.Null -> JSONObject.NULL
+            }
+            json.put(key, value)
+        }
+        
+        return json
+    }
+
+    private fun convertReadableArrayToJsonArray(readableArray: ReadableArray): JSONArray {
+        val json = JSONArray()
+        
+        for (i in 0 until readableArray.size()) {
+            val value = when (readableArray.getType(i)) {
+                ReadableType.Boolean -> readableArray.getBoolean(i)
+                ReadableType.Number -> readableArray.getDouble(i)
+                ReadableType.String -> readableArray.getString(i)
+                ReadableType.Map -> convertReadableMapToJsonObject(readableArray.getMap(i))
+                ReadableType.Array -> convertReadableArrayToJsonArray(readableArray.getArray(i))
+                ReadableType.Null -> JSONObject.NULL
+            }
+            json.put(value)
+        }
+        
+        return json
+    }
 }

package/ios/YunoPaymentMethodsViewManager.m

@@ -0,0 +1,10 @@
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_MODULE(YunoPaymentMethodsViewManager, RCTViewManager)
+
+// Export props
+RCT_EXPORT_VIEW_PROPERTY(checkoutSession, NSString)
+RCT_EXPORT_VIEW_PROPERTY(countryCode, NSString)
+
+@end
+

package/ios/YunoPaymentMethodsViewManager.swift

@@ -0,0 +1,324 @@
+import Foundation
+import UIKit
+import SwiftUI
+import React
+import YunoSDK
+
+/**
+ * ViewManager for YunoPaymentMethodsView.
+ *
+ * This component embeds the native Yuno SDK payment methods list view
+ * into React Native, allowing developers to display payment methods in their app.
+ *
+ * Uses UIHostingController to bridge SwiftUI to UIKit for React Native.
+ */
+@objc(YunoPaymentMethodsViewManager)
+class YunoPaymentMethodsViewManager: RCTViewManager {
+    
+    override func view() -> UIView! {
+        let view = YunoPaymentMethodsView()
+        // Tell React Native this view handles its own scrolling
+        view.clipsToBounds = true
+        return view
+    }
+    
+    override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+}
+
+/**
+ * Custom UIView that wraps the Yuno payment methods SwiftUI view using UIHostingController.
+ */
+class YunoPaymentMethodsView: UIView, YunoPaymentFullDelegate {
+    
+    private var hostingController: UIHostingController<AnyView>?
+    private var _checkoutSession: String?
+    private var _countryCode: String?
+    
+    // YunoPaymentDelegate properties
+    var checkoutSession: String {
+        return _checkoutSession ?? ""
+    }
+    
+    var countryCode: String {
+        return _countryCode ?? ""
+    }
+    
+    var language: String? {
+        return nil // Use default language
+    }
+    
+    var viewController: UIViewController? {
+        return self.findViewController()
+    }
+    
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+        setupView()
+    }
+    
+    required init?(coder: NSCoder) {
+        super.init(coder: coder)
+        setupView()
+    }
+    
+    private func setupView() {
+        self.backgroundColor = .clear
+        self.isUserInteractionEnabled = true
+        self.clipsToBounds = true
+        
+        print("[YunoPaymentMethods] 🏗️ setupView called")
+        // Don't load immediately - wait for checkoutSession and countryCode props
+        // loadPaymentMethodsView() will be called from updateCheckoutSessionIfReady()
+    }
+    
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        print("[YunoPaymentMethods] 📐 layoutSubviews - frame: \(self.frame)")
+        // SwiftUI's Auto Layout constraints will handle the size
+    }
+    
+    
+    override func didMoveToWindow() {
+        super.didMoveToWindow()
+        if window != nil {
+            print("[YunoPaymentMethods] 🪟 View added to window, frame: \(self.frame)")
+            setNeedsLayout()
+            layoutIfNeeded()
+        }
+    }
+    
+    /**
+     * Loads the payment methods view asynchronously from the Yuno SDK.
+     * Uses UIHostingController to convert SwiftUI View to UIView.
+     *
+     * The key is to use a separate async function with explicit return type
+     * to help Swift's type inference select the correct overload.
+     */
+    private func loadPaymentMethodsView() {
+        print("[YunoPaymentMethods] 🔄 loadPaymentMethodsView called")
+        print("[YunoPaymentMethods] 📋 Current checkoutSession: \(self.checkoutSession)")
+        print("[YunoPaymentMethods] 🌍 Current countryCode: \(self.countryCode)")
+        
+        Task { @MainActor in
+            // Get the SwiftUI view by calling the helper function
+            // that explicitly returns 'some View' type
+            print("[YunoPaymentMethods] 🎨 Getting SwiftUI view from Yuno SDK...")
+            let swiftUIView = await getYunoSwiftUIView()
+            print("[YunoPaymentMethods] ✅ SwiftUI view obtained")
+            
+            // Wrap SwiftUI view in UIHostingController
+            let hostingController = UIHostingController(rootView: AnyView(swiftUIView))
+            hostingController.view.backgroundColor = .clear
+            self.hostingController = hostingController
+            
+            guard let hostingView = hostingController.view else { return }
+            
+            print("[YunoPaymentMethods] ➕ Adding SwiftUI hostingView")
+            
+            // Add to view controller hierarchy for proper event handling
+            if let parentVC = self.findViewController() {
+                parentVC.addChild(hostingController)
+                hostingController.didMove(toParent: parentVC)
+            }
+            
+            // Add as subview and pin to edges
+            self.addSubview(hostingView)
+            hostingView.translatesAutoresizingMaskIntoConstraints = false
+            NSLayoutConstraint.activate([
+                hostingView.topAnchor.constraint(equalTo: self.topAnchor),
+                hostingView.leadingAnchor.constraint(equalTo: self.leadingAnchor),
+                hostingView.trailingAnchor.constraint(equalTo: self.trailingAnchor),
+                hostingView.bottomAnchor.constraint(equalTo: self.bottomAnchor)
+            ])
+            
+            print("[YunoPaymentMethods] ✅ Payment methods view loaded")
+        }
+    }
+    
+    /**
+     * Helper function that explicitly returns SwiftUI View type.
+     * This helps Swift's type inference select the correct overload.
+     */
+    @MainActor
+    private func getYunoSwiftUIView() async -> some View {
+        // By declaring the return type as 'some View', Swift knows to call
+        // the SwiftUI version of getPaymentMethodViewAsync
+        await Yuno.getPaymentMethodViewAsync(delegate: self)
+    }
+    
+    /**
+     * Updates the checkout session.
+     */
+    @objc func setCheckoutSession(_ checkoutSession: String) {
+        print("[YunoPaymentMethods] 📝 setCheckoutSession called with: \(checkoutSession)")
+        self._checkoutSession = checkoutSession
+        updateCheckoutSessionIfReady()
+    }
+    
+    /**
+     * Updates the country code.
+     */
+    @objc func setCountryCode(_ countryCode: String) {
+        print("[YunoPaymentMethods] 📝 setCountryCode called with: \(countryCode)")
+        self._countryCode = countryCode
+        updateCheckoutSessionIfReady()
+    }
+    
+    /**
+     * Updates the checkout session in Yuno SDK if both checkoutSession and countryCode are available.
+     * Once both are set, loads the payment methods view.
+     */
+    private func updateCheckoutSessionIfReady() {
+        guard let checkoutSession = _checkoutSession,
+              let countryCode = _countryCode,
+              !checkoutSession.isEmpty,
+              !countryCode.isEmpty else {
+            print("[YunoPaymentMethods] ⏳ Waiting for both checkoutSession and countryCode")
+            return
+        }
+        
+        // Check if view is already loaded
+        if hostingController != nil {
+            print("[YunoPaymentMethods] ✅ View already loaded, skipping reload")
+            return
+        }
+        
+        // The YunoPaymentDelegate protocol properties (checkoutSession, countryCode) 
+        // are already implemented above and Yuno SDK will read them automatically
+        print("[YunoPaymentMethods] ✅✅ Checkout session ready: \(checkoutSession), country: \(countryCode)")
+        print("[YunoPaymentMethods] 🚀 Now loading payment methods view...")
+        
+        // Now that we have both props, load the view
+        loadPaymentMethodsView()
+    }
+    
+    // MARK: - YunoPaymentDelegate
+    
+    func yunoCreatePayment(with token: String) {
+        print("[YunoPaymentMethods] yunoCreatePayment called with token: \(token)")
+        
+        // Emit OTT token event to React Native
+        DispatchQueue.main.async {
+            if let bridge = RCTBridge.current() {
+                if let yunoModule = bridge.module(for: YunoSdk.self) as? YunoSdk {
+                    yunoModule.sendOneTimeTokenEvent(token: token)
+                }
+            }
+        }
+    }
+    
+    func yunoCreatePayment(with token: String, information: [String : Any]) {
+        print("[YunoPaymentMethods] yunoCreatePayment called with token and information")
+        
+        // Emit OTT token event with full information to React Native
+        DispatchQueue.main.async {
+            if let bridge = RCTBridge.current() {
+                if let yunoModule = bridge.module(for: YunoSdk.self) as? YunoSdk {
+                    yunoModule.sendOneTimeTokenEvent(token: token)
+                    // The information parameter contains additional token details
+                    // It's already sent via sendOneTimeTokenEvent which emits both events
+                }
+            }
+        }
+    }
+    
+    func yunoPaymentResult(_ result: Yuno.Result) {
+        print("[YunoPaymentMethods] yunoPaymentResult: \(result)")
+        
+        // Emit payment status event to React Native
+        let statusString: String
+        switch result {
+        case .succeeded:
+            statusString = "SUCCEEDED"
+        case .fail:
+            statusString = "FAILED"
+        case .reject:
+            statusString = "REJECTED"
+        case .processing:
+            statusString = "PROCESSING"
+        case .internalError:
+            statusString = "INTERNAL_ERROR"
+        case .userCancelled:
+            statusString = "CANCELLED_BY_USER"
+        @unknown default:
+            statusString = "UNKNOWN"
+        }
+        
+        DispatchQueue.main.async {
+            if let bridge = RCTBridge.current() {
+                if let yunoModule = bridge.module(for: YunoSdk.self) as? YunoSdk {
+                    yunoModule.sendPaymentStatusEvent(status: statusString)
+                }
+            }
+        }
+    }
+    
+    // MARK: - YunoPaymentFullDelegate
+    
+    func yunoDidSelect(paymentMethod: YunoSDK.PaymentMethodSelected) {
+        // Emit event to React Native
+        print("[YunoPaymentMethods] Payment method selected")
+        emitPaymentSelectedEvent(isSelected: true)
+    }
+    
+    func yunoDidUnenrollSuccessfully(_ success: Bool) {
+        print("[YunoPaymentMethods] yunoDidUnenrollSuccessfully: \(success)")
+    }
+    
+    func yunoUpdatePaymentMethodsViewHeight(_ height: CGFloat) {
+        // Update view height if needed
+        print("[YunoPaymentMethods] yunoUpdatePaymentMethodsViewHeight: \(height)")
+    }
+    
+    // MARK: - Event Emission
+    
+    /**
+     * Emits a payment method selected event to React Native.
+     */
+    private func emitPaymentSelectedEvent(isSelected: Bool) {
+        // Send event through YunoSdk module
+        DispatchQueue.main.async {
+            if let bridge = RCTBridge.current() {
+                if let yunoModule = bridge.module(for: YunoSdk.self) as? YunoSdk {
+                    yunoModule.sendEvent(
+                        withName: "onPaymentMethodSelected",
+                        body: ["isSelected": isSelected]
+                    )
+                }
+            }
+        }
+    }
+    
+    /**
+     * Emits an error event to React Native.
+     */
+    private func emitErrorEvent(message: String) {
+        DispatchQueue.main.async {
+            if let bridge = RCTBridge.current() {
+                if let yunoModule = bridge.module(for: YunoSdk.self) as? YunoSdk {
+                    yunoModule.sendEvent(
+                        withName: "onPaymentMethodError",
+                        body: ["message": message]
+                    )
+                }
+            }
+        }
+    }
+}
+
+// MARK: - UIView extension to find view controller
+
+extension UIView {
+    func findViewController() -> UIViewController? {
+        if let nextResponder = self.next as? UIViewController {
+            return nextResponder
+        } else if let nextResponder = self.next as? UIView {
+            return nextResponder.findViewController()
+        } else {
+            return nil
+        }
+    }
+}
+

package/ios/YunoSdk.m

@@ -33,7 +33,9 @@ RCT_EXTERN_METHOD(
 )
 
 RCT_EXTERN_METHOD(
-    continuePayment:(BOOL)showPaymentStatus
+    continuePayment:(NSString *)checkoutSession
+    countryCode:(NSString *)countryCode
+    showPaymentStatus:(BOOL)showPaymentStatus
     resolver:(RCTPromiseResolveBlock)resolver
     rejecter:(RCTPromiseRejectBlock)rejecter
 )
@@ -56,10 +58,45 @@ RCT_EXTERN_METHOD(
     rejecter:(RCTPromiseRejectBlock)rejecter
 )
 
-+ (BOOL)requiresMainQueueSetup
-{
-    return YES;
-}
+RCT_EXTERN_METHOD(
+    getLastOneTimeToken:(RCTPromiseResolveBlock)resolver
+    rejecter:(RCTPromiseRejectBlock)rejecter
+)
+
+RCT_EXTERN_METHOD(
+    getLastOneTimeTokenInfo:(RCTPromiseResolveBlock)resolver
+    rejecter:(RCTPromiseRejectBlock)rejecter
+)
+
+RCT_EXTERN_METHOD(
+    clearLastOneTimeToken:(RCTPromiseResolveBlock)resolver
+    rejecter:(RCTPromiseRejectBlock)rejecter
+)
+
+RCT_EXTERN_METHOD(
+    clearLastPaymentStatus:(RCTPromiseResolveBlock)resolver
+    rejecter:(RCTPromiseRejectBlock)rejecter
+)
+
+RCT_EXTERN_METHOD(addListener:(NSString *)eventName)
+
+RCT_EXTERN_METHOD(removeListeners:(double)count)
+
+// Headless Payment Flow
+RCT_EXTERN_METHOD(
+    generateToken:(NSDictionary *)tokenCollectedData
+    checkoutSession:(NSString *)checkoutSession
+    countryCode:(NSString *)countryCode
+    resolver:(RCTPromiseResolveBlock)resolver
+    rejecter:(RCTPromiseRejectBlock)rejecter
+)
+
+RCT_EXTERN_METHOD(
+    getThreeDSecureChallenge:(NSString *)checkoutSession
+    countryCode:(NSString *)countryCode
+    resolver:(RCTPromiseResolveBlock)resolver
+    rejecter:(RCTPromiseRejectBlock)rejecter
+)
 
 @end