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

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
             }

package/ios/Sources/Headless Universal Checkout/Managers/Assets Manager/RNTAssetsManager.m

@@ -10,10 +10,17 @@
 
 @interface RCT_EXTERN_MODULE(RNTPrimerHeadlessUniversalCheckoutAssetsManager, RCTEventEmitter)
 
+RCT_EXTERN_METHOD(getCardNetworkTraits:(NSString *)cardNetworkStr
+                      resolver:(RCTPromiseResolveBlock)resolver
+                      rejecter:(RCTPromiseRejectBlock)rejecter)
+
 RCT_EXTERN_METHOD(getCardNetworkImage:(NSString *)cardNetworkStr
                       resolver:(RCTPromiseResolveBlock)resolver
                       rejecter:(RCTPromiseRejectBlock)rejecter)
 
+RCT_EXTERN_METHOD(getOrderedAllowedCardNetworks:(RCTPromiseResolveBlock)resolver
+                      rejecter:(RCTPromiseRejectBlock)rejecter)
+
 RCT_EXTERN_METHOD(getPaymentMethodAsset:(NSString *)paymentMethodType
                       resolver:(RCTPromiseResolveBlock)resolver
                       rejecter:(RCTPromiseRejectBlock)rejecter)

package/ios/Sources/Headless Universal Checkout/Managers/Assets Manager/RNTAssetsManager.swift

@@ -6,7 +6,7 @@
 //
 
 import Foundation
-import PrimerSDK
+@_spi(PrimerInternal) import PrimerSDK
 import React
 
 // swiftlint:disable type_name
@@ -23,24 +23,57 @@ class RNTPrimerHeadlessUniversalCheckoutAssetsManager: RCTEventEmitter {
     }
 
     @objc
-    func getCardNetworkImage(
+    func getCardNetworkTraits(
         _ cardNetworkStr: String,
         resolver: RCTPromiseResolveBlock,
         rejecter: RCTPromiseRejectBlock
     ) {
-        do {
+        guard let traits = PrimerSDK.PrimerHeadlessUniversalCheckout.AssetsManager
+            .getCardNetworkTraits(cardNetworkString: cardNetworkStr) else {
+            resolver(nil)
+            return
+        }
+        resolver([
+            "cardNetwork": traits.cardNetwork.rawValue,
+            "displayName": traits.displayName,
+            "panLengths": traits.panLengths,
+            "gapPattern": traits.gapPattern,
+            "cvvLength": traits.cvvLength,
+            "cvvLabel": traits.cvvLabel
+        ])
+    }
 
-            guard let cardNetwork = CardNetwork(rawValue: cardNetworkStr) else {
-                let err = RNTNativeError(
-                    errorId: "native-ios",
-                    errorDescription: "Failed to find asset of \(cardNetworkStr).",
-                    recoverySuggestion: nil)
-                throw err
-            }
+    @objc
+    func getOrderedAllowedCardNetworks(
+        _ resolver: @escaping RCTPromiseResolveBlock,
+        rejecter: @escaping RCTPromiseRejectBlock
+    ) {
+        guard #available(iOS 15.0, *) else {
+            resolver(["networks": NSNull()])
+            return
+        }
+        if let networks = ComponentsClientSessionBridge().getOrderedAllowedCardNetworks() {
+            resolver(["networks": networks])
+        } else {
+            resolver(["networks": NSNull()])
+        }
+    }
 
+    @objc
+    func getCardNetworkImage(
+        _ cardNetworkStr: String,
+        resolver: RCTPromiseResolveBlock,
+        rejecter: RCTPromiseRejectBlock
+    ) {
+        do {
+            // Use the non-deprecated getCardNetworkAsset API. The deprecated
+            // getCardNetworkImage(for:) concatenates rawValue uppercase with a lowercase
+            // bundle filename (e.g. "VISA-logo-colored" vs "visa-logo-colored.imageset"),
+            // which always misses on iOS's case-sensitive asset lookup.
             guard
-                let cardNetworkImage = try PrimerSDK.PrimerHeadlessUniversalCheckout.AssetsManager
-                    .getCardNetworkImage(for: cardNetwork)
+                let cardNetworkAsset = PrimerSDK.PrimerHeadlessUniversalCheckout.AssetsManager
+                    .getCardNetworkAsset(cardNetworkString: cardNetworkStr),
+                let cardNetworkImage = cardNetworkAsset.cardImage
             else {
                 let err = RNTNativeError(
                     errorId: "native-ios",
@@ -49,7 +82,7 @@ class RNTPrimerHeadlessUniversalCheckoutAssetsManager: RCTEventEmitter {
                 throw err
             }
 
-            let localUrl = try cardNetworkImage.store(withName: cardNetwork.rawValue)
+            let localUrl = try cardNetworkImage.store(withName: cardNetworkAsset.cardNetwork.rawValue)
             resolver(["cardNetworkImageURL": localUrl.absoluteString])
 
         } catch {

package/ios/Sources/Headless Universal Checkout/Managers/Payment Method Managers/RNPrimerHeadlessUniversalCheckoutVaultManager.m

@@ -22,4 +22,6 @@ RCT_EXTERN_METHOD(startPaymentFlow:(NSString *)vaultedPaymentMethodId resolver:(
 
 RCT_EXTERN_METHOD(startPaymentFlowWithAdditionalData:(NSString *)vaultedPaymentMethodId additionalDataStr:(NSString *)additionalDataStr resolver:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
 
+RCT_EXTERN_METHOD(requiresVaultedCardCvv:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
+
 @end

package/ios/Sources/Headless Universal Checkout/Managers/Payment Method Managers/RNPrimerHeadlessUniversalCheckoutVaultManager.swift

@@ -1,4 +1,4 @@
-import PrimerSDK
+@_spi(PrimerInternal) import PrimerSDK
 import React
 
 // swiftlint:disable type_name
@@ -105,4 +105,15 @@ class RNPrimerHeadlessUniversalCheckoutVaultManager: RCTEventEmitter {
       rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
     }
   }
+
+  @objc
+  func requiresVaultedCardCvv(
+    _ resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock
+  ) {
+    guard #available(iOS 15.0, *) else {
+      resolver(false)
+      return
+    }
+    resolver(ComponentsClientSessionBridge().getCaptureVaultedCardCvv())
+  }
 }

package/ios/Sources/Headless Universal Checkout/Managers/Payment Method Managers/RNTRawDataManager.m

@@ -18,6 +18,8 @@ RCT_EXTERN_METHOD(setRawData:(NSString *)rawDataStr resolver:(RCTPromiseResolveB
 
 RCT_EXTERN_METHOD(submit:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(setBillingAddress:(NSString *)billingAddressStr resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(cleanUp:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 
 @end