@primer-io/react-native 2.18.0 → 2.19.0

package/android/build.gradle

@@ -136,5 +136,5 @@ dependencies {
   api 'com.facebook.react:react-native:+'
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
   implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:1.3.3"
-  implementation 'io.primer:android:2.18.0'
+  implementation 'io.primer:android:2.21.0'
 }

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

@@ -7,6 +7,7 @@ import com.facebook.react.uimanager.ViewManager
 import com.primerioreactnative.components.manager.asset.PrimerRNHeadlessUniversalCheckoutAssetManager
 import com.primerioreactnative.components.manager.nativeUi.PrimerRNHeadlessUniversalCheckoutNativeUiManager
 import com.primerioreactnative.components.manager.raw.PrimerRNHeadlessUniversalCheckoutRawManager
+import com.primerioreactnative.components.manager.vault.PrimerRNHeadlessUniversalCheckoutVaultManager
 import kotlinx.serialization.json.Json
 
 class ReactNativePackage : ReactPackage {
@@ -19,7 +20,8 @@ class ReactNativePackage : ReactPackage {
       PrimerRNHeadlessUniversalCheckout(reactContext, json),
       PrimerRNHeadlessUniversalCheckoutRawManager(reactContext, json),
       PrimerRNHeadlessUniversalCheckoutNativeUiManager(reactContext),
-      PrimerRNHeadlessUniversalCheckoutAssetManager(reactContext)
+      PrimerRNHeadlessUniversalCheckoutAssetManager(reactContext),
+      PrimerRNHeadlessUniversalCheckoutVaultManager(reactContext, json)
     )
   }
 

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

@@ -0,0 +1,23 @@
+package com.primerioreactnative.components.datamodels.manager.vault
+
+import kotlinx.serialization.Serializable
+import io.primer.android.components.domain.error.PrimerValidationError
+
+@Serializable
+data class PrimerRNValidationError(
+  val errorId: String,
+  val description: String,
+  val diagnosticsId: String
+)
+
+@Serializable
+data class PrimerRNValidationErrors(
+  val validationErrors: List<PrimerRNValidationError>
+)
+
+internal fun PrimerValidationError.toPrimerRNValidationError() =
+  PrimerRNValidationError(
+    errorId,
+    description,
+    diagnosticsId
+  )

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

@@ -0,0 +1,34 @@
+package com.primerioreactnative.components.datamodels.manager.vault
+
+import com.primerioreactnative.datamodels.PrimerPaymentInstrumentTokenRN.PaymentInstrumentData
+import com.primerioreactnative.datamodels.PrimerPaymentInstrumentTokenRN.ThreeDSAuthenticationData
+import com.primerioreactnative.extensions.toPaymentInstrumentDataRN
+import com.primerioreactnative.extensions.toThreeDsAuthenticationDataRN
+import io.primer.android.domain.tokenization.models.PrimerVaultedPaymentMethod
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class PrimerRNVaultedPaymentMethod(
+  val id: String,
+  val analyticsId: String,
+  val paymentInstrumentType: String,
+  val paymentMethodType: String,
+  val paymentInstrumentData: PaymentInstrumentData?,
+  val threeDSecureAuthentication: ThreeDSAuthenticationData? = null
+)
+
+@Serializable
+data class PrimerRNVaultedPaymentMethods(
+  val paymentMethods: List<PrimerRNVaultedPaymentMethod>
+)
+
+internal fun PrimerVaultedPaymentMethod.toPrimerRNVaultedPaymentMethod() =
+  PrimerRNVaultedPaymentMethod(
+    id,
+    analyticsId,
+    paymentInstrumentType,
+    paymentMethodType,
+    paymentInstrumentData.toPaymentInstrumentDataRN(),
+    threeDSecureAuthentication?.toThreeDsAuthenticationDataRN()
+  )
+

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

@@ -0,0 +1,12 @@
+package com.primerioreactnative.components.datamodels.manager.vault
+
+import io.primer.android.components.domain.payments.vault.model.card.PrimerVaultedCardAdditionalData
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class PrimerRNVaultedPaymentMethodAdditionalData(
+  val cvv: String
+)
+
+internal fun PrimerRNVaultedPaymentMethodAdditionalData.toPrimerVaultedCardAdditionalData() =
+  PrimerVaultedCardAdditionalData(cvv)

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

@@ -0,0 +1,165 @@
+package com.primerioreactnative.components.manager.vault
+
+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.primerioreactnative.components.datamodels.manager.vault.PrimerRNValidationErrors
+import com.primerioreactnative.components.datamodels.manager.vault.PrimerRNVaultedPaymentMethodAdditionalData
+import com.primerioreactnative.components.datamodels.manager.vault.PrimerRNVaultedPaymentMethods
+import com.primerioreactnative.components.datamodels.manager.vault.toPrimerRNValidationError
+import com.primerioreactnative.components.datamodels.manager.vault.toPrimerRNVaultedPaymentMethod
+import com.primerioreactnative.components.datamodels.manager.vault.toPrimerVaultedCardAdditionalData
+import com.primerioreactnative.datamodels.ErrorTypeRN
+import com.primerioreactnative.utils.convertJsonToMap
+import com.primerioreactnative.utils.errorTo
+import io.primer.android.components.manager.vault.PrimerHeadlessUniversalCheckoutVaultManager
+import io.primer.android.components.manager.vault.PrimerHeadlessUniversalCheckoutVaultManagerInterface
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import org.json.JSONObject
+
+class PrimerRNHeadlessUniversalCheckoutVaultManager(
+  reactContext: ReactApplicationContext,
+  private val json: Json,
+) : ReactContextBaseJavaModule(reactContext) {
+
+  private val vaultScope = CoroutineScope(SupervisorJob())
+  private lateinit var nativeVaultManager: PrimerHeadlessUniversalCheckoutVaultManagerInterface
+
+  override fun getName() = "RNPrimerHeadlessUniversalCheckoutVaultManager"
+
+  @ReactMethod
+  fun configure(promise: Promise) {
+    try {
+      nativeVaultManager = PrimerHeadlessUniversalCheckoutVaultManager.newInstance()
+      promise.resolve(null)
+    } catch (e: Exception) {
+      val exception =
+        ErrorTypeRN.NativeBridgeFailed errorTo (e.message
+          ?: "An error occurs while initialising the vault manager.")
+      promise.reject(exception.errorId, exception.description)
+    }
+  }
+
+  @ReactMethod
+  fun fetchVaultedPaymentMethods(promise: Promise) {
+    vaultScope.launch {
+      nativeVaultManager.fetchVaultedPaymentMethods().onSuccess { vaultedPaymentMethods ->
+        promise.resolve(
+          convertJsonToMap(
+            JSONObject(
+              Json.encodeToString(
+                PrimerRNVaultedPaymentMethods(vaultedPaymentMethods.map {
+                  it.toPrimerRNVaultedPaymentMethod()
+                })
+              )
+            )
+          )
+        )
+      }.onFailure { throwable ->
+        val exception =
+          ErrorTypeRN.NativeBridgeFailed errorTo (throwable.message
+            ?: "An error occurs while fetching vaulted payment methods.")
+        promise.reject(exception.errorId, exception.description)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun deleteVaultedPaymentMethod(vaultedPaymentMethodId: String, promise: Promise) {
+    vaultScope.launch {
+      nativeVaultManager.deleteVaultedPaymentMethod(vaultedPaymentMethodId).onSuccess {
+        promise.resolve(null)
+      }.onFailure { throwable ->
+        promise.reject(
+          ErrorTypeRN.VaultManagerDeleteFailed.errorId,
+          throwable.message,
+          throwable
+        )
+      }
+    }
+  }
+
+  @ReactMethod
+  fun validate(
+    vaultedPaymentMethodId: String,
+    additionalDataStr: String,
+    promise: Promise
+  ) {
+    val additionalData: PrimerRNVaultedPaymentMethodAdditionalData =
+      json.decodeFromString(additionalDataStr)
+
+    vaultScope.launch {
+      nativeVaultManager.validate(
+        vaultedPaymentMethodId,
+        additionalData.toPrimerVaultedCardAdditionalData()
+      ).onSuccess { errors ->
+        promise.resolve(
+          convertJsonToMap(
+            JSONObject(
+              Json.encodeToString(
+                PrimerRNValidationErrors(errors.map {
+                  it.toPrimerRNValidationError()
+                })
+              )
+            )
+          )
+        )
+      }.onFailure { throwable ->
+        promise.reject(
+          ErrorTypeRN.InvalidVaultedPaymentMethodId.errorId,
+          throwable.message,
+          throwable
+        )
+      }
+    }
+  }
+
+  @ReactMethod
+  fun startPaymentFlow(
+    vaultedPaymentMethodId: String,
+    promise: Promise
+  ) {
+    vaultScope.launch {
+      nativeVaultManager.startPaymentFlow(vaultedPaymentMethodId).onSuccess {
+        promise.resolve(null)
+      }.onFailure { throwable ->
+        promise.reject(
+          ErrorTypeRN.InvalidVaultedPaymentMethodId.errorId,
+          throwable.message,
+          throwable
+        )
+      }
+    }
+  }
+
+  @ReactMethod
+  fun startPaymentFlowWithAdditionalData(
+    vaultedPaymentMethodId: String,
+    additionalDataStr: String,
+    promise: Promise
+  ) {
+    val additionalData: PrimerRNVaultedPaymentMethodAdditionalData =
+      json.decodeFromString(additionalDataStr)
+
+    vaultScope.launch {
+      nativeVaultManager.startPaymentFlow(
+        vaultedPaymentMethodId,
+        additionalData.toPrimerVaultedCardAdditionalData()
+      ).onSuccess {
+        promise.resolve(null)
+      }.onFailure { throwable ->
+        promise.reject(
+          ErrorTypeRN.InvalidVaultedPaymentMethodId.errorId,
+          throwable.message,
+          throwable
+        )
+      }
+    }
+  }
+}

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

@@ -15,5 +15,7 @@ enum class ErrorTypeRN(val errorId: String) {
   NativeBridgeFailed("native-android"),
   UnitializedSdkSession("uninitialized-sdk-session"),
   UnsupportedPaymentMethod("unsupported-payment-method-type"),
-  UnsupportedPaymentIntent("unsupported-session-intent")
+  UnsupportedPaymentIntent("unsupported-session-intent"),
+  VaultManagerDeleteFailed("vaulted-manager-delete-failed"),
+  InvalidVaultedPaymentMethodId("invalid-vaulted-payment-method-id")
 }

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

@@ -7,7 +7,6 @@ fun PrimerPaymentMethodOptionsRN.toPrimerPaymentMethodOptions() = PrimerPaymentM
   androidSettingsRN.redirectScheme,
   googlePayOptions.toPrimerGooglePayOptions(),
   klarnaOptions.toPrimerKlarnaOptions(),
-  apayaOptions.toPrimerApayaOptions(),
   threeDsOptions.toPrimerThreeDsOptions()
 )
 
@@ -17,7 +16,5 @@ fun PrimerGooglePayOptionsRN.toPrimerGooglePayOptions() =
 fun PrimerKlarnaOptionsRN.toPrimerKlarnaOptions() =
   PrimerKlarnaOptions(recurringPaymentDescription, webViewTitle)
 
-fun PrimerApayaOptionsRN.toPrimerApayaOptions() = PrimerApayaOptions(webViewTitle)
-
 fun PrimerThreeDsOptionsRN.toPrimerThreeDsOptions() =
   PrimerThreeDsOptions(threeDsOptionsAndroid?.threeDsAppRequestorUrl)

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

@@ -0,0 +1,13 @@
+package com.primerioreactnative.extensions
+
+import com.primerioreactnative.datamodels.PrimerPaymentInstrumentTokenRN
+import io.primer.android.domain.tokenization.models.PrimerVaultedPaymentMethod.AuthenticationDetails
+
+internal fun AuthenticationDetails.toThreeDsAuthenticationDataRN() =
+  PrimerPaymentInstrumentTokenRN.ThreeDSAuthenticationData(
+    responseCode.name,
+    reasonCode,
+    reasonText,
+    protocolVersion,
+    challengeIssued
+  )

package/ios/Podfile.lock

@@ -1,3 +1,3 @@
 PODFILE CHECKSUM: 0984f720d2439f86374726bfdebe32d895fdcf46
 
-COCOAPODS: 1.13.0
+COCOAPODS: 1.14.3

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

@@ -0,0 +1,25 @@
+//
+//  VaultManager.m
+//  primer-io-react-native
+//
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(RNPrimerHeadlessUniversalCheckoutVaultManager, RCTEventEmitter)
+
+// MARK: - API
+
+RCT_EXTERN_METHOD(configure: (RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(fetchVaultedPaymentMethods:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(deleteVaultedPaymentMethod:(NSString *)vaultedPaymentMethodId resolver:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(validate:(NSString *)vaultedPaymentMethodId additionalDataStr:(NSString *)additionalDataStr resolver:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(startPaymentFlow:(NSString *)vaultedPaymentMethodId resolver:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(startPaymentFlowWithAdditionalData:(NSString *)vaultedPaymentMethodId additionalDataStr:(NSString *)additionalDataStr resolver:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
+
+@end

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

@@ -0,0 +1,85 @@
+import PrimerSDK
+
+@objc(RNPrimerHeadlessUniversalCheckoutVaultManager)
+class RNPrimerHeadlessUniversalCheckoutVaultManager: RCTEventEmitter {
+
+    private var vaultedManager: PrimerHeadlessUniversalCheckout.VaultManager!
+
+    override func supportedEvents() -> [String]! {
+        return []
+    }
+
+    override class func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+
+    @objc
+    func configure(_ resolver : @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        do {
+            self.vaultedManager = PrimerSDK.PrimerHeadlessUniversalCheckout.VaultManager()
+            try self.vaultedManager.configure()
+            resolver(nil)
+        } catch {
+            rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
+        }
+    }
+
+    @objc
+    func fetchVaultedPaymentMethods(_ resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        self.vaultedManager.fetchVaultedPaymentMethods { vaultedPaymentMethods, err in
+            if let err = err {
+                rejecter(err.rnError["errorId"]!, err.rnError["description"], err)
+            } else if let paymentMethods = vaultedPaymentMethods {
+                do {
+                    let paymentMethodObjects = try paymentMethods.compactMap({ try $0.toJsonObject() })
+                    resolver(["paymentMethods": paymentMethodObjects])
+                } catch {
+                    rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
+                }
+            }
+        }
+    }
+    
+    @objc
+    func deleteVaultedPaymentMethod(_ vaultedPaymentMethodId: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        self.vaultedManager.deleteVaultedPaymentMethod(id: vaultedPaymentMethodId) { err in
+            if let err = err {
+                rejecter(err.rnError["errorId"]!, err.rnError["description"], err)
+            } else {
+                resolver([])
+            }
+        }
+    }
+    
+    @objc
+    func validate(_ vaultedPaymentMethodId: String, additionalDataStr: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        do {
+            let additionalData = try PrimerVaultedCardAdditionalData.from(jsonString: additionalDataStr)
+            self.vaultedManager.validate(vaultedPaymentMethodId: vaultedPaymentMethodId, vaultedPaymentMethodAdditionalData: additionalData) { err in
+                if let err = err, err.count > 0 {
+                    rejecter(err.first!.rnError["errorId"]!, err.first!.rnError["description"], err.first!)
+                } else {
+                    resolver(["validationErrors": []])
+                }
+            }
+        } catch {
+            rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
+        }
+    }
+    
+    @objc
+    func startPaymentFlow(_ vaultedPaymentMethodId: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        self.vaultedManager.startPaymentFlow(vaultedPaymentMethodId: vaultedPaymentMethodId)
+    }
+    
+    @objc
+    func startPaymentFlowWithAdditionalData(_ vaultedPaymentMethodId: String, additionalDataStr: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        do {
+            let additionalData = try PrimerVaultedCardAdditionalData.from(jsonString: additionalDataStr)
+            self.vaultedManager.startPaymentFlow(vaultedPaymentMethodId: vaultedPaymentMethodId,
+                                                 vaultedPaymentMethodAdditionalData: additionalData)
+        } catch {
+            rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
+        }
+    }
+}

package/ios/Sources/Helpers/Encodable+Extension.swift

@@ -8,10 +8,23 @@
 import Foundation
 
 extension Encodable {
-    
+
     func toJsonObject() throws -> Any {
         let data = try JSONEncoder().encode(self)
         let json = try JSONSerialization.jsonObject(with: data, options: .allowFragments)
         return json
     }
 }
+
+extension Decodable {
+    /// Initialize an object from a JSON string.
+    /// - Parameter jsonString: A string representation of the JSON.
+    /// - Throws: An error if the decoding fails.
+    /// - Returns: An initialized object conforming to the Decodable protocol.
+    static func from(jsonString: String) throws -> Self {
+        guard let data = jsonString.data(using: .utf8) else {
+            throw NSError(domain: "String could not be converted to UTF-8 data.", code: 0, userInfo: [NSLocalizedDescriptionKey: "String could not be converted to UTF-8 data."])
+        }
+        return try JSONDecoder().decode(Self.self, from: data)
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primer-io/react-native",
-  "version": "2.18.0",
+  "version": "2.19.0",
   "description": "Primer SDK for RN",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -9,10 +9,8 @@
   "source": "src/index",
   "files": [
     "src",
-    "lib",
     "android",
     "ios",
-    "cpp",
     "primer-io-react-native.podspec",
     "!android/build",
     "!ios/build",
@@ -24,10 +22,10 @@
     "test": "jest",
     "typescript": "tsc --noEmit",
     "lint": "eslint \"**/*.{js,ts,tsx}\"",
+    "build": "bob build",
     "prepare": "bob build",
     "release": "release-it",
     "example": "yarn --cwd example",
-    "pods": "cd example && pod-install --quiet",
     "bootstrap": "yarn example && yarn && yarn pods"
   },
   "keywords": [
@@ -52,18 +50,16 @@
     "@release-it/conventional-changelog": "^5.1.1",
     "@tsconfig/react-native": "^3.0.0",
     "@types/jest": "^26.0.0",
-    "@types/react": "^18.0.24",
-    "@types/react-native": "0.62.13",
+    "@types/react": "^18.0.26",
+    "@types/react-native": "0.72.2",
     "commitlint": "^11.0.0",
-    "eslint": "^8.19.0",
+    "eslint": "^7.0.0",
     "eslint-config-prettier": "^7.0.0",
     "eslint-plugin-prettier": "^3.1.3",
     "husky": "^4.2.5",
     "jest": "^26.0.1",
     "pod-install": "^0.1.0",
     "prettier": "^2.4.1",
-    "react": "18.2.0",
-    "react-native": "0.72.3",
     "react-native-builder-bob": "^0.20.1",
     "release-it": "^15.5.0",
     "typescript": "4.8.4"

package/primer-io-react-native.podspec

@@ -16,5 +16,5 @@ Pod::Spec.new do |s|
   s.source_files = "ios/**/*.{h,m,mm,swift}"
 
   s.dependency "React-Core"
-  s.dependency "PrimerSDK", "2.18.0"
+  s.dependency "PrimerSDK", "2.19.0"
 end

package/src/HeadlessUniversalCheckout/Managers/AssetsManager.ts

@@ -1,4 +1,4 @@
-import type { Asset } from '@primer-io/react-native';
+import { IPrimerAsset as Asset } from '../../models/PrimerAsset';
 import { NativeModules } from 'react-native';
 
 const { RNTPrimerHeadlessUniversalCheckoutAssetsManager } = NativeModules;

package/src/HeadlessUniversalCheckout/Managers/PaymentMethodManagers/RawDataManager.ts

@@ -1,5 +1,5 @@
-import type { RawData } from '@primer-io/react-native';
-import { NativeEventEmitter, NativeModules, EmitterSubscription } from 'react-native';
+import { type PrimerRawData as RawData } from '../../../models/PrimerRawData';
+import { NativeEventEmitter, NativeModules, EmitterSubscription, EventSubscription } from 'react-native';
 import type { PrimerInitializationData } from 'src/models/PrimerInitializationData';
 import { PrimerError } from '../../../models/PrimerError';
 import type { PrimerInputElementType } from '../../../models/PrimerInputElementType';
@@ -26,6 +26,8 @@ class PrimerHeadlessUniversalCheckoutRawDataManager {
 
     options?: RawDataManagerProps
 
+    subscriptions: EventSubscription[] = []
+
     ///////////////////////////////////////////
     // Init
     ///////////////////////////////////////////
@@ -54,25 +56,23 @@ class PrimerHeadlessUniversalCheckoutRawDataManager {
 
     async configureListeners(): Promise<void> {
         //@ts-ignore
-        return new Promise(async (resolve, reject) => {
-            if (this.options?.onMetadataChange) {
-                this.addListener("onMetadataChange", (data) => {
-                    if (this.options?.onMetadataChange) {
-                        this.options.onMetadataChange(data);
-                    }
-                });
-            }
-
-            if (this.options?.onValidation) {
-                this.addListener("onValidation", (data) => {
-                    if (this.options?.onValidation) {
-                        this.options.onValidation(data.isValid, data.errors);
-                    }
-                });
-            }
-
-            resolve();
-        });
+        if (this.options?.onMetadataChange) {
+            const sub = await this.addListener("onMetadataChange", (data) => {
+                if (this.options?.onMetadataChange) {
+                    this.options.onMetadataChange(data);
+                }
+            });
+            this.subscriptions.push(sub);
+        }
+
+        if (this.options?.onValidation) {
+            const sub = await this.addListener("onValidation", (data) => {
+                if (this.options?.onValidation) {
+                    this.options.onValidation(data.isValid, data.errors);
+                }
+            });
+            this.subscriptions.push(sub);
+        }
     }
 
     async getRequiredInputElementTypes(): Promise<PrimerInputElementType[]> {

package/src/HeadlessUniversalCheckout/Managers/VaultManager.ts

@@ -0,0 +1,90 @@
+import { NativeModules } from 'react-native';
+import { PrimerValidationError as ValidationError } from 'src/models/PrimerValidationError';
+import { PrimerVaultedPaymentMethod as VaultedPaymentMethod } from 'src/models/PrimerVaultedPaymentMethod';
+import { PrimerVaultedPaymentMethodAdditionalData as VaultedPaymentMethodAdditionalData } from 'src/models/PrimerVaultedPaymentMethodAdditionalData';
+import { PrimerVaultedPaymentMethodResult } from 'src/models/PrimerVaultedPaymentMethodResult';
+import { PrimerValidationErrorResult } from 'src/models/PrimerValidationErrorResult';
+
+const { RNPrimerHeadlessUniversalCheckoutVaultManager } = NativeModules;
+
+class PrimerHeadlessUniversalCheckoutVaultManager {
+
+    ///////////////////////////////////////////
+    // Init
+    ///////////////////////////////////////////
+    constructor() { }
+
+    ///////////////////////////////////////////
+    // Native API
+    ///////////////////////////////////////////
+
+    async configure(): Promise<void> {
+        return new Promise(async (resolve, reject) => {
+            try {
+                await RNPrimerHeadlessUniversalCheckoutVaultManager.configure();
+                resolve();
+            } catch (err) {
+                console.error(err);
+                reject(err);
+            }
+        });
+    }
+
+    async fetchVaultedPaymentMethods(): Promise<VaultedPaymentMethod[]> {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const data: PrimerVaultedPaymentMethodResult =
+                    await RNPrimerHeadlessUniversalCheckoutVaultManager.fetchVaultedPaymentMethods();
+                const paymentMethods: VaultedPaymentMethod[] = data.paymentMethods;
+                resolve(paymentMethods);
+            } catch (err) {
+                console.error(err);
+                reject(err);
+            }
+        });
+    }
+
+    async deleteVaultedPaymentMethod(vaultedPaymentMethodId: string): Promise<void> {
+        return new Promise(async (resolve, reject) => {
+            try {
+                await RNPrimerHeadlessUniversalCheckoutVaultManager.deleteVaultedPaymentMethod(vaultedPaymentMethodId);
+                resolve();
+            } catch (err) {
+                console.error(err);
+                reject(err);
+            }
+        });
+    }
+
+    async validate(vaultedPaymentMethodId: string, additionalData: VaultedPaymentMethodAdditionalData): Promise<ValidationError[]> {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const data: PrimerValidationErrorResult =
+                    await RNPrimerHeadlessUniversalCheckoutVaultManager.validate(vaultedPaymentMethodId, JSON.stringify(additionalData));
+                const errors: ValidationError[] = data.validationErrors;
+                resolve(errors);
+            } catch (err) {
+                console.error(err);
+                reject(err);
+            }
+        });
+    }
+
+    async startPaymentFlow(vaultedPaymentMethodId: string, additionalData?: VaultedPaymentMethodAdditionalData): Promise<void> {
+        return new Promise(async (resolve, reject) => {
+            try {
+                if(additionalData) {
+                    await RNPrimerHeadlessUniversalCheckoutVaultManager.startPaymentFlowWithAdditionalData(vaultedPaymentMethodId, JSON.stringify(additionalData));
+                } else {
+                    await RNPrimerHeadlessUniversalCheckoutVaultManager.startPaymentFlow(vaultedPaymentMethodId);
+                }
+                resolve();
+            } catch (err) {
+                console.error(err);
+                reject(err);
+            }
+        });
+    }
+}
+
+export default PrimerHeadlessUniversalCheckoutVaultManager;