react-native-hyperswitch-dev-sdk 0.4.1

package/android/src/main/java/com/hyperswitchsdkreactnative/views/PaymentElementViewManager.kt

@@ -0,0 +1,99 @@
+package com.hyperswitchsdkreactnative.views
+
+import android.app.Activity
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.NativePaymentElementManagerDelegate
+import com.facebook.react.viewmanagers.NativePaymentElementManagerInterface
+import io.hyperswitch.view.PaymentWidgetView
+
+class PaymentElementViewManager : SimpleViewManager<PaymentWidgetView>(),
+  NativePaymentElementManagerInterface<PaymentWidgetView> {
+
+  private val mDelegate: ViewManagerDelegate<PaymentWidgetView> =
+    NativePaymentElementManagerDelegate(this)
+
+  override fun getName(): String = NAME
+
+  override fun getDelegate(): ViewManagerDelegate<PaymentWidgetView> {
+    return mDelegate
+  }
+
+  private var context: ReactApplicationContext? = null
+
+  override fun createViewInstance(reactContext: ThemedReactContext): PaymentWidgetView {
+    context = reactContext.reactApplicationContext
+    return NativeWidgetContainer(context?.currentActivity)
+  }
+
+  override fun onAfterUpdateTransaction(container: PaymentWidgetView) {
+    super.onAfterUpdateTransaction(container)
+  }
+
+  @ReactProp(name = "widgetType")
+  override fun setWidgetType(container: PaymentWidgetView, widgetType: String?) {
+    container.setWidgetType(widgetType)
+  }
+
+  @ReactProp(name = "sdkAuthorization")
+  override fun setSdkAuthorization(container: PaymentWidgetView, sdkAuthorization: String?) {
+    sdkAuthorization?.let {
+      container.setSdkAuthorization(sdkAuthorization)
+    }
+  }
+
+  @ReactProp(name = "options")
+  override fun setOptions(container: PaymentWidgetView, options: Dynamic?) {
+    options?.let {
+      container.setConfiguration(it.asMap())
+    }
+  }
+
+
+//  @Suppress("UNCHECKED_CAST")
+//  private fun emitOnPaymentEvent(container: PaymentWidgetView, event: PaymentEvent) {
+//    val payloadMap = Arguments.makeNativeMap(event.payload as Map<String, Object>)
+//    val eventData = Arguments.createMap().apply {
+//      putString("eventName", event.type)
+//      putMap("payload", payloadMap)
+//    }
+//    context?.runOnUiQueueThread {
+//      context?.getJSModule(RCTEventEmitter::class.java)
+//        ?.receiveEvent(container.id, "topOnPaymentEvent", eventData)
+//    }
+//  }
+
+  override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any>? {
+    return com.facebook.react.common.MapBuilder.of(
+      "onPaymentEvent",
+      com.facebook.react.common.MapBuilder.of("registrationName", "onPaymentEvent")
+    )
+  }
+
+  private class NativeWidgetContainer(activity: Activity?) : PaymentWidgetView(activity!!) {
+    override fun requestLayout() {
+      super.requestLayout()
+      post(measureAndLayout)
+    }
+
+    private val measureAndLayout = Runnable {
+      measure(
+        MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+        MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY)
+      )
+      layout(left, top, right, bottom)
+    }
+  }
+
+  companion object {
+    const val NAME = "RCTNativePaymentElement"
+    private const val CVC_WIDGET = "cvcWidget"
+    private const val PAYMENT_ELEMENT = "paymentElement"
+    private const val WIDGET_PAYMENT_SHEET = "widgetPaymentSheet"
+    private const val PAYMENT_ELEMENT_TYPE = "payment"
+  }
+}

package/android/src/main/java/io/hyperswitch/HyperswitchReactPackageProvider.kt

@@ -0,0 +1,19 @@
+package io.hyperswitch
+
+import com.facebook.react.HyperPackageList
+import com.facebook.react.ReactNativeHost
+import com.facebook.react.ReactPackage
+import io.hyperswitch.react.HyperPackage
+//import io.hyperswitch.react.HyperReactPackageProvider
+
+/**
+ * Host-side implementation of [io.hyperswitch.react.HyperReactPackageProvider].
+ *
+ * This class lives in :app so it can reference the autolinked [PackageList]
+ * generated by the React Native Gradle plugin.
+ */
+//class HyperswitchReactPackageProvider : HyperReactPackageProvider() {
+//    override fun getPackages(host: ReactNativeHost): List<ReactPackage> {
+//        return HyperPackageList(host).packages
+//    }
+//}

package/android/src/main/java/io/hyperswitch/PaymentEventType.kt

@@ -0,0 +1,18 @@
+package io.hyperswitch
+
+import io.hyperswitch.utils.ConversionUtils
+import org.json.JSONObject
+
+interface PaymentEventListener {
+  fun onPaymentEvent(event: PaymentEvent)
+}
+
+data class PaymentEvent(
+  val type: String,
+  val payload: Map<String, Any>,
+) {
+  val data = JSONObject().apply {
+    put("type", type)
+    put("payload", ConversionUtils.convertMapToJson(payload))
+  }
+}

package/android/src/main/java/io/hyperswitch/model/ElementConfiguration.kt

@@ -0,0 +1,58 @@
+package io.hyperswitch.model
+
+import io.hyperswitch.utils.StandardResult
+
+//sealed class ElementsUpdateResult {
+//
+//    /** All elements updated successfully. */
+//    object Success : ElementsUpdateResult()
+//
+//    /**
+//     * Session token fetch failed before any element was updated.
+//     * No element was touched — safe to retry the entire call.
+//     */
+//    data class TotalFailure(
+//        val cause: Throwable
+//    ) : ElementsUpdateResult()
+//
+//    /**
+//     * Token fetch succeeded but one or more elements failed to update.
+//     * [succeeded] elements are live; [failed] elements can be selectively retried.
+//     */
+//    data class PartialFailure(
+//        val succeeded: List<HyperswitchBoundElement>,
+//        val failed: Map<HyperswitchBoundElement, Throwable>
+//    ) : ElementsUpdateResult() {
+//        val canRetry: Boolean get() = failed.isNotEmpty()
+//    }
+//}
+
+sealed class ElementUpdateIntentResult {
+  object Success : ElementUpdateIntentResult()
+  object Cancelled : ElementUpdateIntentResult()
+  data class Failure(val cause: Throwable) : ElementUpdateIntentResult()
+
+  fun ElementUpdateIntentResult.toStandardResult(): StandardResult {
+    return when (this) {
+      ElementUpdateIntentResult.Success -> {
+        StandardResult.Success(
+          message = "Element update intent completed successfully"
+        )
+      }
+
+      ElementUpdateIntentResult.Cancelled -> {
+        StandardResult.Cancelled(
+          message = "Element update intent was cancelled"
+        )
+      }
+
+      is ElementUpdateIntentResult.Failure -> {
+        StandardResult.Failed(
+          code = "element_update_failed",
+          message = cause.message ?: "Element update intent failed",
+          error = cause
+        )
+      }
+    }
+  }
+}

package/android/src/main/java/io/hyperswitch/paymentsession/ExitHeadlessCallBackManager.kt

@@ -0,0 +1,47 @@
+package io.hyperswitch.paymentsession
+
+import io.hyperswitch.paymentsheet.PaymentResult
+
+import org.json.JSONObject
+import java.util.concurrent.ConcurrentHashMap
+
+typealias ExitCallback = (PaymentResult) -> Unit
+
+object ExitHeadlessCallBackManager {
+    private val callbacks = ConcurrentHashMap<Int, ExitCallback>()
+
+    fun tryRegisterCallback(rootTag: Int, callback: ExitCallback): Boolean {
+        return if (rootTag == -1) {
+            callbacks[-1] = callback
+            true
+        } else {
+            callbacks.putIfAbsent(rootTag, callback) == null
+        }
+    }
+
+    fun executeCallback(rootTag: Int, data: String): Boolean {
+        val cb = callbacks.remove(rootTag) ?: callbacks.remove(-1)
+
+        val result = parseResult(data)
+        cb?.invoke(result)
+        return true
+    }
+
+    fun clearCallback(rootTag: Int) {
+        callbacks.remove(rootTag)
+    }
+
+    private fun parseResult(data: String): PaymentResult {
+        val message = JSONObject(data)
+        return when (val status = message.getString("status")) {
+            "cancelled" -> PaymentResult.Canceled(status)
+            "failed", "requires_payment_method" -> {
+                val throwable = Throwable(message.getString("message"))
+                throwable.initCause(Throwable(message.getString("code")))
+                PaymentResult.Failed(throwable)
+            }
+
+            else -> PaymentResult.Completed(status ?: "default")
+        }
+    }
+}

package/android/src/main/java/io/hyperswitch/paymentsession/GetPaymentSessionCallBackManager.kt

@@ -0,0 +1,23 @@
+package io.hyperswitch.paymentsession
+
+import java.util.concurrent.atomic.AtomicReference
+
+typealias SessionCallback = (PaymentSessionHandler) -> Unit
+
+object GetPaymentSessionCallBackManager {
+    private val callbackRef = AtomicReference<SessionCallback?>(null)
+    private val sdkAuthorizationRef = AtomicReference<String?>(null)
+    fun setCallback(sdkAuthorization: String?, newCallback: SessionCallback?) {
+        callbackRef.set(newCallback)
+        sdkAuthorizationRef.set(sdkAuthorization)
+    }
+
+    fun getCallback(): SessionCallback? = callbackRef.get()
+
+    fun getSdkAuthorization(): String = sdkAuthorizationRef.get() ?: ""
+
+    fun executeCallback(data: PaymentSessionHandler) {
+        callbackRef.getAndSet(null)?.invoke(data)
+            ?: println("No callback set")
+    }
+}

package/android/src/main/java/io/hyperswitch/paymentsession/PaymentMethod.kt

@@ -0,0 +1,167 @@
+package io.hyperswitch.paymentsession
+
+/**
+ * Sealed class representing different payment method types
+ */
+sealed class PaymentMethodType {
+    data object WALLET : PaymentMethodType()
+    data object CARD : PaymentMethodType()
+    data object CARD_REDIRECT : PaymentMethodType()
+    data object PAY_LATER : PaymentMethodType()
+    data object BANK_REDIRECT : PaymentMethodType()
+    data object OPEN_BANKING : PaymentMethodType()
+    data object BANK_DEBIT : PaymentMethodType()
+    data object BANK_TRANSFER : PaymentMethodType()
+    data object CRYPTO : PaymentMethodType()
+    data object REWARD : PaymentMethodType()
+    data object GIFT_CARD : PaymentMethodType()
+    data class OTHERS(val value: String) : PaymentMethodType()
+
+    companion object {
+        /**
+         * Converts a string value to the corresponding PaymentMethodType
+         * @param value The string representation of the payment method
+         * @return The corresponding PaymentMethodType, returns OTHERS(value) for unrecognized types
+         */
+        fun fromString(value: String): PaymentMethodType {
+            return when (value.lowercase()) {
+                "wallet" -> WALLET
+                "card" -> CARD
+                "card_redirect" -> CARD_REDIRECT
+                "pay_later" -> PAY_LATER
+                "bank_redirect" -> BANK_REDIRECT
+                "open_banking" -> OPEN_BANKING
+                "bank_debit" -> BANK_DEBIT
+                "bank_transfer" -> BANK_TRANSFER
+                "crypto" -> CRYPTO
+                "reward" -> REWARD
+                "gift_card" -> GIFT_CARD
+                else -> OTHERS(value)
+            }
+        }
+    }
+
+    /**
+     * Converts the PaymentMethodType to its string representation
+     * @return The string representation of the payment method type
+     */
+    fun toStringValue(): String {
+        return when (this) {
+            is WALLET -> "wallet"
+            is CARD -> "card"
+            is CARD_REDIRECT -> "card_redirect"
+            is PAY_LATER -> "pay_later"
+            is BANK_REDIRECT -> "bank_redirect"
+            is OPEN_BANKING -> "open_banking"
+            is BANK_DEBIT -> "bank_debit"
+            is BANK_TRANSFER -> "bank_transfer"
+            is CRYPTO -> "crypto"
+            is REWARD -> "reward"
+            is GIFT_CARD -> "gift_card"
+            is OTHERS -> this.value
+        }
+    }
+}
+
+/**
+ * Represents card payment method details
+ */
+data class Card(
+    val scheme: String,
+    val issuerCountry: String,
+    val last4Digits: String,
+    val expiryMonth: String,
+    val expiryYear: String,
+    val cardToken: String?,
+    val cardHolderName: String,
+    val cardFingerprint: String?,
+    val nickName: String,
+    val cardNetwork: String,
+    val cardIsin: String,
+    val cardIssuer: String,
+    val cardType: String,
+    val savedToLocker: Boolean,
+) {
+    fun toMap(): HashMap<String, Any?> {
+        return HashMap<String, Any?>().apply {
+            this["scheme"] = scheme
+            this["issuer_country"] = issuerCountry
+            this["last4_digits"] = last4Digits
+            this["expiry_month"] = expiryMonth
+            this["expiry_year"] = expiryYear
+            this["card_token"] = cardToken
+            this["card_holder_name"] = cardHolderName
+            this["card_fingerprint"] = cardFingerprint
+            this["nick_name"] = nickName
+            this["card_network"] = cardNetwork
+            this["card_isin"] = cardIsin
+            this["card_issuer"] = cardIssuer
+            this["card_type"] = cardType
+            this["saved_to_locker"] = savedToLocker
+        }
+    }
+}
+
+/**
+ * Represents a valid payment method with all details
+ */
+data class PaymentMethod(
+    val paymentToken: String,
+    val paymentMethodId: String,
+    val customerId: String,
+    val paymentMethod: PaymentMethodType,
+    val paymentMethodType: String,
+    val paymentMethodIssuer: String,
+    val paymentMethodIssuerCode: String?,
+    val recurringEnabled: Boolean,
+    val installmentPaymentEnabled: Boolean,
+    val paymentExperience: List<String>,
+    val card: Card?,
+    val metadata: String?,
+    val created: String,
+    val bank: String?,
+    val surchargeDetails: String?,
+    val requiresCvv: Boolean,
+    val lastUsedAt: String,
+    val defaultPaymentMethodSet: Boolean,
+    val billing: String?,
+) {
+    fun toMap(): HashMap<String, Any?> {
+        return HashMap<String, Any?>().apply {
+            this["payment_token"] = paymentToken
+            this["payment_method_id"] = paymentMethodId
+            this["customer_id"] = customerId
+            this["payment_method"] = paymentMethod.toStringValue()
+            this["payment_method_type"] = paymentMethodType
+            this["payment_method_issuer"] = paymentMethodIssuer
+            this["payment_method_issuer_code"] = paymentMethodIssuerCode
+            this["recurring_enabled"] = recurringEnabled
+            this["installment_payment_enabled"] = installmentPaymentEnabled
+            this["payment_experience"] = paymentExperience
+            this["card"] = card?.toMap()
+            this["metadata"] = metadata
+            this["created"] = created
+            this["bank"] = bank
+            this["surcharge_details"] = surchargeDetails
+            this["requires_cvv"] = requiresCvv
+            this["last_used_at"] = lastUsedAt
+            this["default_payment_method_set"] = defaultPaymentMethodSet
+            this["billing"] = billing
+        }
+    }
+}
+
+/**
+ * Represents an error state in payment method retrieval
+ */
+data class PMError(
+    val code: String,
+    override val message: String,
+) : Throwable(message) {
+    fun toMap(): HashMap<String, Any> {
+        return HashMap<String, Any>().apply {
+            this["code"] = code
+            this["message"] = message
+        }
+    }
+}

package/android/src/main/java/io/hyperswitch/paymentsession/PaymentSessionHandler.kt

@@ -0,0 +1,68 @@
+package io.hyperswitch.paymentsession
+
+import android.view.View
+import io.hyperswitch.paymentsheet.PaymentResult
+
+interface PaymentSessionHandler {
+    // -------------------------------------------------------------------------
+    // Kotlin-only API — DO NOT call from Java.
+    // -------------------------------------------------------------------------
+    fun getCustomerDefaultSavedPaymentMethodData(): Result<PaymentMethod>
+    fun getCustomerLastUsedPaymentMethodData(): Result<PaymentMethod>
+    fun getCustomerSavedPaymentMethodData(): Result<List<PaymentMethod>>
+
+    // -------------------------------------------------------------------------
+    // Java-friendly callback variants.
+    // -------------------------------------------------------------------------
+    fun getCustomerDefaultSavedPaymentMethodData(
+        onSuccess: (PaymentMethod) -> Unit,
+        onFailure: (Throwable) -> Unit
+    ) {
+        getCustomerDefaultSavedPaymentMethodData()
+            .onSuccess(onSuccess)
+            .onFailure(onFailure)
+    }
+
+    fun getCustomerLastUsedPaymentMethodData(
+        onSuccess: (PaymentMethod) -> Unit,
+        onFailure: (Throwable) -> Unit
+    ) {
+        getCustomerLastUsedPaymentMethodData()
+            .onSuccess(onSuccess)
+            .onFailure(onFailure)
+    }
+
+    fun getCustomerSavedPaymentMethodData(
+        onSuccess: (List<PaymentMethod>) -> Unit,
+        onFailure: (Throwable) -> Unit
+    ) {
+        getCustomerSavedPaymentMethodData()
+            .onSuccess(onSuccess)
+            .onFailure(onFailure)
+    }
+
+    fun confirmWithCustomerDefaultPaymentMethod(
+        cvc: String? = null, resultHandler: (PaymentResult) -> Unit
+    )
+
+    fun confirmWithCustomerLastUsedPaymentMethod(
+        cvc: String? = null, resultHandler: (PaymentResult) -> Unit
+    )
+    fun updateSdkAuthorization(sdkAuthorization : String)
+
+    fun confirmWithCustomerPaymentToken(
+        paymentToken: String, cvc: String? = null, resultHandler: (PaymentResult) -> Unit
+    )
+
+    // -------------------------------------------------------------------------
+    // Kotlin-only — hidden Continuation<T> parameter; not callable from Java.
+    // -------------------------------------------------------------------------
+    suspend fun confirmWithCustomerLastUsedPaymentMethod(cvcWidget: View): PaymentResult
+    suspend fun confirmWithCustomerDefaultPaymentMethod(cvcWidget: View): PaymentResult
+
+    // -------------------------------------------------------------------------
+    // Java-friendly callback variants — no Continuation, no name mangling.
+    // -------------------------------------------------------------------------
+    fun confirmWithCustomerLastUsedPaymentMethod(cvcWidget: View, resultHandler: (PaymentResult) -> Unit)
+    fun confirmWithCustomerDefaultPaymentMethod(cvcWidget: View, resultHandler: (PaymentResult) -> Unit)
+}

package/android/src/main/java/io/hyperswitch/paymentsession/PaymentSessionHandlerImpl.kt

@@ -0,0 +1,179 @@
+package io.hyperswitch.paymentsession
+
+import android.view.View
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import io.hyperswitch.paymentsheet.PaymentResult
+import io.hyperswitch.utils.ConversionUtils
+import io.hyperswitch.view.PaymentWidgetView
+//import io.hyperswitch.view.CVCWidget
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+internal class PaymentSessionHandlerImpl(
+    private var sdkAuthorization: String,
+    private val defaultMethodData: ReadableMap,
+    private val lastUsedMethodData: ReadableMap,
+    private val allMethodsData: ReadableArray,
+    private val jsCallback: Callback,
+) : PaymentSessionHandler {
+
+    override fun getCustomerDefaultSavedPaymentMethodData(): Result<PaymentMethod> =
+        parsePaymentMethod(defaultMethodData)
+
+    override fun getCustomerLastUsedPaymentMethodData(): Result<PaymentMethod> =
+        parsePaymentMethod(lastUsedMethodData)
+
+    override fun getCustomerSavedPaymentMethodData(): Result<List<PaymentMethod>> {
+        val list = mutableListOf<PaymentMethod>()
+        for (i in 0 until allMethodsData.size()) {
+            allMethodsData.getMap(i)?.let { map ->
+                parsePaymentMethod(map).onSuccess { list.add(it) }
+            }
+        }
+        return Result.success(list)
+    }
+
+    override fun confirmWithCustomerDefaultPaymentMethod(
+        cvc: String?, resultHandler: (PaymentResult) -> Unit
+    ) {
+        defaultMethodData.getString("payment_token")
+            ?.let { confirmWithCustomerPaymentToken(it, cvc, resultHandler) }
+    }
+
+    override fun confirmWithCustomerLastUsedPaymentMethod(
+        cvc: String?, resultHandler: (PaymentResult) -> Unit
+    ) {
+        lastUsedMethodData.getString("payment_token")
+            ?.let { confirmWithCustomerPaymentToken(it, cvc, resultHandler) }
+    }
+
+    override fun updateSdkAuthorization(sdkAuthorization: String){
+        this.sdkAuthorization = sdkAuthorization
+    }
+
+    override fun confirmWithCustomerPaymentToken(
+        paymentToken: String, cvc: String?, resultHandler: (PaymentResult) -> Unit
+    ) {
+        try {
+            val registered = ExitHeadlessCallBackManager.tryRegisterCallback(-1, resultHandler)
+            if (!registered) {
+                resultHandler(PaymentResult.Failed(
+                    Throwable("Payment confirmation already in progress for this handler").apply {
+                        initCause(Throwable("ALREADY_IN_PROGRESS"))
+                    }
+                ))
+                return
+            }
+            jsCallback.invoke(Arguments.createMap().apply {
+                putString("paymentToken", paymentToken)
+                putString("cvc", cvc)
+            })
+        } catch (ex: Exception) {
+            ExitHeadlessCallBackManager.clearCallback(-1)
+            resultHandler(PaymentResult.Failed(Throwable("Not Initialised").apply {
+                initCause(Throwable("Not Initialised"))
+            }))
+        }
+    }
+
+    // ── CVCWidget suspend overloads ───────────────────────────────────────────
+
+    override suspend fun confirmWithCustomerLastUsedPaymentMethod(cvcWidget: View): PaymentResult {
+        val method = getCustomerLastUsedPaymentMethodData()
+            .getOrElse { return PaymentResult.Failed(it) }
+        (cvcWidget as? PaymentWidgetView)?.let {
+            it.setSdkAuthorization(sdkAuthorization)
+//            return it.confirmCVCWidget(sdkAuthorization, method.paymentToken, method.billing)
+        }
+        return PaymentResult.Failed(Throwable("View can't be cast as CVCWidget"))
+    }
+
+    override suspend fun confirmWithCustomerDefaultPaymentMethod(cvcWidget: View): PaymentResult {
+        val method = getCustomerDefaultSavedPaymentMethodData()
+            .getOrElse { return PaymentResult.Failed(it) }
+        (cvcWidget as? PaymentWidgetView)?.let {
+            it.setSdkAuthorization(sdkAuthorization)
+//            return it.confirmCVCWidget(sdkAuthorization, method.paymentToken, method.billing)
+        }
+        return PaymentResult.Failed(Throwable("View can't be cast as CVCWidget"))
+    }
+
+    // ── CVCWidget callback overloads (Java-friendly, no Continuation needed) ─
+
+    override fun confirmWithCustomerLastUsedPaymentMethod(
+        cvcWidget: View, resultHandler: (PaymentResult) -> Unit
+    ) {
+        CoroutineScope(Dispatchers.Main).launch {
+            resultHandler(confirmWithCustomerLastUsedPaymentMethod(cvcWidget))
+        }
+    }
+
+    override fun confirmWithCustomerDefaultPaymentMethod(
+        cvcWidget: View, resultHandler: (PaymentResult) -> Unit
+    ) {
+        CoroutineScope(Dispatchers.Main).launch {
+            resultHandler(confirmWithCustomerDefaultPaymentMethod(cvcWidget))
+        }
+    }
+
+    // ── Parsing ──────────────────────────────────────────────────────────────
+
+    private fun parsePaymentMethod(map: ReadableMap): Result<PaymentMethod> {
+        val paymentMethodStr = map.getString("payment_method_str")
+            ?: return Result.failure(PMError(
+                code = map.getString("code") ?: "",
+                message = map.getString("message") ?: ""
+            ))
+
+        val cardMap = map.getMap("card")
+        val card = cardMap?.let {
+            Card(
+                scheme = it.getString("scheme") ?: "",
+                issuerCountry = it.getString("issuer_country") ?: "",
+                last4Digits = it.getString("last4_digits") ?: "",
+                expiryMonth = it.getString("expiry_month") ?: "",
+                expiryYear = it.getString("expiry_year") ?: "",
+                cardToken = it.getString("card_token"),
+                cardHolderName = it.getString("card_holder_name") ?: "",
+                cardFingerprint = it.getString("card_fingerprint"),
+                nickName = it.getString("nick_name") ?: "",
+                cardNetwork = it.getString("card_network") ?: "",
+                cardIsin = it.getString("card_isin") ?: "",
+                cardIssuer = it.getString("card_issuer") ?: "",
+                cardType = it.getString("card_type") ?: "",
+                savedToLocker = it.getBoolean("saved_to_locker"),
+            )
+        }
+
+        val paymentExperience = buildList {
+            val arr = map.getArray("payment_experience") ?: return@buildList
+            for (i in 0 until arr.size()) arr.getString(i)?.let { add(it) }
+        }
+
+        return Result.success(PaymentMethod(
+            paymentToken = map.getString("payment_token") ?: "",
+            paymentMethodId = map.getString("payment_method_id") ?: "",
+            customerId = map.getString("customer_id") ?: "",
+            paymentMethod = PaymentMethodType.fromString(paymentMethodStr),
+            paymentMethodType = map.getString("payment_method_type") ?: "",
+            paymentMethodIssuer = map.getString("payment_method_issuer") ?: "",
+            paymentMethodIssuerCode = map.getString("payment_method_issuer_code"),
+            recurringEnabled = map.getBoolean("recurring_enabled"),
+            installmentPaymentEnabled = map.getBoolean("installment_payment_enabled"),
+            paymentExperience = paymentExperience,
+            card = card,
+            metadata = map.getString("metadata"),
+            created = map.getString("created") ?: "",
+            bank = map.getString("bank"),
+            surchargeDetails = map.getString("surcharge_details"),
+            requiresCvv = map.getBoolean("requires_cvv"),
+            lastUsedAt = map.getString("last_used_at") ?: "",
+            defaultPaymentMethodSet = map.getBoolean("default_payment_method_set"),
+            billing = map.getMap("billing")?.let { ConversionUtils.convertMapToJson(it).toString() },
+        ))
+    }
+}