react-native-hyperswitch-dev-sdk 0.4.1

package/ios/hyperswitchSDK/Core/HyperPaymentWidget/PaymentWidget.swift

@@ -0,0 +1,212 @@
+//
+//  PaymentWidget.swift
+//  hyperswitch
+//
+//  Created by Harshit Srivastava on 21/04/26.
+//
+
+import Combine
+import Foundation
+import React
+
+public class PaymentWidget: UIControl {
+
+    private let paymentSession: PaymentSession
+    private let configuration: PaymentSheet.Configuration?
+    private var configurationDict: [String: Any]?
+    private var widgetReactTag: NSNumber?
+    internal var rootReactTag: NSNumber? { widgetReactTag }
+    private var rootView: RCTRootView?
+    private var initCallback: ((PaymentResult) -> Void)?
+    private var shouldProceedWithPaymentCallback: ((PaymentRequestData, @escaping (Bool) -> Void) -> Void)?
+    private var cancellables = Set<AnyCancellable>()
+    private var subscribedEventNames: [String]?
+    internal var paymentEventListener: PaymentEventListener?
+
+    public init(
+        paymentSession: PaymentSession,
+        configuration: PaymentSheet.Configuration? = nil,
+        completion: @escaping ((PaymentResult) -> Void),
+        subscribe: ((PaymentEventSubscriptionBuilder) -> Void)? = nil
+    ) {
+        self.paymentSession = paymentSession
+        self.configuration = configuration
+        self.configurationDict = nil
+        if let subscribe {
+            let builder = PaymentEventSubscriptionBuilder()
+            subscribe(builder)
+            let (subscription, listener) = builder.build()
+            self.paymentEventListener = listener
+            self.subscribedEventNames = subscription.subscribedEventStrings()
+        }
+        self.initCallback = completion
+        super.init(frame: .zero)
+        commonInit()
+    }
+
+    public init(
+        paymentSession: PaymentSession,
+        configurationDict: [String: Any]?,
+        completion: @escaping ((PaymentResult) -> Void),
+        subscribe: ((PaymentEventSubscriptionBuilder) -> Void)? = nil
+    ) {
+        self.paymentSession = paymentSession
+        self.configuration = nil
+        self.configurationDict = configurationDict
+        if let subscribe {
+            let builder = PaymentEventSubscriptionBuilder()
+            subscribe(builder)
+            let (subscription, listener) = builder.build()
+            self.paymentEventListener = listener
+            self.subscribedEventNames = subscription.subscribedEventStrings()
+        }
+        self.initCallback = completion
+        super.init(frame: .zero)
+        commonInit()
+    }
+
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    public func shouldProceedWithPayment(_ callback: @escaping (PaymentRequestData, @escaping (Bool) -> Void) -> Void) {
+        self.shouldProceedWithPaymentCallback = callback
+    }
+
+    private func commonInit() {
+
+        let hyperswitchConfiguration = try? paymentSession.hyperswitchConfiguration?.toDictionary()
+        let paymentSessionConfiguration = try? paymentSession.paymentSessionConfiguration.toDictionary()
+
+        let sdkParams = SDKParams.getSDKParams()
+
+        var nativeConfig = try? configuration?.toDictionary()
+        if self.subscribedEventNames == nil {
+            self.subscribedEventNames = configurationDict?["subscribedEvents"] as? [String]
+                ?? nativeConfig?["subscribedEvents"] as? [String]
+        }
+        nativeConfig?["hideConfirmButton"] = true
+        nativeConfig?["subscribedEvents"] = subscribedEventNames
+        configurationDict?["hideConfirmButton"] = true
+        configurationDict?["subscribedEvents"] = subscribedEventNames
+
+        let props: [String: Any] = [
+            "type": "widgetPaymentSheet",
+            "hyperswitchConfig": hyperswitchConfiguration as Any,
+            "paymentSessionConfig": paymentSessionConfiguration as Any,
+            "sdkParams": sdkParams,
+            "configuration": configurationDict ?? nativeConfig as Any,
+            "from": (configurationDict != nil) ? "rn" : "nativeWidget",
+        ]
+
+        self.rootView = RNViewManager.sharedInstance.widgetViewForModule(
+            "hyperSwitch",
+            initialProperties: ["props": props]
+        )
+        if let rootView = self.rootView {
+            self.widgetReactTag = rootView.reactTag
+
+            rootView.backgroundColor = .clear
+
+            addSubview(rootView)
+
+            rootView.translatesAutoresizingMaskIntoConstraints = false
+            NSLayoutConstraint.activate([
+                rootView.topAnchor.constraint(equalTo: topAnchor),
+                rootView.bottomAnchor.constraint(equalTo: bottomAnchor),
+                rootView.leadingAnchor.constraint(equalTo: leadingAnchor),
+                rootView.trailingAnchor.constraint(equalTo: trailingAnchor),
+            ])
+        }
+
+        paymentSession.updateIntentDidStart
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] in
+                guard let self = self else { return }
+                let payload: [String: Any] = ["rootTag": self.widgetReactTag ?? -1]
+                self.rootView?.bridge.enqueueJSCall(
+                    "RCTDeviceEventEmitter",
+                    method: "emit",
+                    args: ["updateIntentInit", payload],
+                    completion: nil
+                )
+            }
+            .store(in: &cancellables)
+
+        paymentSession.updateIntentDidComplete
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] sdkAuthorization in
+                guard let self = self else { return }
+                let payload: [String: Any] = [
+                    "rootTag": self.widgetReactTag ?? -1,
+                    "sdkAuthorization": sdkAuthorization,
+                ]
+                self.rootView?.bridge.enqueueJSCall(
+                    "RCTDeviceEventEmitter",
+                    method: "emit",
+                    args: ["updateIntentComplete", payload],
+                    completion: nil
+                )
+            }
+            .store(in: &cancellables)
+    }
+
+    public func confirm() {
+        let payload: [String: Any] = [
+            "rootTag": self.widgetReactTag ?? -1,
+            "actionType": "CONFIRM_PAYMENT_ACTION",
+        ]
+        self.rootView?.bridge.enqueueJSCall(
+            "RCTDeviceEventEmitter",
+            method: "emit",
+            args: ["triggerWidgetAction", payload],
+            completion: nil
+        )
+    }
+
+    internal func setPaymentEventListener(_ listener: PaymentEventListener?) {
+        self.paymentEventListener = listener
+    }
+
+    internal func handleShouldProceedWithPayment(payload: String, callback: @escaping (Bool) -> Void) {
+        if shouldProceedWithPaymentCallback == nil {
+            callback(true)
+        } else {
+            if let data = payload.data(using: .utf8),
+                let paymentRequestData = try? JSONDecoder().decode(PaymentRequestData.self, from: data)
+            {
+                shouldProceedWithPaymentCallback?(paymentRequestData, callback)
+            }
+        }
+    }
+
+    internal func handleUpdateIntentEvent(type: String, result: String) {
+        switch type {
+        case "UPDATE_INTENT_INIT_RETURNED":
+            paymentSession.updateIntentInitReturned.send(result)
+        case "UPDATE_INTENT_COMPLETE_RETURNED":
+            paymentSession.updateIntentCompleteReturned.send(result)
+        default:
+            break
+        }
+    }
+
+    internal func handleConfirmPaymentResponse(_ result: PaymentResult) {
+        initCallback?(result)
+        initCallback = nil
+        cancellables.removeAll()
+        rootView?.removeFromSuperview()
+        rootView = nil
+        widgetReactTag = nil
+    }
+
+    internal func dispatchPaymentEvent(type: String, payload: [String: Any]) {
+        guard let listener = paymentEventListener else { return }
+        let event = PaymentEvent(type: type, payload: payload)
+        if Thread.isMainThread {
+            listener.onPaymentEvent(event)
+        } else {
+            DispatchQueue.main.async { listener.onPaymentEvent(event) }
+        }
+    }
+}

package/ios/hyperswitchSDK/Core/HyperSession/PaymentSession+UIKit.swift

@@ -0,0 +1,228 @@
+//
+//  PaymentSession+UIKit.swift
+//  hyperswitch
+//
+//  Created by Harshit Srivastava on 30/08/24.
+//
+
+import Foundation
+import React
+
+extension PaymentSession {
+
+    private static var hasResponded: Bool = false
+    internal static var headlessCompletion: ((PaymentSessionHandler) -> Void)?
+    private static var completion: ((PaymentResult) -> Void)?
+    internal static weak var activeSession: PaymentSession?  // NEW
+
+    private static func safeResolve(
+        _ callback: @escaping RCTResponseSenderBlock,
+        _ result: [Any],
+        _ resultHandler: @escaping (PaymentResult) -> Void
+    ) {
+        guard !PaymentSession.hasResponded else {
+            print("Warning: Attempt to resolve callback more than once")
+            resultHandler(.failed(error: NSError(domain: "Not Initialised", code: 0, userInfo: ["message": "An error has occurred."])))
+            return
+        }
+        PaymentSession.hasResponded = true
+        callback(result)
+    }
+
+    public func presentPaymentSheet(
+        viewController: UIViewController,
+        configuration: PaymentSheet.Configuration? = nil,
+        subscribe: ((PaymentEventSubscriptionBuilder) -> Void)? = nil,
+        completion: @escaping (PaymentResult) -> Void
+    ) {
+        let paymentSheet = PaymentSheet(
+            paymentSessionConfiguration: paymentSessionConfiguration,
+            hyperswitchConfiguration: hyperswitchConfiguration ?? nil,
+            configuration: configuration
+        )
+
+        if let subscribe {
+            let builder = PaymentEventSubscriptionBuilder()
+            subscribe(builder)
+            let (subscription, builtListener) = builder.build()
+            paymentSheet.subscribedEvents = subscription.subscribedEventStrings()
+            paymentSheet.paymentEventListener = builtListener
+        }
+        paymentSheet.present(from: viewController, completion: completion)
+    }
+
+    // MARK: for external frameworks
+    public func presentPaymentSheetWithParams(
+        viewController: UIViewController,
+        params: [String: Any],
+        subscribe: ((PaymentEventSubscriptionBuilder) -> Void)? = nil,
+        completion: @escaping (PaymentResult) -> Void
+    ) {
+        let paymentSheet = PaymentSheet(
+            paymentSessionConfiguration: paymentSessionConfiguration,
+            hyperswitchConfiguration: hyperswitchConfiguration ?? nil
+        )
+
+        if let subscribe {
+            let builder = PaymentEventSubscriptionBuilder()
+            subscribe(builder)
+            let (subscription, builtListener) = builder.build()
+            paymentSheet.subscribedEvents = subscription.subscribedEventStrings()
+            paymentSheet.paymentEventListener = builtListener
+        }
+        paymentSheet.presentWithParams(from: viewController, props: params, completion: completion)
+    }
+
+    public func getCustomerSavedPaymentMethods(
+        _ func_: @escaping (PaymentSessionHandler) -> Void,
+        configuration: SavedPaymentMethodsConfiguration? = nil
+    ) {
+        PaymentSession.hasResponded = false
+        PaymentSession.headlessCompletion = func_
+        PaymentSession.activeSession = self
+        RNHeadlessManager.sharedInstance.reinvalidateBridge()
+        let hyperswitchConfiguration = try? hyperswitchConfiguration?.toDictionary()
+        let paymentSessionConfiguration = try? paymentSessionConfiguration.toDictionary()
+        let sdkParams = SDKParams.getSDKParams()
+        let configurationDict = try? configuration.toDictionary()
+
+        var props: [String: Any] = [
+            "hyperswitchConfig": hyperswitchConfiguration as Any,
+            "paymentSessionConfig": paymentSessionConfiguration as Any,
+            "sdkParams": sdkParams,
+        ]
+
+        props["configuration"] = [
+            "paymentMethodLayout": [
+                "savedMethodCustomization": configurationDict
+            ]
+        ]
+
+        let _ = RNHeadlessManager.sharedInstance.viewForModule("HyperHeadless", initialProperties: ["props": props])
+    }
+
+    internal static func getPaymentSession(
+        getPaymentMethodData: NSDictionary,
+        getPaymentMethodData2: NSDictionary,
+        getPaymentMethodDataArray: NSArray,
+        callback: @escaping RCTResponseSenderBlock
+    ) {
+        DispatchQueue.main.async {
+            PaymentSession.hasResponded = false
+            let handler = PaymentSessionHandler(
+                getCustomerDefaultSavedPaymentMethodData: {
+                    return decodePaymentMethodData(getPaymentMethodData)
+                },
+                getCustomerLastUsedPaymentMethodData: {
+                    return decodePaymentMethodData(getPaymentMethodData2)
+                },
+                getCustomerSavedPaymentMethodData: {
+                    var array = [PaymentMethod]()
+                    for i in 0..<getPaymentMethodDataArray.count {
+                        if let map = getPaymentMethodDataArray[i] as? NSDictionary {
+                            switch decodePaymentMethodData(map) {
+                            case .success(let paymentMethod):
+                                array.append(paymentMethod)
+                            case .failure(_):
+                                continue
+                            }
+                        }
+                    }
+                    if array.isEmpty {
+                        return .failure(
+                            PMError(
+                                code: "01",
+                                message: "No default type found"
+                            )
+                        )
+                    }
+                    return .success(array)
+
+                },
+                confirmWithCustomerDefaultPaymentMethod: { cvc, resultHandler in
+                    if let paymentToken = getPaymentMethodData["payment_token"] as? String {
+                        self.completion = resultHandler
+                        var map = [String: Any]()
+                        map["paymentToken"] = paymentToken
+                        map["cvc"] = cvc
+                        self.safeResolve(callback, [map], resultHandler)
+                    }
+                },
+                confirmWithCustomerLastUsedPaymentMethod: { cvc, resultHandler in
+                    if let paymentToken = getPaymentMethodData2["payment_token"] as? String {
+                        cvc.confirm(
+                            sdkAuthorization: PaymentSession.activeSession?.paymentSessionConfiguration.sdkAuthorization ?? "",
+                            paymentToken: paymentToken
+                        )
+                        self.completion = resultHandler
+                        //                        var map = [String: Any]()
+                        //                        map["paymentToken"] = paymentToken
+                        //                        map["cvc"] = cvc
+                        //                        self.safeResolve(callback, [map], resultHandler)
+                    }
+                },
+                confirmWithCustomerPaymentToken: { paymentToken, cvc, resultHandler in
+                    self.completion = resultHandler
+                    var map = [String: Any]()
+                    map["paymentToken"] = paymentToken
+                    map["cvc"] = cvc
+                    self.safeResolve(callback, [map], resultHandler)
+                }
+            )
+            self.headlessCompletion?(handler)
+        }
+    }
+
+    internal static func exitHeadless(rnMessage: String) {
+        DispatchQueue.main.async {
+            if let data = rnMessage.data(using: .utf8) {
+                do {
+                    if let message = try JSONSerialization.jsonObject(with: data, options: []) as? [String: String] {
+                        guard let status = message["status"] else {
+                            completion?(
+                                .failed(error: NSError(domain: "UNKNOWN_ERROR", code: 0, userInfo: ["message": "An error has occurred."]))
+                            )
+                            return
+                        }
+                        switch status {
+                        case "cancelled":
+                            completion?(.canceled(data: status))
+                        case "failed", "requires_payment_method":
+                            let domain = (message["code"]) != "" ? message["code"] : "UNKNOWN_ERROR"
+                            let errorMessage = message["message"] ?? "An error has occurred."
+                            let userInfo = ["message": errorMessage]
+                            completion?(.failed(error: NSError(domain: domain ?? "UNKNOWN_ERROR", code: 0, userInfo: userInfo)))
+                        default:
+                            completion?(.completed(data: status))
+                        }
+                    } else {
+                        let domain = "UNKNOWN_ERROR"
+                        let errorMessage = "An error has occurred."
+                        let userInfo = ["message": errorMessage]
+                        self.completion?(.failed(error: NSError(domain: domain, code: 0, userInfo: userInfo)))
+                    }
+                } catch {
+                    let domain = "UNKNOWN_ERROR"
+                    let errorMessage = "An error has occurred."
+                    let userInfo = ["message": errorMessage]
+                    self.completion?(.failed(error: NSError(domain: domain, code: 0, userInfo: userInfo)))
+                }
+            }
+        }
+    }
+
+    private static func decodePaymentMethodData(_ readableMap: NSDictionary) -> Result<PaymentMethod, PMError> {
+        if let jsonData = try? JSONSerialization.data(withJSONObject: readableMap),
+            let paymentMethod = try? JSONDecoder().decode(PaymentMethod.self, from: jsonData)
+        {
+            return .success(paymentMethod)
+        } else {
+            return .failure(
+                PMError(
+                    code: readableMap["code"] as? String ?? "01",
+                    message: readableMap["message"] as? String ?? "No default type found"
+                )
+            )
+        }
+    }
+}

package/ios/hyperswitchSDK/Core/HyperSession/PaymentSessionTypes.swift

@@ -0,0 +1,174 @@
+//
+//  PaymentSessionTypes.swift
+//  hyperswitch
+//
+//  Created by Harshit Srivastava on 30/08/24.
+//
+
+import Foundation
+
+/// Represents a valid payment method with all details
+public struct PaymentMethod: Codable {
+    public let paymentToken: String
+    public let paymentMethodId: String
+    public let customerId: String
+    public let paymentMethod: String
+    public let paymentMethodType: String
+    public let paymentMethodIssuer: String
+    public let paymentMethodIssuerCode: String?
+    public let recurringEnabled: Bool
+    public let installmentPaymentEnabled: Bool
+    public let paymentExperience: [String]
+    public let card: Card?
+    public let metadata: String?
+    public let created: String
+    public let bank: String?
+    public let surchargeDetails: String?
+    public let requiresCvv: Bool
+    public let lastUsedAt: String
+    public let defaultPaymentMethodSet: Bool
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        paymentToken = try container.decode(String.self, forKey: .paymentToken)
+        paymentMethodId = try container.decodeIfPresent(String.self, forKey: .paymentMethodId) ?? ""
+        customerId = try container.decodeIfPresent(String.self, forKey: .customerId) ?? ""
+        paymentMethod = try container.decodeIfPresent(String.self, forKey: .paymentMethod) ?? ""
+        paymentMethodType = try container.decodeIfPresent(String.self, forKey: .paymentMethodType) ?? ""
+        paymentMethodIssuer = try container.decodeIfPresent(String.self, forKey: .paymentMethodIssuer) ?? ""
+        paymentMethodIssuerCode = try container.decodeIfPresent(String.self, forKey: .paymentMethodIssuerCode)
+        recurringEnabled = try container.decodeIfPresent(Bool.self, forKey: .recurringEnabled) ?? false
+        installmentPaymentEnabled = try container.decodeIfPresent(Bool.self, forKey: .installmentPaymentEnabled) ?? false
+        paymentExperience = try container.decodeIfPresent([String].self, forKey: .paymentExperience) ?? []
+        card = try container.decodeIfPresent(Card.self, forKey: .card)
+        metadata = try container.decodeIfPresent(String.self, forKey: .metadata)
+        created = try container.decodeIfPresent(String.self, forKey: .created) ?? ""
+        bank = try container.decodeIfPresent(String.self, forKey: .bank)
+        surchargeDetails = try container.decodeIfPresent(String.self, forKey: .surchargeDetails)
+        requiresCvv = try container.decodeIfPresent(Bool.self, forKey: .requiresCvv) ?? false
+        lastUsedAt = try container.decodeIfPresent(String.self, forKey: .lastUsedAt) ?? ""
+        defaultPaymentMethodSet = try container.decodeIfPresent(Bool.self, forKey: .defaultPaymentMethodSet) ?? false
+    }
+
+    enum CodingKeys: String, CodingKey {
+        case paymentToken = "payment_token"
+        case paymentMethodId = "payment_method_id"
+        case customerId = "customer_id"
+        case paymentMethod = "payment_method_str"
+        case paymentMethodType = "payment_method_type"
+        case paymentMethodIssuer = "payment_method_issuer"
+        case paymentMethodIssuerCode = "payment_method_issuer_code"
+        case recurringEnabled = "recurring_enabled"
+        case installmentPaymentEnabled = "installment_payment_enabled"
+        case paymentExperience = "payment_experience"
+        case card
+        case metadata
+        case created
+        case bank
+        case surchargeDetails = "surcharge_details"
+        case requiresCvv = "requires_cvv"
+        case lastUsedAt = "last_used_at"
+        case defaultPaymentMethodSet = "default_payment_method_set"
+    }
+}
+
+/// Represents card payment method details
+public struct Card: Codable {
+    public let scheme: String
+    public let issuerCountry: String
+    public let last4Digits: String
+    public let expiryMonth: String
+    public let expiryYear: String
+    public let cardToken: String?
+    public let cardHolderName: String
+    public let cardFingerprint: String?
+    public let nickName: String
+    public let cardNetwork: String
+    public let cardIsin: String
+    public let cardIssuer: String
+    public let cardType: String
+    public let savedToLocker: Bool
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        scheme = try container.decodeIfPresent(String.self, forKey: .scheme) ?? ""
+        issuerCountry = try container.decodeIfPresent(String.self, forKey: .issuerCountry) ?? ""
+        last4Digits = try container.decodeIfPresent(String.self, forKey: .last4Digits) ?? ""
+        expiryMonth = try container.decodeIfPresent(String.self, forKey: .expiryMonth) ?? ""
+        expiryYear = try container.decodeIfPresent(String.self, forKey: .expiryYear) ?? ""
+        cardToken = try container.decodeIfPresent(String.self, forKey: .cardToken)
+        cardHolderName = try container.decodeIfPresent(String.self, forKey: .cardHolderName) ?? ""
+        cardFingerprint = try container.decodeIfPresent(String.self, forKey: .cardFingerprint)
+        nickName = try container.decodeIfPresent(String.self, forKey: .nickName) ?? ""
+        cardNetwork = try container.decodeIfPresent(String.self, forKey: .cardNetwork) ?? ""
+        cardIsin = try container.decodeIfPresent(String.self, forKey: .cardIsin) ?? ""
+        cardIssuer = try container.decodeIfPresent(String.self, forKey: .cardIssuer) ?? ""
+        cardType = try container.decodeIfPresent(String.self, forKey: .cardType) ?? ""
+        savedToLocker = try container.decodeIfPresent(Bool.self, forKey: .savedToLocker) ?? false
+    }
+
+    enum CodingKeys: String, CodingKey {
+        case scheme
+        case issuerCountry = "issuer_country"
+        case last4Digits = "last4_digits"
+        case expiryMonth = "expiry_month"
+        case expiryYear = "expiry_year"
+        case cardToken = "card_token"
+        case cardHolderName = "card_holder_name"
+        case cardFingerprint = "card_fingerprint"
+        case nickName = "nick_name"
+        case cardNetwork = "card_network"
+        case cardIsin = "card_isin"
+        case cardIssuer = "card_issuer"
+        case cardType = "card_type"
+        case savedToLocker = "saved_to_locker"
+    }
+}
+
+/// Represents an error state in payment method retrieval
+public struct PMError: Codable, Error {
+    public let code: String
+    public let message: String
+}
+
+/// Handler for payment session operations
+public struct PaymentSessionHandler {
+    public let getCustomerDefaultSavedPaymentMethodData: () -> Result<PaymentMethod, PMError>
+    public let getCustomerLastUsedPaymentMethodData: () -> Result<PaymentMethod, PMError>
+    public let getCustomerSavedPaymentMethodData: () -> Result<[PaymentMethod], PMError>
+    private let confirmWithCustomerDefaultPaymentMethod: (_ cvc: String?, _ resultHandler: @escaping (PaymentResult) -> Void) -> Void
+    private let confirmWithCustomerLastUsedPaymentMethod:
+        (_ cvcWidget: CVCWidget, _ resultHandler: @escaping (PaymentResult) -> Void) -> Void
+    private let confirmWithCustomerPaymentToken:
+        (_ paymentToken: String, _ cvc: String?, _ resultHandler: @escaping (PaymentResult) -> Void) -> Void
+
+    public init(
+        getCustomerDefaultSavedPaymentMethodData: @escaping () -> Result<PaymentMethod, PMError>,
+        getCustomerLastUsedPaymentMethodData: @escaping () -> Result<PaymentMethod, PMError>,
+        getCustomerSavedPaymentMethodData: @escaping () -> Result<[PaymentMethod], PMError>,
+        confirmWithCustomerDefaultPaymentMethod: @escaping (_ cvc: String?, _ resultHandler: @escaping (PaymentResult) -> Void) -> Void,
+        confirmWithCustomerLastUsedPaymentMethod:
+            @escaping (_ cvcWidget: CVCWidget, _ resultHandler: @escaping (PaymentResult) -> Void) -> Void,
+        confirmWithCustomerPaymentToken:
+            @escaping (_ paymentToken: String, _ cvc: String?, _ resultHandler: @escaping (PaymentResult) -> Void) -> Void
+    ) {
+        self.getCustomerDefaultSavedPaymentMethodData = getCustomerDefaultSavedPaymentMethodData
+        self.getCustomerLastUsedPaymentMethodData = getCustomerLastUsedPaymentMethodData
+        self.getCustomerSavedPaymentMethodData = getCustomerSavedPaymentMethodData
+        self.confirmWithCustomerDefaultPaymentMethod = confirmWithCustomerDefaultPaymentMethod
+        self.confirmWithCustomerLastUsedPaymentMethod = confirmWithCustomerLastUsedPaymentMethod
+        self.confirmWithCustomerPaymentToken = confirmWithCustomerPaymentToken
+    }
+
+    public func confirmWithCustomerDefaultPaymentMethod(resultHandler: @escaping (PaymentResult) -> Void) {
+        confirmWithCustomerDefaultPaymentMethod(nil, resultHandler)
+    }
+
+    public func confirmWithCustomerLastUsedPaymentMethod(_ cvcWidget: CVCWidget, resultHandler: @escaping (PaymentResult) -> Void) {
+        confirmWithCustomerLastUsedPaymentMethod(cvcWidget, resultHandler)
+    }
+
+    public func confirmWithCustomerPaymentToken(paymentToken: String, resultHandler: @escaping (PaymentResult) -> Void) {
+        confirmWithCustomerPaymentToken(paymentToken, nil, resultHandler)
+    }
+}

package/ios/hyperswitchSDK/Core/NativeModule/HyperHeadless.m

@@ -0,0 +1,15 @@
+//
+//  HyperHeadless.m
+//  Hyperswitch
+//
+//  Created by Shivam Shashank on 06/03/24.
+//
+
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(HyperHeadless, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(getPaymentSession: (nonnull NSNumber *)rootTag :(NSDictionary)rnMessage :(NSDictionary)rnMessage2 :(NSArray)rnMessage3 :(RCTResponseSenderBlock)rnCallback)
+RCT_EXTERN_METHOD(exitHeadless: (nonnull NSNumber *)rootTag: (NSString)rnMessage)
+
+@end