@primer-io/react-native 2.45.0 → 3.0.0-beta.0

package/android/build.gradle

@@ -133,7 +133,9 @@ dependencies {
   implementation 'com.facebook.react:react-native:+'
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
   implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.3"
-  implementation 'io.primer:android:2.51.0'
+  implementation 'io.primer:android:3.0.0-beta.4'
+  implementation 'io.primer:components-analytics:3.0.0-beta.4'
+  implementation 'io.primer:components-bridge:3.0.0-beta.4'
   testImplementation 'io.mockk:mockk:1.14.2'
   testImplementation 'org.junit.jupiter:junit-jupiter-api:5.10.2'
   testImplementation 'org.junit.jupiter:junit-jupiter-api:5.10.2'

package/android/src/main/java/com/primerioreactnative/DefaultNativePrimerModule.kt

@@ -13,9 +13,11 @@ import com.primerioreactnative.datamodels.PrimerSettingsRN
 import com.primerioreactnative.datamodels.toPrimerSettings
 import com.primerioreactnative.utils.PrimerImplementedRNCallbacks
 import com.primerioreactnative.utils.errorTo
+import com.primerioreactnative.utils.toAnalyticsEvent
 import com.primerioreactnative.utils.toWritableMap
 import io.primer.android.Primer
 import io.primer.android.PrimerSessionIntent
+import io.primer.android.components.analytics.ComponentsAnalyticsLoggingBridge
 import io.primer.android.data.settings.PrimerSettings
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
@@ -27,6 +29,7 @@ internal open class DefaultNativePrimerModule(
     private val json: Json,
     private val eventSender: (String, WritableMap) -> Unit,
 ) {
+    private var analyticsLoggingBridge: ComponentsAnalyticsLoggingBridge? = null
     private val mListener = PrimerRNEventListener()
 
     init {
@@ -238,6 +241,67 @@ internal open class DefaultNativePrimerModule(
         }
     }
 
+    // region analytics bridge
+    fun trackAnalyticsEvent(
+        eventName: String,
+        metadata: String?,
+        promise: Promise,
+    ) {
+        try {
+            val metadataMap: Map<String, String>? = metadata?.let {
+                json.decodeFromString<Map<String, String>>(it)
+            }
+            val analyticsEvent = toAnalyticsEvent(eventName, metadataMap) ?: return promise.resolve(null)
+            analyticsLoggingBridge?.sendEvent(analyticsEvent)
+            promise.resolve(null)
+        } catch (expected: Exception) {
+            promise.resolve(null)
+        }
+    }
+
+    fun sendLog(
+        message: String,
+        event: String,
+        initDurationMs: Double?,
+        promise: Promise,
+    ) {
+        try {
+            analyticsLoggingBridge?.sendInfoLog(message, event, initDurationMs?.toLong())
+            promise.resolve(null)
+        } catch (expected: Exception) {
+            promise.resolve(null)
+        }
+    }
+
+    fun sendErrorLog(
+        message: String,
+        event: String?,
+        errorMessage: String?,
+        stack: String?,
+        promise: Promise,
+    ) {
+        try {
+            analyticsLoggingBridge?.sendErrorLog(message, event, errorMessage, stack)
+            promise.resolve(null)
+        } catch (expected: Exception) {
+            promise.resolve(null)
+        }
+    }
+
+    @Suppress("UnusedParameter")
+    fun setupAnalyticsLoggingBridge(
+        clientToken: String,
+        promise: Promise,
+    ) {
+        try {
+            analyticsLoggingBridge = ComponentsAnalyticsLoggingBridge.create()
+            promise.resolve(null)
+        } catch (expected: Exception) {
+            promise.reject("setup_failed", expected.message, expected)
+        }
+    }
+    // endregion
+
     private fun startSdk(settings: PrimerSettings) {
         Primer.instance.configure(settings, mListener)
     }

package/android/src/main/java/com/primerioreactnative/PrimerRNHeadlessUniversalCheckoutListener.kt

@@ -25,6 +25,7 @@ import io.primer.android.completion.PrimerHeadlessUniversalCheckoutResumeDecisio
 import io.primer.android.completion.PrimerPaymentCreationDecisionHandler
 import io.primer.android.components.PrimerHeadlessUniversalCheckoutListener
 import io.primer.android.components.PrimerHeadlessUniversalCheckoutUiListener
+import io.primer.android.components.bridge.clientsession.ComponentsClientSessionBridge
 import io.primer.android.components.domain.core.models.PrimerHeadlessUniversalCheckoutPaymentMethod
 import io.primer.android.domain.PrimerCheckoutData
 import io.primer.android.domain.action.models.PrimerClientSession
@@ -76,6 +77,30 @@ class PrimerRNHeadlessUniversalCheckoutListener(
         successCallback?.resolve(
             availablePaymentMethods.toWritableMap(),
         )
+
+        // The native SDK only fires `onClientSessionUpdated` on subsequent updates, never on
+        // initial load. Read the current session via `ComponentsClientSessionBridge` and
+        // synthesize the update event so JS receives the initial session at startup.
+        if (implementedRNCallbacks?.isOnClientSessionUpdateImplemented == true) {
+            val bridge = ComponentsClientSessionBridge.create()
+            bridge.getClientSession()?.let { initialClientSession ->
+                sendEvent?.invoke(
+                    PrimerHeadlessUniversalCheckoutEvent.ON_CLIENT_SESSION_UPDATE.eventName,
+                    JSONObject().apply {
+                        put(
+                            CLIENT_SESSION_PAYLOAD_KEY,
+                            JSONObject(
+                                Json.encodeToString(
+                                    initialClientSession.toPrimerClientSessionRN(
+                                        bridge.getCheckoutModules(),
+                                    ),
+                                ),
+                            ),
+                        )
+                    },
+                )
+            }
+        }
     }
 
     override fun onPreparationStarted(paymentMethodType: String) {
@@ -171,12 +196,20 @@ class PrimerRNHeadlessUniversalCheckoutListener(
 
     override fun onClientSessionUpdated(clientSession: PrimerClientSession) {
         if (implementedRNCallbacks?.isOnClientSessionUpdateImplemented == true) {
+            // The SDK callback delivers `PrimerClientSession` without `checkoutModules`.
+            // Read those separately from the bridge so JS gets the same shape it gets
+            // from the synthesized initial event.
+            val checkoutModules = ComponentsClientSessionBridge.create().getCheckoutModules()
             sendEvent?.invoke(
                 PrimerHeadlessUniversalCheckoutEvent.ON_CLIENT_SESSION_UPDATE.eventName,
                 JSONObject().apply {
                     put(
-                        "clientSession",
-                        JSONObject(Json.encodeToString(clientSession.toPrimerClientSessionRN())),
+                        CLIENT_SESSION_PAYLOAD_KEY,
+                        JSONObject(
+                            Json.encodeToString(
+                                clientSession.toPrimerClientSessionRN(checkoutModules),
+                            ),
+                        ),
                     )
                 },
             )
@@ -373,6 +406,7 @@ class PrimerRNHeadlessUniversalCheckoutListener(
     }
 
     private companion object {
+        const val CLIENT_SESSION_PAYLOAD_KEY = "clientSession"
         val json = Json { encodeDefaults = true }
     }
 }

package/android/src/main/java/com/primerioreactnative/PrimerSdkPackage.kt

@@ -47,6 +47,7 @@ class PrimerSdkPackage : BaseReactPackage() {
     // New Architecture modules
     private val newArchModules: Array<Class<out NativeModule>> = arrayOf(
         NativePrimerModule::class.java,
+        PrimerViewUtilsModule::class.java,
     )
 
     override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? =
@@ -85,6 +86,7 @@ class PrimerSdkPackage : BaseReactPackage() {
             )
 
             PrimerGooglePayButtonConstantsModule.NAME -> PrimerGooglePayButtonConstantsModule(reactContext)
+            PrimerViewUtilsModule.NAME -> PrimerViewUtilsModule(reactContext)
             else -> null
         }
 

package/android/src/main/java/com/primerioreactnative/PrimerViewUtilsImpl.kt

@@ -0,0 +1,33 @@
+package com.primerioreactnative
+
+import android.content.res.Resources
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+
+internal class PrimerViewUtilsImpl(
+    private val reactContext: ReactApplicationContext,
+) {
+    fun getBottomSafeAreaInset(promise: Promise) {
+        val activity = reactContext.currentActivity
+        if (activity == null) {
+            promise.resolve(0.0)
+            return
+        }
+        activity.runOnUiThread {
+            try {
+                val insets = ViewCompat.getRootWindowInsets(activity.window.decorView)
+                if (insets == null) {
+                    promise.resolve(0.0)
+                    return@runOnUiThread
+                }
+                val bottomPx = insets.getInsets(WindowInsetsCompat.Type.systemBars()).bottom
+                val density = Resources.getSystem().displayMetrics.density
+                promise.resolve((bottomPx / density).toDouble())
+            } catch (_: Exception) {
+                promise.resolve(0.0)
+            }
+        }
+    }
+}

package/android/src/main/java/com/primerioreactnative/components/datamodels/manager/raw/billingAddress/PrimerRNAddress.kt

@@ -0,0 +1,29 @@
+package com.primerioreactnative.components.datamodels.manager.raw.billingAddress
+
+import io.primer.android.configuration.data.model.CountryCode
+import io.primer.android.domain.action.models.PrimerAddress
+import kotlinx.serialization.Serializable
+
+@Serializable
+internal data class PrimerRNAddress(
+    val firstName: String? = null,
+    val lastName: String? = null,
+    val addressLine1: String? = null,
+    val addressLine2: String? = null,
+    val postalCode: String? = null,
+    val city: String? = null,
+    val state: String? = null,
+    val countryCode: String? = null,
+) {
+    fun toPrimerAddress(): PrimerAddress =
+        PrimerAddress(
+            firstName = firstName,
+            lastName = lastName,
+            addressLine1 = addressLine1,
+            addressLine2 = addressLine2,
+            postalCode = postalCode,
+            city = city,
+            state = state,
+            countryCode = countryCode?.let { CountryCode.valueOf(it) },
+        )
+}

package/android/src/main/java/com/primerioreactnative/components/datamodels/manager/raw/card/PrimerRNCardData.kt

@@ -1,6 +1,7 @@
 package com.primerioreactnative.components.datamodels.manager.raw.card
 
 import io.primer.android.components.domain.core.models.card.PrimerCardData
+import io.primer.android.configuration.data.model.CardNetwork
 import kotlinx.serialization.Serializable
 
 @Serializable
@@ -9,6 +10,7 @@ internal data class PrimerRNCardData(
     val expiryDate: String? = null,
     val cvv: String? = null,
     val cardholderName: String? = null,
+    val cardNetwork: String? = null,
 ) {
     fun toPrimerCardData() =
         PrimerCardData(
@@ -16,5 +18,6 @@ internal data class PrimerRNCardData(
             expiryDate.orEmpty(),
             cvv.orEmpty(),
             cardholderName,
+            cardNetwork = cardNetwork?.let { id -> CardNetwork.Type.values().firstOrNull { it.name == id } },
         )
 }

package/android/src/main/java/com/primerioreactnative/components/manager/asset/PrimerRNHeadlessUniversalCheckoutAssetManager.kt

@@ -1,6 +1,7 @@
 package com.primerioreactnative.components.manager.asset
 
 import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
@@ -21,6 +22,7 @@ import com.primerioreactnative.datamodels.ErrorTypeRN
 import com.primerioreactnative.utils.errorTo
 import com.primerioreactnative.utils.toWritableMap
 import io.primer.android.components.SdkUninitializedException
+import io.primer.android.components.bridge.clientsession.ComponentsClientSessionBridge
 import io.primer.android.components.ui.assets.PrimerHeadlessUniversalCheckoutAssetsManager
 import io.primer.android.components.ui.assets.PrimerPaymentMethodAsset
 import io.primer.android.components.ui.assets.PrimerPaymentMethodNativeView
@@ -37,6 +39,34 @@ internal class PrimerRNHeadlessUniversalCheckoutAssetManager(
 ) : ReactContextBaseJavaModule(reactContext) {
     override fun getName() = "RNTPrimerHeadlessUniversalCheckoutAssetsManager"
 
+    @ReactMethod
+    fun getCardNetworkTraits(
+        cardNetworkStr: String,
+        promise: Promise,
+    ) {
+        // Android always returns a Descriptor (Type.OTHER fallback for unknown strings).
+        // JS normalises cardNetwork == "OTHER" to DEFAULT_DESCRIPTOR, matching iOS nil semantics.
+        val descriptor = CardNetwork.lookupByCardNetwork(cardNetworkStr)
+        val panLengthsArray =
+            Arguments.createArray().apply {
+                descriptor.lengths.forEach { pushInt(it) }
+            }
+        val gapPatternArray =
+            Arguments.createArray().apply {
+                descriptor.gaps.forEach { pushInt(it) }
+            }
+        val result =
+            Arguments.createMap().apply {
+                putString("cardNetwork", descriptor.type.name)
+                putString("displayName", descriptor.type.displayName)
+                putArray("panLengths", panLengthsArray)
+                putArray("gapPattern", gapPatternArray)
+                putInt("cvvLength", descriptor.cvvLength)
+                putString("cvvLabel", descriptor.cvvLabel)
+            }
+        promise.resolve(result)
+    }
+
     @ReactMethod
     fun getCardNetworkImage(
         cardNetworkStr: String,
@@ -76,6 +106,25 @@ internal class PrimerRNHeadlessUniversalCheckoutAssetManager(
         }
     }
 
+    @ReactMethod
+    fun getOrderedAllowedCardNetworks(promise: Promise) {
+        try {
+            val networks = ComponentsClientSessionBridge.create().getOrderedAllowedCardNetworks()
+            val map = Arguments.createMap()
+            if (networks == null) {
+                map.putNull("networks")
+            } else {
+                val array = Arguments.createArray()
+                networks.forEach { array.pushString(it) }
+                map.putArray("networks", array)
+            }
+            promise.resolve(map)
+        } catch (e: Exception) {
+            val exception = ErrorTypeRN.NativeBridgeFailed errorTo e.message.orEmpty()
+            promise.reject(exception.errorId, exception.description, e)
+        }
+    }
+
     @Suppress("SwallowedException")
     @ReactMethod
     fun getPaymentMethodAsset(

package/android/src/main/java/com/primerioreactnative/components/manager/raw/PrimerRNHeadlessUniversalCheckoutRawManager.kt

@@ -10,6 +10,7 @@ import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.primerioreactnative.Keys
 import com.primerioreactnative.components.datamodels.core.PrimerRawPaymentMethodType
+import com.primerioreactnative.components.datamodels.manager.raw.billingAddress.PrimerRNAddress
 import com.primerioreactnative.components.datamodels.manager.raw.card.PrimerRNCardData
 import com.primerioreactnative.components.datamodels.manager.raw.cardRedirect.PrimerRNBancontactCardData
 import com.primerioreactnative.components.datamodels.manager.raw.phoneNumber.PrimerRNPhoneNumberData
@@ -22,10 +23,16 @@ import com.primerioreactnative.utils.errorTo
 import com.primerioreactnative.utils.toWritableMap
 import io.primer.android.RetailOutletsList
 import io.primer.android.components.SdkUninitializedException
+import io.primer.android.components.bridge.billingaddress.ComponentsBillingAddressBridge
 import io.primer.android.components.domain.exception.UnsupportedPaymentMethodManagerException
 import io.primer.android.components.manager.raw.PrimerHeadlessUniversalCheckoutRawDataManager
 import io.primer.android.components.manager.raw.PrimerHeadlessUniversalCheckoutRawDataManagerInterface
 import io.primer.android.core.ExperimentalPrimerApi
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancelChildren
+import kotlinx.coroutines.launch
 import kotlinx.serialization.decodeFromString
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
@@ -42,6 +49,7 @@ internal class PrimerRNHeadlessUniversalCheckoutRawManager(
     private val listener = PrimerRNHeadlessUniversalCheckoutRawManagerListener()
     private lateinit var rawManager: PrimerHeadlessUniversalCheckoutRawDataManagerInterface
     private var paymentMethodTypeStr: String? = null
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
 
     init {
         listener.sendEvent = { eventName, paramsJson -> sendEvent(eventName, paramsJson) }
@@ -132,9 +140,8 @@ internal class PrimerRNHeadlessUniversalCheckoutRawManager(
                 val rawData =
                     when (PrimerRawPaymentMethodType.valueOf(paymentMethodTypeStr.toString())) {
                         PrimerRawPaymentMethodType.PAYMENT_CARD ->
-                            json.decodeFromString<PrimerRNCardData>(
-                                rawDataStr,
-                            ).toPrimerCardData()
+                            json.decodeFromString<PrimerRNCardData>(rawDataStr)
+                                .toPrimerCardData()
 
                         PrimerRawPaymentMethodType.XENDIT_OVO,
                         PrimerRawPaymentMethodType.ADYEN_MBWAY,
@@ -174,6 +181,54 @@ internal class PrimerRNHeadlessUniversalCheckoutRawManager(
         }
     }
 
+    @ReactMethod
+    @Suppress("ReturnCount")
+    fun setBillingAddress(
+        billingAddressStr: String,
+        promise: Promise,
+    ) {
+        if (::rawManager.isInitialized.not()) {
+            val exception =
+                ErrorTypeRN.NativeBridgeFailed errorTo UNINITIALIZED_ERROR
+            promise.reject(exception.errorId, exception.description)
+            return
+        }
+
+        val rnAddress =
+            try {
+                json.decodeFromString<PrimerRNAddress>(billingAddressStr)
+            } catch (e: Exception) {
+                val exception =
+                    ErrorTypeRN.NativeBridgeFailed errorTo
+                        "Failed to decode billing address $billingAddressStr on Android. " +
+                        "Make sure you're providing a valid billing address object."
+                promise.reject(exception.errorId, exception.description, e)
+                return
+            }
+
+        val address =
+            try {
+                rnAddress.toPrimerAddress()
+            } catch (e: IllegalArgumentException) {
+                val exception = ErrorTypeRN.InvalidRawData errorTo (e.message ?: "Invalid billing address.")
+                promise.reject(exception.errorId, exception.description, e)
+                return
+            }
+
+        scope.launch {
+            try {
+                ComponentsBillingAddressBridge.create().setBillingAddress(address)
+                promise.resolve(null)
+            } catch (e: IllegalArgumentException) {
+                val exception = ErrorTypeRN.InvalidRawData errorTo (e.message ?: "Invalid billing address.")
+                promise.reject(exception.errorId, exception.description, e)
+            } catch (e: Exception) {
+                val exception = ErrorTypeRN.NativeBridgeFailed errorTo e.message.orEmpty()
+                promise.reject(exception.errorId, exception.description, e)
+            }
+        }
+    }
+
     @ReactMethod
     fun cleanUp(promise: Promise) {
         if (::rawManager.isInitialized.not()) {
@@ -182,6 +237,9 @@ internal class PrimerRNHeadlessUniversalCheckoutRawManager(
             promise.reject(exception.errorId, exception.description)
         } else {
             rawManager.cleanup()
+            // `scope` is module-scoped; cancel pending coroutines but keep the scope
+            // alive across configure/cleanup cycles.
+            scope.coroutineContext.cancelChildren()
             promise.resolve(null)
         }
     }

package/android/src/main/java/com/primerioreactnative/components/manager/vault/PrimerRNHeadlessUniversalCheckoutVaultManager.kt

@@ -14,6 +14,7 @@ import com.primerioreactnative.components.datamodels.manager.vault.toPrimerVault
 import com.primerioreactnative.datamodels.ErrorTypeRN
 import com.primerioreactnative.utils.errorTo
 import com.primerioreactnative.utils.toWritableMap
+import io.primer.android.components.bridge.clientsession.ComponentsClientSessionBridge
 import io.primer.android.components.manager.vault.PrimerHeadlessUniversalCheckoutVaultManager
 import io.primer.android.components.manager.vault.PrimerHeadlessUniversalCheckoutVaultManagerInterface
 import kotlinx.coroutines.CoroutineScope
@@ -171,6 +172,11 @@ class PrimerRNHeadlessUniversalCheckoutVaultManager(
         }
     }
 
+    @ReactMethod
+    fun requiresVaultedCardCvv(promise: Promise) {
+        promise.resolve(ComponentsClientSessionBridge.create().getCaptureVaultedCardCvv())
+    }
+
     companion object {
         const val NAME = "RNPrimerHeadlessUniversalCheckoutVaultManager"
     }

package/android/src/main/java/com/primerioreactnative/datamodels/PrimerClientSessionRN.kt

@@ -12,6 +12,13 @@ data class PrimerClientSessionRN(
     val lineItems: List<PrimerLineItemRN>?,
     val orderDetails: PrimerOrderRN?,
     val customer: PrimerCustomerRN?,
+    val checkoutModules: List<PrimerCheckoutModuleRN>? = null,
+)
+
+@Serializable
+data class PrimerCheckoutModuleRN(
+    val type: String,
+    val options: Map<String, Boolean>?,
 )
 
 @Serializable

package/android/src/main/java/com/primerioreactnative/datamodels/PrimerErrorRN.kt

@@ -19,6 +19,7 @@ enum class ErrorTypeRN(val errorId: String) {
     UnsupportedPaymentIntent("unsupported-session-intent"),
     VaultManagerDeleteFailed("vaulted-manager-delete-failed"),
     InvalidVaultedPaymentMethodId("invalid-vaulted-payment-method-id"),
+    InvalidRawData("invalid-raw-data"),
 }
 
 @Serializable

package/android/src/main/java/com/primerioreactnative/extensions/PrimerClientSession.kt

@@ -1,15 +1,19 @@
 package com.primerioreactnative.extensions
 
+import com.primerioreactnative.datamodels.PrimerCheckoutModuleRN
 import com.primerioreactnative.datamodels.PrimerClientSessionRN
+import io.primer.android.components.bridge.clientsession.ComponentsCheckoutModule
 import io.primer.android.domain.action.models.PrimerClientSession
 
-internal fun PrimerClientSession.toPrimerClientSessionRN() =
-    PrimerClientSessionRN(
-        customerId,
-        orderId,
-        currencyCode,
-        totalAmount,
-        lineItems?.map { it.toPrimerLineItemRN() },
-        orderDetails?.toPrimerOrderRN(),
-        customer?.toPrimerCustomerRN(),
-    )
+internal fun PrimerClientSession.toPrimerClientSessionRN(
+    checkoutModules: List<ComponentsCheckoutModule>? = null,
+) = PrimerClientSessionRN(
+    customerId,
+    orderId,
+    currencyCode,
+    totalAmount,
+    lineItems?.map { it.toPrimerLineItemRN() },
+    orderDetails?.toPrimerOrderRN(),
+    customer?.toPrimerCustomerRN(),
+    checkoutModules?.map { PrimerCheckoutModuleRN(it.type, it.options) },
+)

package/android/src/main/java/com/primerioreactnative/utils/AnalyticsEventMapper.kt

@@ -0,0 +1,115 @@
+package com.primerioreactnative.utils
+
+import io.primer.android.components.analytics.data.model.AnalyticsEvent
+
+@Suppress("CyclomaticComplexMethod", "ReturnCount", "LongMethod")
+internal fun toAnalyticsEvent(name: String, metadata: Map<String, String>?): AnalyticsEvent? {
+    return when (name) {
+        "SDK_INIT_START" -> AnalyticsEvent.SdkInitStart
+        "SDK_INIT_END" -> AnalyticsEvent.SdkInitEnd
+        "CHECKOUT_FLOW_STARTED" -> AnalyticsEvent.CheckoutFlowStarted
+        "PAYMENT_FLOW_EXITED" -> AnalyticsEvent.PaymentFlowExited
+        "PAYMENT_REATTEMPTED" -> AnalyticsEvent.PaymentReattempted(metadata?.get("paymentMethod"))
+
+        "PAYMENT_METHOD_SELECTION" -> {
+            val paymentMethod = metadata?.get("paymentMethod") ?: return null
+            AnalyticsEvent.PaymentMethodSelection(paymentMethod)
+        }
+        "PAYMENT_DETAILS_ENTERED" -> {
+            val paymentMethod = metadata?.get("paymentMethod") ?: return null
+            AnalyticsEvent.PaymentDetailsEntered(paymentMethod)
+        }
+        "PAYMENT_SUBMITTED" -> {
+            val paymentMethod = metadata?.get("paymentMethod") ?: return null
+            AnalyticsEvent.PaymentSubmitted(paymentMethod)
+        }
+        "PAYMENT_PROCESSING_STARTED" -> {
+            val paymentMethod = metadata?.get("paymentMethod") ?: return null
+            AnalyticsEvent.PaymentProcessingStarted(paymentMethod)
+        }
+        "PAYMENT_SUCCESS" -> {
+            val paymentMethod = metadata?.get("paymentMethod") ?: return null
+            val paymentId = metadata["paymentId"] ?: return null
+            AnalyticsEvent.PaymentSuccess(paymentMethod, paymentId)
+        }
+        "PAYMENT_FAILURE" -> {
+            val paymentMethod = metadata?.get("paymentMethod") ?: return null
+            val paymentId = metadata["paymentId"]
+            AnalyticsEvent.PaymentFailure(paymentMethod, paymentId)
+        }
+        "PAYMENT_THREEDS" -> {
+            val paymentMethod = metadata?.get("paymentMethod") ?: return null
+            val threedsProvider = metadata["threedsProvider"] ?: return null
+            val threedsResponse = metadata["threedsResponse"]
+            AnalyticsEvent.PaymentThreeDS(paymentMethod, threedsProvider, threedsResponse)
+        }
+        "PAYMENT_REDIRECT_TO_THIRD_PARTY" -> {
+            val paymentMethod = metadata?.get("paymentMethod") ?: return null
+            val redirectDestinationUrl = metadata["redirectDestinationUrl"] ?: return null
+            AnalyticsEvent.PaymentRedirect(paymentMethod, redirectDestinationUrl)
+        }
+
+        "VAULT_LIST_OPENED" ->
+            AnalyticsEvent.VaultListOpened(metadata.vaultString("vaultedMethodId"))
+        "VAULT_OTHER_PAY_METHODS_REQUESTED" ->
+            AnalyticsEvent.VaultOtherPayMethodsRequested(metadata.vaultString("vaultedMethodId"))
+        "VAULT_METHOD_SELECTED" -> {
+            val vaultedMethodId = metadata.vaultString("vaultedMethodId") ?: return null
+            AnalyticsEvent.VaultMethodSelected(vaultedMethodId, metadata.vaultString("previousVaultedMethodId"))
+        }
+        "VAULT_EDIT_MODE_ENTERED" ->
+            AnalyticsEvent.VaultEditModeEntered(metadata?.get("vaultedMethodCount")?.toIntOrNull())
+        "VAULT_EDIT_MODE_EXITED" ->
+            AnalyticsEvent.VaultEditModeExited(metadata?.get("exitedFromConfirmation")?.toBooleanStrictOrNull())
+        "VAULT_DELETION_REQUESTED" -> {
+            val vaultedMethodId = metadata.vaultString("vaultedMethodId") ?: return null
+            AnalyticsEvent.VaultDeletionRequested(vaultedMethodId, metadata?.get("isActive")?.toBooleanStrictOrNull())
+        }
+        "VAULT_DELETION_CANCELLED" -> {
+            val vaultedMethodId = metadata.vaultString("vaultedMethodId") ?: return null
+            AnalyticsEvent.VaultDeletionCancelled(vaultedMethodId)
+        }
+        "VAULT_METHOD_DELETED" -> {
+            val vaultedMethodId = metadata.vaultString("vaultedMethodId") ?: return null
+            AnalyticsEvent.VaultMethodDeleted(
+                vaultedMethodId,
+                metadata?.get("isActive")?.toBooleanStrictOrNull(),
+                metadata.vaultString("promotedVaultedMethodId"),
+            )
+        }
+        "VAULT_METHOD_DELETION_FAILED" -> {
+            val vaultedMethodId = metadata.vaultString("vaultedMethodId") ?: return null
+            AnalyticsEvent.VaultMethodDeletionFailed(
+                vaultedMethodId,
+                metadata.vaultString("errorId"),
+                metadata?.get("isActive")?.toBooleanStrictOrNull(),
+            )
+        }
+        "VAULT_CVV_REQUIRED_RENDERED" -> {
+            val vaultedMethodId = metadata.vaultString("vaultedMethodId") ?: return null
+            AnalyticsEvent.VaultCvvRequiredRendered(
+                vaultedMethodId,
+                metadata.vaultString("network"),
+                metadata?.get("expectedCvvLength")?.toIntOrNull(),
+            )
+        }
+        "VAULT_CVV_SUBMITTED" -> {
+            val vaultedMethodId = metadata.vaultString("vaultedMethodId") ?: return null
+            AnalyticsEvent.VaultCvvSubmitted(vaultedMethodId, metadata.vaultString("network"))
+        }
+        "VAULT_CVV_REQUIRED_DISMISSED" -> {
+            val vaultedMethodId = metadata.vaultString("vaultedMethodId") ?: return null
+            AnalyticsEvent.VaultCvvRequiredDismissed(vaultedMethodId)
+        }
+        "VAULT_CVV_SUBMISSION_FAILED" -> {
+            val vaultedMethodId = metadata.vaultString("vaultedMethodId") ?: return null
+            AnalyticsEvent.VaultCvvSubmissionFailed(vaultedMethodId, metadata.vaultString("errorId"))
+        }
+
+        else -> null
+    }
+}
+
+// RN sends "" as the absent-value sentinel; treat it as null (matches the iOS bridge).
+private fun Map<String, String>?.vaultString(key: String): String? =
+    this?.get(key)?.takeIf { it.isNotEmpty() }