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

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() }

package/android/src/newarch/java/com/primerioreactnative/NativePrimerModule.kt

@@ -110,6 +110,34 @@ class NativePrimerModule(private val reactContext: ReactApplicationContext, priv
     implementation.setImplementedRNCallbacks(implementedRNCallbacksStr = implementedRNCallbacks, promise = promise)
   }
 
+  override fun trackAnalyticsEvent(eventName: String, metadata: String?, promise: Promise) {
+    implementation.trackAnalyticsEvent(eventName = eventName, metadata = metadata, promise = promise)
+  }
+
+  override fun sendLog(message: String, event: String, initDurationMs: Double?, promise: Promise) {
+    implementation.sendLog(message = message, event = event, initDurationMs = initDurationMs, promise = promise)
+  }
+
+  override fun sendErrorLog(
+    message: String,
+    event: String?,
+    errorMessage: String?,
+    stack: String?,
+    promise: Promise
+  ) {
+    implementation.sendErrorLog(
+      message = message,
+      event = event,
+      errorMessage = errorMessage,
+      stack = stack,
+      promise = promise
+    )
+  }
+
+  override fun setupAnalyticsLoggingBridge(clientToken: String, promise: Promise) {
+    implementation.setupAnalyticsLoggingBridge(clientToken = clientToken, promise = promise)
+  }
+
   override fun addListener(eventName: String?) = Unit
 
   override fun removeListeners(count: Double?) = Unit

package/android/src/newarch/java/com/primerioreactnative/PrimerViewUtilsModule.kt

@@ -0,0 +1,24 @@
+package com.primerioreactnative
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+
+@ReactModule(name = PrimerViewUtilsModule.NAME)
+class PrimerViewUtilsModule(reactContext: ReactApplicationContext) :
+    NativePrimerViewUtilsSpec(reactContext) {
+
+    private val implementation by lazy {
+        PrimerViewUtilsImpl(reactContext)
+    }
+
+    override fun getName(): String = NAME
+
+    override fun getBottomSafeAreaInset(promise: Promise) {
+        implementation.getBottomSafeAreaInset(promise)
+    }
+
+    companion object {
+        const val NAME = "PrimerViewUtils"
+    }
+}

package/android/src/oldarch/java/com/primerioreactnative/NativePrimerModule.kt

@@ -133,6 +133,38 @@ class NativePrimerModule(private val reactContext: ReactApplicationContext, priv
     implementation.setImplementedRNCallbacks(implementedRNCallbacksStr = implementedRNCallbacks, promise = promise)
   }
 
+  @ReactMethod
+  fun trackAnalyticsEvent(eventName: String, metadata: String?, promise: Promise) {
+    implementation.trackAnalyticsEvent(eventName = eventName, metadata = metadata, promise = promise)
+  }
+
+  @ReactMethod
+  fun sendLog(message: String, event: String, initDurationMs: Double?, promise: Promise) {
+    implementation.sendLog(message = message, event = event, initDurationMs = initDurationMs, promise = promise)
+  }
+
+  @ReactMethod
+  fun sendErrorLog(
+    message: String,
+    event: String?,
+    errorMessage: String?,
+    stack: String?,
+    promise: Promise
+  ) {
+    implementation.sendErrorLog(
+      message = message,
+      event = event,
+      errorMessage = errorMessage,
+      stack = stack,
+      promise = promise
+    )
+  }
+
+  @ReactMethod
+  fun setupAnalyticsLoggingBridge(clientToken: String, promise: Promise) {
+    implementation.setupAnalyticsLoggingBridge(clientToken = clientToken, promise = promise)
+  }
+
   @ReactMethod
   fun addListener(eventName: String?) = Unit
 

package/android/src/oldarch/java/com/primerioreactnative/PrimerViewUtilsModule.kt

@@ -0,0 +1,27 @@
+package com.primerioreactnative
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.module.annotations.ReactModule
+
+@ReactModule(name = PrimerViewUtilsModule.NAME)
+class PrimerViewUtilsModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    private val implementation by lazy {
+        PrimerViewUtilsImpl(reactContext)
+    }
+
+    override fun getName(): String = NAME
+
+    @ReactMethod
+    fun getBottomSafeAreaInset(promise: Promise) {
+        implementation.getBottomSafeAreaInset(promise)
+    }
+
+    companion object {
+        const val NAME = "PrimerViewUtils"
+    }
+}

package/android/src/test/java/com/primerioreactnative/utils/AnalyticsEventMapperTest.kt

@@ -0,0 +1,351 @@
+package com.primerioreactnative.utils
+
+import io.primer.android.components.analytics.data.model.AnalyticsEvent
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertNull
+import org.junit.jupiter.api.Nested
+import org.junit.jupiter.api.Test
+
+internal class AnalyticsEventMapperTest {
+
+    @Nested
+    inner class `data object events` {
+        @Test
+        fun `toAnalyticsEvent returns SdkInitStart`() {
+            assertEquals(AnalyticsEvent.SdkInitStart, toAnalyticsEvent("SDK_INIT_START", null))
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns SdkInitEnd`() {
+            assertEquals(AnalyticsEvent.SdkInitEnd, toAnalyticsEvent("SDK_INIT_END", null))
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns CheckoutFlowStarted`() {
+            assertEquals(AnalyticsEvent.CheckoutFlowStarted, toAnalyticsEvent("CHECKOUT_FLOW_STARTED", null))
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns PaymentFlowExited`() {
+            assertEquals(AnalyticsEvent.PaymentFlowExited, toAnalyticsEvent("PAYMENT_FLOW_EXITED", null))
+        }
+
+        @Test
+        fun `toAnalyticsEvent ignores metadata for data object events`() {
+            val metadata = mapOf("paymentMethod" to "PAYMENT_CARD")
+            assertEquals(AnalyticsEvent.SdkInitStart, toAnalyticsEvent("SDK_INIT_START", metadata))
+        }
+    }
+
+    @Nested
+    inner class `PaymentReattempted event` {
+        @Test
+        fun `toAnalyticsEvent returns PaymentReattempted with paymentMethod`() {
+            val metadata = mapOf("paymentMethod" to "PAYMENT_CARD")
+            assertEquals(
+                AnalyticsEvent.PaymentReattempted("PAYMENT_CARD"),
+                toAnalyticsEvent("PAYMENT_REATTEMPTED", metadata),
+            )
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns PaymentReattempted with null paymentMethod when absent`() {
+            assertEquals(AnalyticsEvent.PaymentReattempted(null), toAnalyticsEvent("PAYMENT_REATTEMPTED", null))
+        }
+    }
+
+    @Nested
+    inner class `PaymentMethodSelection event` {
+        @Test
+        fun `toAnalyticsEvent returns PaymentMethodSelection with paymentMethod`() {
+            val metadata = mapOf("paymentMethod" to "PAYMENT_CARD")
+            assertEquals(
+                AnalyticsEvent.PaymentMethodSelection("PAYMENT_CARD"),
+                toAnalyticsEvent("PAYMENT_METHOD_SELECTION", metadata),
+            )
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns null when paymentMethod is missing`() {
+            assertNull(toAnalyticsEvent("PAYMENT_METHOD_SELECTION", emptyMap()))
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns null when metadata is null`() {
+            assertNull(toAnalyticsEvent("PAYMENT_METHOD_SELECTION", null))
+        }
+    }
+
+    @Nested
+    inner class `single-field data class events` {
+        @Test
+        fun `toAnalyticsEvent returns PaymentDetailsEntered`() {
+            val metadata = mapOf("paymentMethod" to "PAYMENT_CARD")
+            assertEquals(
+                AnalyticsEvent.PaymentDetailsEntered("PAYMENT_CARD"),
+                toAnalyticsEvent("PAYMENT_DETAILS_ENTERED", metadata),
+            )
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns null for PaymentDetailsEntered without paymentMethod`() {
+            assertNull(toAnalyticsEvent("PAYMENT_DETAILS_ENTERED", null))
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns PaymentSubmitted`() {
+            val metadata = mapOf("paymentMethod" to "PAYMENT_CARD")
+            assertEquals(
+                AnalyticsEvent.PaymentSubmitted("PAYMENT_CARD"),
+                toAnalyticsEvent("PAYMENT_SUBMITTED", metadata),
+            )
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns null for PaymentSubmitted without paymentMethod`() {
+            assertNull(toAnalyticsEvent("PAYMENT_SUBMITTED", null))
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns PaymentProcessingStarted`() {
+            val metadata = mapOf("paymentMethod" to "PAYMENT_CARD")
+            assertEquals(
+                AnalyticsEvent.PaymentProcessingStarted("PAYMENT_CARD"),
+                toAnalyticsEvent("PAYMENT_PROCESSING_STARTED", metadata),
+            )
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns null for PaymentProcessingStarted without paymentMethod`() {
+            assertNull(toAnalyticsEvent("PAYMENT_PROCESSING_STARTED", null))
+        }
+    }
+
+    @Nested
+    inner class `PaymentSuccess event` {
+        @Test
+        fun `toAnalyticsEvent returns PaymentSuccess with paymentMethod and paymentId`() {
+            val metadata = mapOf("paymentMethod" to "PAYMENT_CARD", "paymentId" to "abc123")
+            assertEquals(
+                AnalyticsEvent.PaymentSuccess("PAYMENT_CARD", "abc123"),
+                toAnalyticsEvent("PAYMENT_SUCCESS", metadata),
+            )
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns null when paymentId is missing`() {
+            val metadata = mapOf("paymentMethod" to "PAYMENT_CARD")
+            assertNull(toAnalyticsEvent("PAYMENT_SUCCESS", metadata))
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns null when paymentMethod is missing`() {
+            val metadata = mapOf("paymentId" to "abc123")
+            assertNull(toAnalyticsEvent("PAYMENT_SUCCESS", metadata))
+        }
+    }
+
+    @Nested
+    inner class `PaymentFailure event` {
+        @Test
+        fun `toAnalyticsEvent returns PaymentFailure with paymentMethod and paymentId`() {
+            val metadata = mapOf("paymentMethod" to "PAYMENT_CARD", "paymentId" to "abc123")
+            assertEquals(
+                AnalyticsEvent.PaymentFailure("PAYMENT_CARD", "abc123"),
+                toAnalyticsEvent("PAYMENT_FAILURE", metadata),
+            )
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns PaymentFailure with null paymentId when absent`() {
+            val metadata = mapOf("paymentMethod" to "PAYMENT_CARD")
+            assertEquals(
+                AnalyticsEvent.PaymentFailure("PAYMENT_CARD", null),
+                toAnalyticsEvent("PAYMENT_FAILURE", metadata),
+            )
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns null when paymentMethod is missing`() {
+            assertNull(toAnalyticsEvent("PAYMENT_FAILURE", emptyMap()))
+        }
+    }
+
+    @Nested
+    inner class `PaymentThreeDS event` {
+        @Test
+        fun `toAnalyticsEvent returns PaymentThreeDS with all fields`() {
+            val metadata = mapOf(
+                "paymentMethod" to "PAYMENT_CARD",
+                "threedsProvider" to "ADYEN",
+                "threedsResponse" to "CHALLENGE",
+            )
+            assertEquals(
+                AnalyticsEvent.PaymentThreeDS("PAYMENT_CARD", "ADYEN", "CHALLENGE"),
+                toAnalyticsEvent("PAYMENT_THREEDS", metadata),
+            )
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns PaymentThreeDS with null threedsResponse`() {
+            val metadata = mapOf(
+                "paymentMethod" to "PAYMENT_CARD",
+                "threedsProvider" to "ADYEN",
+            )
+            assertEquals(
+                AnalyticsEvent.PaymentThreeDS("PAYMENT_CARD", "ADYEN", null),
+                toAnalyticsEvent("PAYMENT_THREEDS", metadata),
+            )
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns null when threedsProvider is missing`() {
+            val metadata = mapOf("paymentMethod" to "PAYMENT_CARD")
+            assertNull(toAnalyticsEvent("PAYMENT_THREEDS", metadata))
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns null when paymentMethod is missing`() {
+            val metadata = mapOf("threedsProvider" to "ADYEN")
+            assertNull(toAnalyticsEvent("PAYMENT_THREEDS", metadata))
+        }
+    }
+
+    @Nested
+    inner class `PaymentRedirect event` {
+        @Test
+        fun `toAnalyticsEvent returns PaymentRedirect with paymentMethod and url`() {
+            val metadata = mapOf(
+                "paymentMethod" to "PAYPAL",
+                "redirectDestinationUrl" to "https://example.com",
+            )
+            assertEquals(
+                AnalyticsEvent.PaymentRedirect("PAYPAL", "https://example.com"),
+                toAnalyticsEvent("PAYMENT_REDIRECT_TO_THIRD_PARTY", metadata),
+            )
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns null when redirectDestinationUrl is missing`() {
+            val metadata = mapOf("paymentMethod" to "PAYPAL")
+            assertNull(toAnalyticsEvent("PAYMENT_REDIRECT_TO_THIRD_PARTY", metadata))
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns null when paymentMethod is missing`() {
+            val metadata = mapOf("redirectDestinationUrl" to "https://example.com")
+            assertNull(toAnalyticsEvent("PAYMENT_REDIRECT_TO_THIRD_PARTY", metadata))
+        }
+    }
+
+    @Nested
+    inner class `Vault events` {
+        @Test
+        fun `toAnalyticsEvent returns VaultListOpened with vaultedMethodId`() {
+            assertEquals(
+                AnalyticsEvent.VaultListOpened("vm-1"),
+                toAnalyticsEvent("VAULT_LIST_OPENED", mapOf("vaultedMethodId" to "vm-1")),
+            )
+        }
+
+        @Test
+        fun `toAnalyticsEvent treats empty vaultedMethodId as null for optional-id events`() {
+            assertEquals(
+                AnalyticsEvent.VaultListOpened(null),
+                toAnalyticsEvent("VAULT_LIST_OPENED", mapOf("vaultedMethodId" to "")),
+            )
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns VaultMethodSelected with previous id`() {
+            val metadata = mapOf("vaultedMethodId" to "vm-2", "previousVaultedMethodId" to "vm-1")
+            assertEquals(
+                AnalyticsEvent.VaultMethodSelected("vm-2", "vm-1"),
+                toAnalyticsEvent("VAULT_METHOD_SELECTED", metadata),
+            )
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns null for VaultMethodSelected without vaultedMethodId`() {
+            assertNull(toAnalyticsEvent("VAULT_METHOD_SELECTED", null))
+        }
+
+        @Test
+        fun `toAnalyticsEvent parses vaultedMethodCount as Int`() {
+            assertEquals(
+                AnalyticsEvent.VaultEditModeEntered(3),
+                toAnalyticsEvent("VAULT_EDIT_MODE_ENTERED", mapOf("vaultedMethodCount" to "3")),
+            )
+        }
+
+        @Test
+        fun `toAnalyticsEvent parses exitedFromConfirmation as Boolean`() {
+            assertEquals(
+                AnalyticsEvent.VaultEditModeExited(true),
+                toAnalyticsEvent("VAULT_EDIT_MODE_EXITED", mapOf("exitedFromConfirmation" to "true")),
+            )
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns VaultMethodDeleted with all fields`() {
+            val metadata = mapOf(
+                "vaultedMethodId" to "vm-1",
+                "isActive" to "true",
+                "promotedVaultedMethodId" to "vm-2",
+            )
+            assertEquals(
+                AnalyticsEvent.VaultMethodDeleted("vm-1", true, "vm-2"),
+                toAnalyticsEvent("VAULT_METHOD_DELETED", metadata),
+            )
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns VaultMethodDeletionFailed with errorId and isActive`() {
+            val metadata = mapOf(
+                "vaultedMethodId" to "vm-1",
+                "errorId" to "vault-delete-failed",
+                "isActive" to "false",
+            )
+            assertEquals(
+                AnalyticsEvent.VaultMethodDeletionFailed("vm-1", "vault-delete-failed", false),
+                toAnalyticsEvent("VAULT_METHOD_DELETION_FAILED", metadata),
+            )
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns VaultCvvRequiredRendered with network and expectedCvvLength`() {
+            val metadata = mapOf(
+                "vaultedMethodId" to "vm-1",
+                "network" to "VISA",
+                "expectedCvvLength" to "4",
+            )
+            assertEquals(
+                AnalyticsEvent.VaultCvvRequiredRendered("vm-1", "VISA", 4),
+                toAnalyticsEvent("VAULT_CVV_REQUIRED_RENDERED", metadata),
+            )
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns null for VaultCvvSubmitted without vaultedMethodId`() {
+            assertNull(toAnalyticsEvent("VAULT_CVV_SUBMITTED", null))
+        }
+    }
+
+    @Nested
+    inner class `unknown and edge cases` {
+        @Test
+        fun `toAnalyticsEvent returns null for unknown event name`() {
+            assertNull(toAnalyticsEvent("UNKNOWN_EVENT", null))
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns null for empty event name`() {
+            assertNull(toAnalyticsEvent("", null))
+        }
+
+        @Test
+        fun `toAnalyticsEvent returns null for lowercase event name`() {
+            assertNull(toAnalyticsEvent("sdk_init_start", null))
+        }
+    }
+}

package/ios/Sources/DataModels/PrimerAddress+Extension.swift

@@ -0,0 +1,35 @@
+//
+//  PrimerAddress+Extension.swift
+//  primer-io-react-native
+//
+
+import Foundation
+import PrimerSDK
+
+extension PrimerAddress {
+
+    convenience init?(billingAddressStr: String) {
+        guard
+            let data = billingAddressStr.data(using: .utf8),
+            let json = try? JSONSerialization.jsonObject(with: data),
+            let dict = json as? [String: Any]
+        else {
+            return nil
+        }
+
+        let stringValue: (String) -> String? = { key in
+            dict[key] as? String
+        }
+
+        self.init(
+            firstName: stringValue("firstName"),
+            lastName: stringValue("lastName"),
+            addressLine1: stringValue("addressLine1"),
+            addressLine2: stringValue("addressLine2"),
+            postalCode: stringValue("postalCode"),
+            city: stringValue("city"),
+            state: stringValue("state"),
+            countryCode: stringValue("countryCode")
+        )
+    }
+}

package/ios/Sources/DataModels/PrimerCardData+Extension.swift

@@ -26,11 +26,19 @@ extension PrimerCardData {
                let cvv = dict["cvv"],
                let expiryDate = dict["expiryDate"] {
                 let cardholderName = dict["cardholderName"]
+                // Optional co-badge pick from JS; unknown identifiers are ignored.
+                var cardNetwork: CardNetwork?
+                if let networkIdentifier = dict["cardNetwork"],
+                   let network = CardNetwork(rawValue: networkIdentifier),
+                   network != .unknown {
+                    cardNetwork = network
+                }
                 self.init(
                     cardNumber: cardNumber,
                     expiryDate: expiryDate,
                     cvv: cvv,
-                    cardholderName: cardholderName)
+                    cardholderName: cardholderName,
+                    cardNetwork: cardNetwork)
             } else {
                 return nil
             }