judokit-react-native 4.1.2 → 4.2.0

package/android/src/main/java/com/judopay/judokit/reactnative/JudoKitReactNativeModule.kt

@@ -0,0 +1,238 @@
+package com.judopay.judokit.reactnative
+
+import androidx.fragment.app.FragmentActivity
+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.bridge.ReadableMap
+import com.judopay.judokit.android.Judo
+import com.judopay.judokit.android.api.factory.JudoApiServiceFactory
+import com.judopay.judokit.android.api.model.response.JudoApiCallResult
+import com.judopay.judokit.android.api.model.response.Receipt
+import com.judopay.judokit.android.api.model.response.toJudoResult
+import com.judopay.judokit.android.model.JudoPaymentResult
+import com.judopay.judokit.android.model.PaymentWidgetType
+import com.judopay.judokit.android.model.TransactionDetails
+import com.judopay.judokit.android.service.CardTransactionManager
+import com.judopay.judokit.android.service.CardTransactionManagerResultListener
+import retrofit2.Call
+import retrofit2.Callback
+import retrofit2.Response
+
+const val REQUEST_FAILED_MESSAGE = "The request was unsuccessful."
+const val MODULE_NAME = "JudoKitReactNative"
+
+class JudoKitReactNativeModule internal constructor(private val reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext), CardTransactionManagerResultListener {
+    override fun getName() = MODULE_NAME
+
+    private val listener = JudoActivityEventListener()
+    private var transactionPromise: Promise? = null
+    private var isSubscribedToCardTransactionResults = false
+
+    init {
+      reactContext.addActivityEventListener(listener)
+    }
+
+    @ReactMethod
+    fun invokeTransaction(
+      options: ReadableMap,
+      promise: Promise,
+    ) {
+      try {
+        val judo = getTransactionConfiguration(options)
+        startJudoActivity(judo, promise)
+      } catch (error: Exception) {
+        promise.reject(JUDO_PROMISE_REJECTION_CODE, error.localizedMessage, error)
+      }
+    }
+
+    @ReactMethod
+    fun invokeGooglePay(
+      options: ReadableMap,
+      promise: Promise,
+    ) {
+      try {
+        val judo = getGoogleTransactionConfiguration(options)
+        startJudoActivity(judo, promise)
+      } catch (error: Exception) {
+        promise.reject(JUDO_PROMISE_REJECTION_CODE, error.localizedMessage, error)
+      }
+    }
+
+    @ReactMethod
+    fun invokePaymentMethodScreen(
+      options: ReadableMap,
+      promise: Promise,
+    ) {
+      try {
+        val judo = getPaymentMethodsConfiguration(options)
+        startJudoActivity(judo, promise)
+      } catch (error: Exception) {
+        promise.reject(JUDO_PROMISE_REJECTION_CODE, error.localizedMessage, error)
+      }
+    }
+
+    @ReactMethod
+    fun performTokenTransaction(
+      options: ReadableMap,
+      promise: Promise,
+    ) {
+      try {
+        ensureIsSubscribedToCardTransactionResults()
+
+        val activity = reactContext.currentActivity as FragmentActivity
+        val manager = CardTransactionManager.getInstance(activity)
+
+        val judo = getTokenTransactionConfiguration(options)
+        val cardToken = options.cardToken
+
+        if (cardToken == null) {
+          promise.reject(JUDO_PROMISE_REJECTION_CODE, "No card token found")
+          return
+        }
+
+        manager.configureWith(judo)
+
+        val details =
+          TransactionDetails.Builder()
+            .setCardHolderName(options.cardholderName)
+            .setSecurityNumber(options.securityCode)
+            .setCardType(options.cardType)
+            .setCardToken(cardToken)
+            .setEmail(judo.emailAddress)
+            .setCountryCode(judo.address?.countryCode.toString())
+            .setPhoneCountryCode(judo.phoneCountryCode)
+            .setMobileNumber(judo.mobileNumber)
+            .setAddressLine1(judo.address?.line1)
+            .setAddressLine2(judo.address?.line2)
+            .setAddressLine3(judo.address?.line3)
+            .setCity(judo.address?.town)
+            .setPostalCode(judo.address?.postCode)
+            .build()
+
+        transactionPromise = promise
+
+        when (judo.paymentWidgetType) {
+          PaymentWidgetType.CARD_PAYMENT -> manager.paymentWithToken(details, JudoKitReactNativeModule::class.java.name)
+          PaymentWidgetType.PRE_AUTH -> manager.preAuthWithToken(details, JudoKitReactNativeModule::class.java.name)
+          else ->
+            promise.reject(
+              JUDO_PROMISE_REJECTION_CODE,
+              "${judo.paymentWidgetType.name} payment widget type is not valid for token transactions",
+            )
+        }
+      } catch (exception: Exception) {
+        promise.reject(exception)
+      }
+    }
+
+    @ReactMethod
+    fun fetchTransactionDetails(
+      options: ReadableMap,
+      promise: Promise,
+    ) {
+      try {
+        val judo = getJudoConfigurationForApiService(options)
+        val receiptId = options.receiptId ?: ""
+
+        val service = JudoApiServiceFactory.create(reactContext, judo)
+
+        val fetchTransactionDetailsCallback =
+          object : Callback<JudoApiCallResult<Receipt>> {
+            override fun onResponse(
+              call: Call<JudoApiCallResult<Receipt>>,
+              response: Response<JudoApiCallResult<Receipt>>,
+            ) {
+              when (val result = response.body()) {
+                is JudoApiCallResult.Success -> {
+                  val receipt = result.data
+                  if (receipt != null) {
+                    val judoResult = receipt.toJudoResult()
+                    promise.resolve(getMappedResult(judoResult))
+                  } else {
+                    promise.reject(JUDO_PROMISE_REJECTION_CODE, REQUEST_FAILED_MESSAGE)
+                  }
+                }
+                is JudoApiCallResult.Failure -> {
+                  val message = result.error?.message ?: REQUEST_FAILED_MESSAGE
+                  promise.reject(JUDO_PROMISE_REJECTION_CODE, message)
+                }
+                else -> {
+                  promise.reject(JUDO_PROMISE_REJECTION_CODE, REQUEST_FAILED_MESSAGE)
+                }
+              }
+            }
+
+            override fun onFailure(
+              call: Call<JudoApiCallResult<Receipt>>,
+              throwable: Throwable,
+            ) {
+              promise.reject(JUDO_PROMISE_REJECTION_CODE, throwable.localizedMessage, throwable)
+            }
+          }
+
+        service
+          .fetchTransactionWithReceiptId(receiptId)
+          .enqueue(fetchTransactionDetailsCallback)
+      } catch (error: Exception) {
+        promise.reject(JUDO_PROMISE_REJECTION_CODE, error.localizedMessage, error)
+      }
+    }
+
+    private fun ensureIsSubscribedToCardTransactionResults() {
+      if (isSubscribedToCardTransactionResults) {
+        return
+      }
+
+      val activity = reactContext.currentActivity
+      activity?.let {
+        isSubscribedToCardTransactionResults = true
+        CardTransactionManager.getInstance(activity as FragmentActivity).registerResultListener(this)
+      }
+    }
+
+    private fun unsubscribeFromCardTransactionResults() {
+      val activity = reactContext.currentActivity
+      activity?.let {
+        isSubscribedToCardTransactionResults = false
+        CardTransactionManager.getInstance(activity as FragmentActivity).unRegisterResultListener(this)
+      }
+    }
+
+    override fun initialize() {
+      super.initialize()
+      ensureIsSubscribedToCardTransactionResults()
+    }
+
+    override fun invalidate() {
+      super.invalidate()
+      unsubscribeFromCardTransactionResults()
+    }
+
+    override fun onCardTransactionResult(result: JudoPaymentResult) {
+      transactionPromise?.let {
+        if (result is JudoPaymentResult.Success) {
+          it.resolve(getMappedResult(result.result))
+        } else {
+          val message =
+            when (result) {
+              is JudoPaymentResult.Error -> result.error.message
+              is JudoPaymentResult.UserCancelled -> result.error.message
+              else -> "The transaction was unsuccessful"
+            }
+          it.reject(JUDO_PROMISE_REJECTION_CODE, message)
+        }
+      }
+    }
+
+    private fun startJudoActivity(
+      configuration: Judo,
+      promise: Promise,
+    ) = currentActivity?.let {
+      listener.transactionPromise = promise
+      val intent = configuration.toJudoActivityIntent(it)
+      it.startActivityForResult(intent, JUDO_PAYMENT_WIDGET_REQUEST_CODE)
+    }
+  }

package/android/src/main/java/com/judopay/judokit/reactnative/JudoKitReactNativePackage.kt

@@ -0,0 +1,16 @@
+package com.judopay.judokit.reactnative
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class JudoKitReactNativePackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf(JudoKitReactNativeModule(reactContext))
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return emptyList()
+  }
+}

package/ios/{Classes/Extensions → Extensions}/NSDictionary+JudoConvert.h

@@ -1,6 +1,6 @@
 //
 //  NSDictionary+JudoConvert.h
-//  RNJudo
+//  JudoKitReactNative
 //
 //  Copyright (c) 2020 Alternative Payments Ltd
 //

package/ios/{Classes/Extensions → Extensions}/NSDictionary+JudoConvert.m

@@ -1,6 +1,6 @@
 //
 //  NSDictionary+JudoConvert.m
-//  RNJudo
+//  JudoKitReactNative
 //
 //  Copyright (c) 2020 Alternative Payments Ltd
 //
@@ -97,7 +97,7 @@
 
 - (nonnull NSString *)hexColorForKey:(nonnull NSString *)key {
     id object = [self stringForKey:key];
-    
+
     NSString *regexPattern = @"#[A-Fa-f0-9]{6}$";
     NSRegularExpression *regex = [NSRegularExpression regularExpressionWithPattern:regexPattern options:0 error:nil];
     if ([regex matchesInString:object options:NSMatchingAnchored range:NSMakeRange(0, [object length])].count) {

package/ios/{Classes/Extensions → Extensions}/NSException+JudoValidationExceptions.h

@@ -1,6 +1,6 @@
 //
 //  NSException+JudoValidationExceptions.h
-//  RNJudo
+//  JudoKitReactNative
 //
 //  Copyright (c) 2020 Alternative Payments Ltd
 //

package/ios/{Classes/Extensions → Extensions}/NSException+JudoValidationExceptions.m

@@ -1,6 +1,6 @@
 //
 //  NSException+JudoValidationExceptions.h
-//  RNJudo
+//  JudoKitReactNative
 //
 //  Copyright (c) 2020 Alternative Payments Ltd
 //

package/ios/{Classes/Extensions → Extensions}/UIColor+RNAdditions.h

@@ -1,6 +1,6 @@
 //
 //  UIColor+Additions.m
-//  RNJudo
+//  JudoKitReactNative
 //
 //  Copyright (c) 2020 Alternative Payments Ltd
 //

package/ios/{Classes/Extensions → Extensions}/UIColor+RNAdditions.m

@@ -1,6 +1,6 @@
 //
 //  UIColor+Additions.m
-//  RNJudo
+//  JudoKitReactNative
 //
 //  Copyright (c) 2020 Alternative Payments Ltd
 //
@@ -22,8 +22,8 @@
 //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 //  SOFTWARE.
 
-#import <UIKit/UIKit.h>
 #import "UIColor+RNAdditions.h"
+#import <UIKit/UIKit.h>
 
 @implementation UIColor (RNAdditions)
 
@@ -35,7 +35,7 @@
     NSScanner *scanner = [NSScanner scannerWithString:hexString];
     [scanner setScanLocation:1]; // bypass '#' character
     [scanner scanHexInt:&rgbValue];
-    return [UIColor colorWithRed:((rgbValue & 0xFF0000) >> 16)/255.0 green:((rgbValue & 0xFF00) >> 8)/255.0 blue:(rgbValue & 0xFF)/255.0 alpha:1.0];
+    return [UIColor colorWithRed:((rgbValue & 0xFF0000) >> 16) / 255.0 green:((rgbValue & 0xFF00) >> 8) / 255.0 blue:(rgbValue & 0xFF) / 255.0 alpha:1.0];
 }
 
 @end

package/ios/{Classes/RNJudo.h → JudoKitReactNative.h}

@@ -1,8 +1,8 @@
 //
-//  RNJudo.h
-//  RNJudo
+//  JudoKitReactNative.h
+//  JudoKitReactNative
 //
-//  Copyright (c) 2020 Alternative Payments Ltd
+//  Copyright (c) 2024 Alternative Payments Ltd
 //
 //  Permission is hereby granted, free of charge, to any person obtaining a copy
 //  of this software and associated documentation files (the "Software"), to deal
@@ -22,10 +22,16 @@
 //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 //  SOFTWARE.
 
-#import <React/RCTBridgeModule.h>
-
 static const NSErrorDomain _Nonnull RNJudoErrorDomain = @"com.judopay.react-native.error-domain";
 
-@interface RNJudo : NSObject <RCTBridgeModule>
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "RNJudoKitReactNativeSpec.h"
+
+@interface JudoKitReactNative : NSObject <NativeJudoKitReactNativeSpec>
+#else
+#import <React/RCTBridgeModule.h>
+
+@interface JudoKitReactNative : NSObject <RCTBridgeModule>
+#endif
 
 @end

package/ios/{Classes/RNJudo.m → JudoKitReactNative.mm}

@@ -1,8 +1,8 @@
 //
-//  RNJudo.m
-//  RNJudo
+//  JudoKitReactNative.m
+//  JudoKitReactNative
 //
-//  Copyright (c) 2020 Alternative Payments Ltd
+//  Copyright (c) 2024 Alternative Payments Ltd
 //
 //  Permission is hereby granted, free of charge, to any person obtaining a copy
 //  of this software and associated documentation files (the "Software"), to deal
@@ -22,112 +22,89 @@
 //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 //  SOFTWARE.
 
-#import <JudoKit-iOS/JudoKit_iOS.h>
-#import <JudoKit-iOS/JPError+Additions.h>
-
-#import "RNJudo.h"
-#import "RNWrappers.h"
+#import "JudoKitReactNative.h"
 #import "RNApplePayWrappers.h"
+#import "RNWrappers.h"
+#import <JudoKit-iOS/JPError+Additions.h>
+#import <JudoKit-iOS/JudoKit_iOS.h>
 
 static NSString *kJudoPromiseRejectionCode = @"JUDO_ERROR";
 
 typedef NS_ENUM(NSUInteger, JudoSDKInvocationType) {
     JudoSDKInvocationTypeTransaction,
     JudoSDKInvocationTypeApplePay,
-    JudoSDKInvocationTypePBBA,
-    JudoSDKInvocationTypePaymentMethods
+    JudoSDKInvocationTypePaymentMethods,
+    JudoSDKInvocationTypeTokenTransaction
 };
 
-@interface RNJudo ()
+@interface JudoKitReactNative ()
 
 @property (nonatomic, strong) JudoKit *judoKit;
 @property (nonatomic, strong) JPApiService *apiService;
-@property (nonatomic, strong) JPCardTransactionService *transactionService;
 @property (nonatomic, strong) JPCompletionBlock completionBlock;
 
 @end
 
-@implementation RNJudo
-
-RCT_EXPORT_MODULE();
+@implementation JudoKitReactNative
+RCT_EXPORT_MODULE()
 
 //----------------------------------------------
 // MARK: - SDK Methods
 //----------------------------------------------
 
-RCT_REMAP_METHOD(isBankingAppAvailable,
-                 isBankingAppAvailableWithResolver:(RCTPromiseResolveBlock)resolve
-                 rejecter:(RCTPromiseRejectBlock)reject) {
-    NSNumber *boolValue = [NSNumber numberWithBool:[JudoKit isBankingAppAvailable]];
-    resolve(boolValue);
-}
-
 RCT_REMAP_METHOD(isApplePayAvailableWithConfiguration,
-                 properties:(NSDictionary *)properties
-                 isApplePayAvailableWithResolver:(RCTPromiseResolveBlock)resolve
-                 rejecter:(RCTPromiseRejectBlock)reject) {
+                 properties : (NSDictionary *)properties
+                     isApplePayAvailableWithResolver : (RCTPromiseResolveBlock)resolve
+                         rejecter : (RCTPromiseRejectBlock)reject) {
     JPConfiguration *configuration = [RNWrappers configurationFromProperties:properties];
     NSNumber *boolValue = [NSNumber numberWithBool:[JudoKit isApplePayAvailableWithConfiguration:configuration]];
     resolve(boolValue);
 }
 
 RCT_REMAP_METHOD(invokeTransaction,
-                 properties:(NSDictionary *)properties
-                 invokePaymentWithResolver:(RCTPromiseResolveBlock)resolve
-                 rejecter:(RCTPromiseRejectBlock)reject) {
-    [self invokeSDKWithType:JudoSDKInvocationTypeTransaction withProperties:properties resolver:resolve andRejecter:reject];
+                 properties : (NSDictionary *)properties
+                     invokePaymentWithResolver : (RCTPromiseResolveBlock)resolve
+                         rejecter : (RCTPromiseRejectBlock)reject) {
+    [self invokeSDKWithType:JudoSDKInvocationTypeTransaction
+             withProperties:properties
+                   resolver:resolve
+                andRejecter:reject];
 }
 
 RCT_REMAP_METHOD(invokeApplePay,
-                 properties:(NSDictionary *)properties
-                 invokeApplePayWithResolver:(RCTPromiseResolveBlock)resolve
-                 rejecter:(RCTPromiseRejectBlock)reject) {
-    [self invokeSDKWithType:JudoSDKInvocationTypeApplePay withProperties:properties resolver:resolve andRejecter:reject];
-}
-
-RCT_REMAP_METHOD(invokePayByBankApp,
-                 properties:(NSDictionary *)properties
-                 invokePayByBankAppWithResolver:(RCTPromiseResolveBlock)resolve
-                 rejecter:(RCTPromiseRejectBlock)reject) {
-    [self invokeSDKWithType:JudoSDKInvocationTypePBBA withProperties:properties resolver:resolve andRejecter:reject];
+                 properties : (NSDictionary *)properties
+                     invokeApplePayWithResolver : (RCTPromiseResolveBlock)resolve
+                         rejecter : (RCTPromiseRejectBlock)reject) {
+    [self invokeSDKWithType:JudoSDKInvocationTypeApplePay
+             withProperties:properties
+                   resolver:resolve
+                andRejecter:reject];
 }
 
 RCT_REMAP_METHOD(invokePaymentMethodScreen,
-                 properties:(NSDictionary *)properties
-                 invokePaymentMethodScreenWithResolver:(RCTPromiseResolveBlock)resolve
-                 rejecter:(RCTPromiseRejectBlock)reject) {
-    [self invokeSDKWithType:JudoSDKInvocationTypePaymentMethods withProperties:properties resolver:resolve andRejecter:reject];
+                 properties : (NSDictionary *)properties
+                     invokePaymentMethodScreenWithResolver : (RCTPromiseResolveBlock)resolve
+                         rejecter : (RCTPromiseRejectBlock)reject) {
+    [self invokeSDKWithType:JudoSDKInvocationTypePaymentMethods
+             withProperties:properties
+                   resolver:resolve
+                andRejecter:reject];
 }
 
 RCT_REMAP_METHOD(performTokenTransaction,
-                 properties:(NSDictionary *)properties
-                 performTokenTransactionWithResolver:(RCTPromiseResolveBlock)resolve
-                 rejecter:(RCTPromiseRejectBlock)reject) {
-
-    self.transactionService = [RNWrappers cardTransactionServiceFromProperties:properties];
-    self.completionBlock = [self completionBlockWithResolve:resolve andReject:reject];
-
-    JPTransactionMode transactionMode = [RNWrappers transactionModeFromProperties:properties];
-    JPConfiguration *configuration = [RNWrappers configurationFromProperties:properties];
-    
-    JPCardTransactionDetails *details = [[JPCardTransactionDetails new] initWithConfiguration:configuration];
-    details.cardToken = [RNWrappers cardTokenFromProperties:properties];
-    details.securityCode = [RNWrappers securityCodeFromProperties:properties];
-    details.cardholderName = [RNWrappers cardholderNameFromProperties:properties];
-    details.cardType = [RNWrappers cardTypeFromProperties:properties];
-    
-    if (transactionMode == JPTransactionModePreAuth) {
-        [self.transactionService invokePreAuthTokenPaymentWithDetails:details andCompletion:self.completionBlock];
-        return;
-    }
-
-    [self.transactionService invokeTokenPaymentWithDetails:details andCompletion:self.completionBlock];
+                 properties : (NSDictionary *)properties
+                     performTokenTransactionWithResolver : (RCTPromiseResolveBlock)resolve
+                         rejecter : (RCTPromiseRejectBlock)reject) {
+    [self invokeSDKWithType:JudoSDKInvocationTypeTokenTransaction
+             withProperties:properties
+                   resolver:resolve
+                andRejecter:reject];
 }
 
 RCT_REMAP_METHOD(fetchTransactionDetails,
-                 properties:(NSDictionary *)properties
-                 fetchTransactionDetailsWithResolver:(RCTPromiseResolveBlock)resolve
-                 rejecter:(RCTPromiseRejectBlock)reject) {
+                 properties : (NSDictionary *)properties
+                     fetchTransactionDetailsWithResolver : (RCTPromiseResolveBlock)resolve
+                         rejecter : (RCTPromiseRejectBlock)reject) {
     @try {
         self.apiService = [RNWrappers apiServiceFromProperties:properties];
         self.completionBlock = [self completionBlockWithResolve:resolve andReject:reject];
@@ -160,24 +137,37 @@ RCT_REMAP_METHOD(fetchTransactionDetails,
         switch (invocationType) {
             case JudoSDKInvocationTypeTransaction: {
                 JPTransactionType type = [RNWrappers transactionTypeFromProperties:properties];
-                [self.judoKit invokeTransactionWithType:type configuration:configuration completion:self.completionBlock];
+                [self.judoKit invokeTransactionWithType:type
+                                          configuration:configuration
+                                             completion:self.completionBlock];
                 break;
             }
 
             case JudoSDKInvocationTypeApplePay: {
                 JPTransactionMode mode = [RNWrappers transactionModeFromProperties:properties];
-                [self.judoKit invokeApplePayWithMode:mode configuration:configuration completion:self.completionBlock];
+                [self.judoKit invokeApplePayWithMode:mode
+                                       configuration:configuration
+                                          completion:self.completionBlock];
                 break;
             }
 
-            case JudoSDKInvocationTypePBBA: {
-                [self.judoKit invokePBBAWithConfiguration:configuration completion:self.completionBlock];
+            case JudoSDKInvocationTypePaymentMethods: {
+                JPTransactionMode mode = [RNWrappers transactionModeFromProperties:properties];
+                [self.judoKit invokePaymentMethodScreenWithMode:mode
+                                                  configuration:configuration
+                                                     completion:self.completionBlock];
                 break;
             }
 
-            case JudoSDKInvocationTypePaymentMethods: {
+            case JudoSDKInvocationTypeTokenTransaction: {
+                JPCardTransactionDetails *details = [self transactionDetailsFromProperties:properties];
                 JPTransactionMode mode = [RNWrappers transactionModeFromProperties:properties];
-                [self.judoKit invokePaymentMethodScreenWithMode:mode configuration:configuration completion:self.completionBlock];
+                JPTransactionType type = mode == JPTransactionModePayment ? JPTransactionTypePayment : JPTransactionTypePreAuth;
+
+                [self.judoKit invokeTokenTransactionWithType:type
+                                               configuration:configuration
+                                                     details:details
+                                                  completion:self.completionBlock];
                 break;
             }
 
@@ -194,22 +184,35 @@ RCT_REMAP_METHOD(fetchTransactionDetails,
     }
 }
 
+- (JPCardTransactionDetails *)transactionDetailsFromProperties:(NSDictionary *)properties {
+    JPConfiguration *configuration = [RNWrappers configurationFromProperties:properties];
+
+    JPCardTransactionDetails *details = [[JPCardTransactionDetails new] initWithConfiguration:configuration];
+
+    details.cardToken = [RNWrappers cardTokenFromProperties:properties];
+    details.securityCode = [RNWrappers securityCodeFromProperties:properties];
+    details.cardholderName = [RNWrappers cardholderNameFromProperties:properties];
+    details.cardType = [RNWrappers cardTypeFromProperties:properties];
+
+    return details;
+}
+
 - (JPCompletionBlock)completionBlockWithResolve:(RCTPromiseResolveBlock)resolve
                                       andReject:(RCTPromiseRejectBlock)reject {
     return ^(JPResponse *response, NSError *error) {
         if (error) {
             if (error.code == JPError.userDidCancelError.code) {
-                reject(kJudoPromiseRejectionCode, @"Transaction cancelled",  error);
+                reject(kJudoPromiseRejectionCode, @"Transaction cancelled", error);
                 return;
             }
-            
+
             NSString *description = error.userInfo[NSLocalizedDescriptionKey];
             NSString *message = @"Transaction failed";
-            
+
             if (description && description.length > 0) {
                 message = description;
             }
-            
+
             // TODO: RCTJSErrorFromCodeMessageAndNSError expects an NSError instane in userInfo[NSUnderlyingErrorKey]
             // which in case of a 3DS SDK error is a NSString ('JP3DSSDKRuntimeException') - so it crashes
             // ! this should be fixed in JudoKit-iOS, and the folowing workaround removed ASAP
@@ -218,8 +221,7 @@ RCT_REMAP_METHOD(fetchTransactionDetails,
             NSError *myError = [[NSError alloc] initWithDomain:error.domain
                                                           code:error.code
                                                       userInfo:[NSDictionary dictionaryWithDictionary:userInfo]];
-            
-            
+
             reject(kJudoPromiseRejectionCode, message, myError);
         } else {
             NSDictionary *mappedResponse = [RNWrappers dictionaryFromResponse:response];

package/ios/{Classes/RNTypes.h → RNTypes.h}

@@ -1,6 +1,6 @@
 //
 //  RNTypes.h
-//  RNJudo
+//  JudoKitReactNative
 //
 //  Copyright (c) 2020 Alternative Payments Ltd
 //
@@ -28,7 +28,6 @@ typedef NS_OPTIONS(NSUInteger, IOSPaymentMethod) {
     IOSPaymentMethodCard = 1 << 0,
     IOSPaymentMethodApplePay = 1 << 1,
     IOSPaymentMethodIDEAL = 1 << 3,
-    IOSPaymentMethodPBBA = 1 << 4,
     IOSPaymentMethodAll = 1 << 5,
 };
 
@@ -73,3 +72,10 @@ typedef NS_ENUM(NSUInteger, IOSShippingType) {
     IOSShippingTypeServicePickup,
 };
 
+typedef NS_ENUM(NSUInteger, IOSCalendarUnit) {
+    IOSCalendarUnitYear = 1,
+    IOSCalendarUnitMonth,
+    IOSCalendarUnitDay,
+    IOSCalendarUnitHour,
+    IOSCalendarUnitMinute,
+};

package/ios/{Classes/Wrappers → Wrappers}/RNApplePayWrappers.h

@@ -1,6 +1,6 @@
 //
 //  RNApplePayWrappers.h
-//  RNJudo
+//  JudoKitReactNative
 //
 //  Copyright (c) 2020 Alternative Payments Ltd
 //