judokit-react-native 3.3.8 → 3.4.1

package/android/src/main/java/com/reactlibrary/JudoReactNativeModule.kt

@@ -15,9 +15,9 @@ import com.judopay.judokit.android.api.model.response.Receipt
 import com.judopay.judokit.android.api.model.response.toCardVerificationModel
 import com.judopay.judokit.android.api.model.response.toJudoPaymentResult
 import com.judopay.judokit.android.api.model.response.toJudoResult
-import com.judopay.judokit.android.model.JudoPaymentResult
-import com.judopay.judokit.android.model.JudoResult
-import com.judopay.judokit.android.model.PaymentWidgetType
+import com.judopay.judokit.android.model.*
+import com.judopay.judokit.android.service.CardTransactionManager
+import com.judopay.judokit.android.service.CardTransactionManagerResultListener
 import com.judopay.judokit.android.toTokenRequest
 import com.judopay.judokit.android.ui.cardverification.THREE_DS_ONE_DIALOG_FRAGMENT_TAG
 import com.judopay.judokit.android.ui.cardverification.ThreeDSOneCardVerificationDialogFragment
@@ -33,9 +33,10 @@ const val JUDO_PAYMENT_WIDGET_REQUEST_CODE = 65520
 const val JUDO_PROMISE_REJECTION_CODE = "JUDO_ERROR"
 
 class JudoReactNativeModule internal constructor(val context: ReactApplicationContext) :
-    ReactContextBaseJavaModule(context) {
+    ReactContextBaseJavaModule(context), CardTransactionManagerResultListener {
 
     private val listener = JudoReactNativeActivityEventListener()
+    internal var transactionPromise: Promise? = null
 
     /**
      * A broadcast receiver to catch Pay by Bank app /order/bank/sale response event.
@@ -106,62 +107,75 @@ class JudoReactNativeModule internal constructor(val context: ReactApplicationCo
     @ReactMethod
     fun performTokenTransaction(options: ReadableMap, promise: Promise) {
         try {
+            val activity = context.currentActivity as FragmentActivity
+            val manager = CardTransactionManager.getInstance(activity)
 
             val judo = getTokenTransactionConfiguration(options)
 
-            val service = JudoApiServiceFactory.createApiService(context, judo)
-
             val cardToken = options.cardToken
-            val securityCode = options.securityCode
 
             if (cardToken == null) {
                 promise.reject(JUDO_PROMISE_REJECTION_CODE, "No card token found")
                 return
             }
 
-            val tokenTransactionCallback = object : Callback<JudoApiCallResult<Receipt>> {
-
-                override fun onFailure(call: Call<JudoApiCallResult<Receipt>>, t: Throwable) {
-                    promise.reject(t)
-                }
-
-                override fun onResponse(call: Call<JudoApiCallResult<Receipt>>, response: Response<JudoApiCallResult<Receipt>>) {
-
-                    if (response.body() == null) {
-                        promise.reject(JUDO_PROMISE_REJECTION_CODE, "Response body is empty")
-                        return
-                    }
-
-                    when (val data = response.body()?.toJudoPaymentResult(context.resources)) {
-                        is JudoPaymentResult.Success -> {
-                            val receipt = (response.body() as JudoApiCallResult.Success).data
-                            if (receipt != null && receipt.is3dSecureRequired) {
-                                handleThreeDSAuthentication(promise, service, receipt)
-                            } else {
-                                promise.resolve(getMappedResult(receipt?.toJudoResult()))
-                            }
-                        }
-                        is JudoPaymentResult.Error -> {
-                            promise.reject(JUDO_PROMISE_REJECTION_CODE, data.error.message)
-                        }
-                        else -> {
-                            // noop
-                        }
-                    }
-                }
-            }
+            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 -> service.tokenPayment(judo.toTokenRequest(cardToken, securityCode)).enqueue(tokenTransactionCallback)
-                PaymentWidgetType.PRE_AUTH -> service.preAuthTokenPayment(judo.toTokenRequest(cardToken, securityCode)).enqueue(tokenTransactionCallback)
+                PaymentWidgetType.CARD_PAYMENT -> manager.paymentWithToken(details, JudoReactNativeModule::class.java.name)
+                PaymentWidgetType.PRE_AUTH -> manager.preAuthWithToken(details, JudoReactNativeModule::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)
         }
     }
 
+    override fun initialize() {
+        super.initialize()
+
+        val activity =  context.currentActivity as FragmentActivity
+        CardTransactionManager.getInstance(activity).registerResultListener(this)
+    }
+
+    override fun invalidate() {
+        super.invalidate()
+
+        val activity =  context.currentActivity as FragmentActivity
+        CardTransactionManager.getInstance(activity).unRegisterResultListener(this)
+    }
+
+    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)
+            }
+        }
+    }
+
     @ReactMethod
     fun isBankingAppAvailable(promise: Promise) {
         try {
@@ -176,40 +190,4 @@ class JudoReactNativeModule internal constructor(val context: ReactApplicationCo
         val intent = configuration.toJudoActivityIntent(it)
         it.startActivityForResult(intent, JUDO_PAYMENT_WIDGET_REQUEST_CODE)
     }
-
-    private fun handleThreeDSAuthentication(promise: Promise, service: JudoApiService, receipt: Receipt) {
-        val callback = object : ThreeDSOneCompletionCallback {
-            override fun onSuccess(success: JudoPaymentResult) {
-                handleSuccessfulThreeDSTransaction(success, promise)
-            }
-
-            override fun onFailure(error: JudoPaymentResult) {
-                handleFailedThreeDSTransaction(error, promise)
-            }
-        }
-
-        val fragment = ThreeDSOneCardVerificationDialogFragment(
-                service,
-                receipt.toCardVerificationModel(),
-                callback
-        )
-        fragment.show((context.currentActivity as FragmentActivity).supportFragmentManager, THREE_DS_ONE_DIALOG_FRAGMENT_TAG)
-    }
-
-    private fun handleFailedThreeDSTransaction(error: JudoPaymentResult, promise: Promise) {
-        val message = when (error) {
-            is JudoPaymentResult.Error -> error.error.message
-            is JudoPaymentResult.UserCancelled -> error.error.message
-            else -> "The transaction was unsuccessful"
-        }
-        promise.reject(JUDO_PROMISE_REJECTION_CODE, message)
-    }
-
-    private fun handleSuccessfulThreeDSTransaction(success: JudoPaymentResult, promise: Promise) {
-        if (success is JudoPaymentResult.Success) {
-            promise.resolve(getMappedResult(success.result))
-        } else {
-            promise.reject(JUDO_PROMISE_REJECTION_CODE, "Unknown error occured")
-        }
-    }
 }

package/ios/Classes/RNJudo.m

@@ -42,7 +42,7 @@ typedef NS_ENUM(NSUInteger, JudoSDKInvocationType) {
 
 @property (nonatomic, strong) JudoKit *judoKit;
 @property (nonatomic, strong) JPApiService *apiService;
-@property (nonatomic, strong) JP3DSService *threeDSService;
+@property (nonatomic, strong) JPCardTransactionService *transactionService;
 @property (nonatomic, strong) JPCompletionBlock completionBlock;
 
 @end
@@ -104,31 +104,24 @@ RCT_REMAP_METHOD(performTokenTransaction,
                  performTokenTransactionWithResolver:(RCTPromiseResolveBlock)resolve
                  rejecter:(RCTPromiseRejectBlock)reject) {
 
-    self.apiService = [RNWrappers apiServiceFromProperties:properties];
-    self.threeDSService = [[JP3DSService alloc] initWithApiService:self.apiService];
+    self.transactionService = [RNWrappers cardTransactionServiceFromProperties:properties];
     self.completionBlock = [self completionBlockWithResolve:resolve andReject:reject];
 
     JPTransactionMode transactionMode = [RNWrappers transactionModeFromProperties:properties];
     JPConfiguration *configuration = [RNWrappers configurationFromProperties:properties];
-
-    NSString *cardToken = [RNWrappers cardTokenFromProperties:properties];
-    JPTokenRequest *tokenRequest = [[JPTokenRequest alloc] initWithConfiguration:configuration
-                                                                    andCardToken:cardToken];
-
-    __weak typeof(self) weakSelf = self;
-
+    
+    JPCardTransactionDetails *details = [[JPCardTransactionDetails new] initWithConfiguration:configuration];
+    details.cardToken = [RNWrappers cardTokenFromProperties:properties];
+    details.secureCode = [RNWrappers securityCodeFromProperties:properties];
+    details.cardholderName = [RNWrappers cardholderNameFromProperties:properties];
+    details.cardType = [RNWrappers cardTypeFromProperties:properties];
+    
     if (transactionMode == JPTransactionModePreAuth) {
-        [self.apiService invokePreAuthTokenPaymentWithRequest:tokenRequest
-                                                andCompletion:^(JPResponse *response, JPError *error) {
-            [weakSelf handleResponse:response andError:error];
-        }];
+        [self.transactionService invokePreAuthTokenPaymentWithDetails:details andCompletion:self.completionBlock];
         return;
     }
 
-    [self.apiService invokeTokenPaymentWithRequest:tokenRequest
-                                     andCompletion:^(JPResponse *response, JPError *error) {
-        [weakSelf handleResponse:response andError:error];
-    }];
+    [self.transactionService invokeTokenPaymentWithDetails:details andCompletion:self.completionBlock];
 }
 
 RCT_REMAP_METHOD(fetchTransactionDetails,
@@ -191,46 +184,27 @@ RCT_REMAP_METHOD(fetchTransactionDetails,
         NSError *error = [[NSError alloc] initWithDomain:RNJudoErrorDomain
                                                     code:0
                                                 userInfo:exception.userInfo];
-
         reject(kJudoPromiseRejectionCode, exception.reason, error);
     }
 }
 
-- (void)handleResponse:(JPResponse *)response andError:(JPError *)error {
-
-    if (error.code != Judo3DSRequestError) {
-        self.completionBlock(response, error);
-        return;
-    }
-
-    JP3DSConfiguration *configuration = [JP3DSConfiguration configurationWithError:error];
-    [self.threeDSService invoke3DSecureWithConfiguration:configuration completion:self.completionBlock];
-}
-
-//----------------------------------------------
-// MARK: - React Native methods
-//----------------------------------------------
-
-- (dispatch_queue_t)methodQueue {
-    return dispatch_get_main_queue();
-}
-
-+ (BOOL)requiresMainQueueSetup {
-    return YES;
-}
-
 - (JPCompletionBlock)completionBlockWithResolve:(RCTPromiseResolveBlock)resolve
                                       andReject:(RCTPromiseRejectBlock)reject {
-
     return ^(JPResponse *response, NSError *error) {
         if (error) {
-
             if (error.code == JPError.judoUserDidCancelError.code) {
                 reject(kJudoPromiseRejectionCode, @"Transaction cancelled",  error);
                 return;
             }
-
-            reject(kJudoPromiseRejectionCode, @"Transaction failed",  error);
+            
+            NSString *description = error.userInfo[NSLocalizedDescriptionKey];
+            NSString *message = @"Transaction failed";
+            
+            if (description && description.length > 0) {
+                message = description;
+            }
+            
+            reject(kJudoPromiseRejectionCode, message, error);
         } else {
             NSDictionary *mappedResponse = [RNWrappers dictionaryFromResponse:response];
             resolve(mappedResponse);
@@ -238,4 +212,16 @@ RCT_REMAP_METHOD(fetchTransactionDetails,
     };
 }
 
+//----------------------------------------------
+// MARK: - React Native methods
+//----------------------------------------------
+
+- (dispatch_queue_t)methodQueue {
+    return dispatch_get_main_queue();
+}
+
++ (BOOL)requiresMainQueueSetup {
+    return YES;
+}
+
 @end

package/ios/Classes/Wrappers/RNWrappers.h

@@ -46,6 +46,10 @@
  */
 + (JPApiService *)apiServiceFromProperties:(NSDictionary *)properties;
 
++ (JPCardTransactionService *)cardTransactionServiceFromProperties:(NSDictionary *)properties;
+
++ (id<JPAuthorization>)authorizationFromProperties:(NSDictionary *)properties;
+
 /**
  * A method that returns the correct TransactionType value based on the passed dictionary parameters
  * TransactionType is set to switch between Payment, PreAuth, Register Card, Check Card and Save Card transactions
@@ -96,6 +100,12 @@
 */
 + (NSString *)cardTokenFromProperties:(NSDictionary *)properties;
 
++ (NSString *)securityCodeFromProperties:(NSDictionary *)properties;
+
++ (NSString *)cardholderNameFromProperties:(NSDictionary *)properties;
+
++ (JPCardNetworkType)cardTypeFromProperties:(NSDictionary *)properties;
+
 /**
 * A method that returns the receipt ID contained in the properties dictionary
 *

package/ios/Classes/Wrappers/RNWrappers.m

@@ -29,6 +29,10 @@
 #import "NSDictionary+JudoConvert.h"
 #import "UIColor+RNAdditions.h"
 
+static NSString *const kCardSchemeVISA = @"visa";
+static NSString *const kCardSchemeMasterCard = @"mastercard";
+static NSString *const kCardSchemeAMEX = @"amex";
+
 @implementation RNWrappers
 
 //---------------------------------------------------
@@ -36,50 +40,46 @@
 //---------------------------------------------------
 
 + (JudoKit *)judoSessionFromProperties:(NSDictionary *)properties {
-
-    NSDictionary *authorizationDict = [properties dictionaryForKey:@"authorization"];
-
-    NSString *token = [authorizationDict stringForKey:@"token"];
-    NSString *secret = [authorizationDict optionalStringForKey:@"secret"];
-    NSString *paymentSession = [authorizationDict optionalStringForKey:@"paymentSession"];
-
-    JudoKit *judoKit;
-
-    if (secret) {
-        JPBasicAuthorization *authorization = [JPBasicAuthorization authorizationWithToken:token
-                                                                                 andSecret:secret];
-        judoKit = [[JudoKit alloc] initWithAuthorization:authorization];
-    } else {
-        JPSessionAuthorization *authorization = [JPSessionAuthorization authorizationWithToken:token
-                                                                             andPaymentSession:paymentSession];
-        judoKit = [[JudoKit alloc] initWithAuthorization:authorization];
-    }
-
-    NSNumber *isSandboxed = [properties boolForKey:@"sandboxed"];
-    judoKit.isSandboxed = isSandboxed.boolValue;
-
+    id<JPAuthorization> authorization = [RNWrappers authorizationFromProperties:properties];
+    JudoKit *judoKit = [[JudoKit alloc] initWithAuthorization:authorization];
+    judoKit.isSandboxed = [RNWrappers isSandboxedFromProperties:properties];
     return judoKit;
 }
 
 + (JPApiService *)apiServiceFromProperties:(NSDictionary *)properties {
+    BOOL isSandboxed = [RNWrappers isSandboxedFromProperties:properties];
+    id<JPAuthorization> authorization = [RNWrappers authorizationFromProperties:properties];
+
+    return [[JPApiService alloc] initWithAuthorization:authorization isSandboxed:isSandboxed];
+}
 
++ (id<JPAuthorization>)authorizationFromProperties:(NSDictionary *)properties {
     NSDictionary *authorizationDict = [properties dictionaryForKey:@"authorization"];
 
     NSString *token = [authorizationDict stringForKey:@"token"];
     NSString *secret = [authorizationDict optionalStringForKey:@"secret"];
     NSString *paymentSession = [authorizationDict optionalStringForKey:@"paymentSession"];
+    
+    if (secret) {
+        return [JPBasicAuthorization authorizationWithToken:token andSecret:secret];
+    }
 
+    return [JPSessionAuthorization authorizationWithToken:token andPaymentSession:paymentSession];
+}
+
++ (BOOL)isSandboxedFromProperties:(NSDictionary *)properties {
     NSNumber *isSandboxed = [properties boolForKey:@"sandboxed"];
+    return isSandboxed.boolValue;
+}
 
-    if (secret) {
-        JPBasicAuthorization *authorization = [JPBasicAuthorization authorizationWithToken:token
-                                                                                 andSecret:secret];
-        return [[JPApiService alloc] initWithAuthorization:authorization isSandboxed:isSandboxed.boolValue];
-    }
++ (JPCardTransactionService *)cardTransactionServiceFromProperties:(NSDictionary *)properties {
+    BOOL isSandboxed = [RNWrappers isSandboxedFromProperties:properties];
+    id<JPAuthorization> authorization = [RNWrappers authorizationFromProperties:properties];
+    JPConfiguration *configuration = [RNWrappers configurationFromProperties:properties];
 
-    JPSessionAuthorization *authorization = [JPSessionAuthorization authorizationWithToken:token
-                                                                         andPaymentSession:paymentSession];
-    return [[JPApiService alloc] initWithAuthorization:authorization isSandboxed:isSandboxed.boolValue];
+    return [[JPCardTransactionService alloc] initWithAuthorization:authorization
+                                                       isSandboxed:isSandboxed
+                                                  andConfiguration:configuration];
 }
 
 + (JPTransactionType)transactionTypeFromProperties:(NSDictionary *)properties {
@@ -107,6 +107,22 @@
     return availableModes[intType].intValue;
 }
 
++ (JPNetworkTimeout *)networkTimeoutFromProperties:(NSDictionary *)properties {
+    NSDictionary *networkTimeout = [properties optionalDictionaryForKey:@"networkTimeout"];
+
+    if (!networkTimeout) {
+        return nil;
+    }
+
+    NSTimeInterval connectTimeout = [networkTimeout numberForKey:@"connectTimeout"].doubleValue;
+    NSTimeInterval readTimeout = [networkTimeout numberForKey:@"readTimeout"].doubleValue;
+    NSTimeInterval writeTimeout = [networkTimeout numberForKey:@"writeTimeout"].doubleValue;
+
+    return [[JPNetworkTimeout alloc] initWithConnectTimeout:connectTimeout
+                                             andReadTimeout:readTimeout
+                                            andWriteTimeout:writeTimeout];
+}
+
 + (JPConfiguration *)configurationFromProperties:(NSDictionary *)properties {
 
     NSDictionary *configurationDict = [properties dictionaryForKey:@"configuration"];
@@ -129,7 +145,36 @@
     configuration.paymentMethods = [RNWrappers paymentMethodsFromConfiguration:configurationDict];
     configuration.applePayConfiguration = [RNApplePayWrappers applePayConfigurationFromConfiguration:configurationDict];
     configuration.pbbaConfiguration = [RNPBBAWrappers pbbaConfigurationFromConfiguration:configurationDict];
+    configuration.networkTimeout = [RNWrappers networkTimeoutFromProperties:configurationDict];
+        
+    NSString *scaExemption = [configurationDict optionalStringForKey:@"scaExemption"];
+    NSString *challengeRequestIndicator = [configurationDict optionalStringForKey:@"challengeRequestIndicator"];
+    NSString *mobileNumber = [configurationDict optionalStringForKey:@"mobileNumber"];
+    NSString *emailAddress = [configurationDict optionalStringForKey:@"emailAddress"];
+    NSString *threeDSTwoMessageVersion = [configurationDict optionalStringForKey:@"threeDSTwoMessageVersion"];
+    NSNumber *threeDSTwoMaxTimeout = [configurationDict optionalNumberForKey:@"threeDSTwoMaxTimeout"];
+    NSString *phoneCountryCode = [configurationDict optionalStringForKey:@"phoneCountryCode"];
+
+    configuration.mobileNumber = mobileNumber;
+    configuration.emailAddress = emailAddress;
+    configuration.phoneCountryCode = phoneCountryCode;
+
+    if (scaExemption) {
+        configuration.scaExemption = scaExemption;
+    }
+
+    if (challengeRequestIndicator) {
+        configuration.challengeRequestIndicator = challengeRequestIndicator;
+    }
+    
+    if (threeDSTwoMessageVersion) {
+        configuration.threeDSTwoMessageVersion = threeDSTwoMessageVersion;
+    }
 
+    if (threeDSTwoMaxTimeout) {
+        configuration.threeDSTwoMaxTimeout = threeDSTwoMaxTimeout.intValue;
+    }
+    
     return configuration;
 }
 
@@ -186,10 +231,36 @@
     return [properties optionalStringForKey:@"cardToken"];
 }
 
++ (NSString *)securityCodeFromProperties:(NSDictionary *)properties {
+    return [properties optionalStringForKey:@"securityCode"];
+}
+
++ (NSString *)cardholderNameFromProperties:(NSDictionary *)properties {
+    return [properties optionalStringForKey:@"cardholderName"];
+}
+
 + (NSString *)receiptIdFromProperties:(NSDictionary *)properties {
     return [properties optionalStringForKey:@"receiptId"];
 }
 
++ (JPCardNetworkType)cardTypeFromProperties:(NSDictionary *)properties {
+    NSString *cardScheme = [properties optionalStringForKey:@"cardScheme"].lowercaseString;
+    
+    if ([kCardSchemeVISA isEqualToString:cardScheme]) {
+        return JPCardNetworkTypeVisa;
+    }
+    
+    if ([kCardSchemeMasterCard isEqualToString:cardScheme]) {
+        return JPCardNetworkTypeMasterCard;
+    }
+    
+    if ([kCardSchemeAMEX isEqualToString:cardScheme]) {
+        return JPCardNetworkTypeAMEX;
+    }
+    
+    return JPCardNetworkTypeUnknown;
+}
+
 //---------------------------------------------------
 // MARK: - Helper methods
 //---------------------------------------------------
@@ -251,13 +322,13 @@
     if (!addressDictionary) {
         return nil;
     }
-
-    return [[JPAddress alloc] initWithLine1:[addressDictionary optionalStringForKey:@"line1"]
-                                      line2:[addressDictionary optionalStringForKey:@"line2"]
-                                      line3:[addressDictionary optionalStringForKey:@"line3"]
-                                       town:[addressDictionary optionalStringForKey:@"town"]
-                                countryCode:[addressDictionary optionalNumberForKey:@"countryCode"]
-                                   postCode:[addressDictionary optionalStringForKey:@"postCode"]];
+    
+    return [[JPAddress alloc] initWithAddress1:[addressDictionary optionalStringForKey:@"line1"]
+                                      address2:[addressDictionary optionalStringForKey:@"line2"]
+                                      address3:[addressDictionary optionalStringForKey:@"line3"]
+                                          town:[addressDictionary optionalStringForKey:@"town"]
+                                      postCode:[addressDictionary optionalStringForKey:@"postCode"]
+                                   countryCode:[addressDictionary optionalNumberForKey:@"countryCode"]];
 }
 
 + (JPUIConfiguration *)uiConfigurationFromConfiguration:(NSDictionary *)configuration {
@@ -274,12 +345,17 @@
     NSNumber *shouldDisplayAmount = [dictionary boolForKey:@"shouldPaymentMethodsDisplayAmount"];
     NSNumber *isPayButtonAmountVisible = [dictionary boolForKey:@"shouldPaymentButtonDisplayAmount"];
     NSNumber *isSecureCodeCheckEnabled = [dictionary boolForKey:@"shouldPaymentMethodsVerifySecurityCode"];
-
+    NSNumber *shouldAskForBillingInformation = [dictionary optionalBoolForKey:@"shouldAskForBillingInformation"];
+    
     uiConfiguration.isAVSEnabled = isAVSEnabled.boolValue;
     uiConfiguration.shouldPaymentMethodsDisplayAmount = shouldDisplayAmount.boolValue;
     uiConfiguration.shouldPaymentButtonDisplayAmount = isPayButtonAmountVisible.boolValue;
     uiConfiguration.shouldPaymentMethodsVerifySecurityCode = isSecureCodeCheckEnabled.boolValue;
-
+    
+    if (shouldAskForBillingInformation) {
+        uiConfiguration.shouldAskForBillingInformation = shouldAskForBillingInformation.boolValue;
+    }
+    
     uiConfiguration.theme = [self themeFromUIConfiguration:dictionary];
 
     return uiConfiguration;

package/ios/Podfile

@@ -16,10 +16,10 @@ pre_install do |installer|
 end
 
 target 'RNJudo' do
-  use_frameworks!
+  # use_frameworks!
 
   # Pods for RNJudo
-  pod "JudoKit-iOS", "2.4.6"
+  pod "JudoKit-iOS", "3.1.0"
   pod 'FBLazyVector', :path => "../node_modules/react-native/Libraries/FBLazyVector"
   pod 'FBReactNativeSpec', :path => "../node_modules/react-native/Libraries/FBReactNativeSpec"
   pod 'RCTRequired', :path => "../node_modules/react-native/Libraries/RCTRequired"

package/ios/Podfile.lock

@@ -1,6 +1,7 @@
 PODS:
   - boost-for-react-native (1.63.0)
-  - DeviceDNA (1.1.3)
+  - DeviceDNA (2.0.0):
+    - OpenSSL-Universal (~> 1.1.180)
   - DoubleConversion (1.1.6)
   - FBLazyVector (0.61.5)
   - FBReactNativeSpec (0.61.5):
@@ -20,10 +21,13 @@ PODS:
     - DoubleConversion
     - glog
   - glog (0.3.5)
-  - JudoKit-iOS (2.4.1):
-    - DeviceDNA
+  - Judo3DS2_iOS (1.0.1)
+  - JudoKit-iOS (3.0.2):
+    - DeviceDNA (~> 2.0.0)
+    - Judo3DS2_iOS (~> 1.0.1)
     - TrustKit
     - ZappMerchantLib
+  - OpenSSL-Universal (1.1.1700)
   - RCTRequired (0.61.5)
   - RCTTypeSafety (0.61.5):
     - FBLazyVector (= 0.61.5)
@@ -232,7 +236,7 @@ DEPENDENCIES:
   - FBReactNativeSpec (from `../node_modules/react-native/Libraries/FBReactNativeSpec`)
   - Folly (from `../node_modules/react-native/third-party-podspecs/Folly.podspec`)
   - glog (from `../node_modules/react-native/third-party-podspecs/glog.podspec`)
-  - JudoKit-iOS (= 2.4.1)
+  - JudoKit-iOS (= 3.0.2)
   - RCTRequired (from `../node_modules/react-native/Libraries/RCTRequired`)
   - RCTTypeSafety (from `../node_modules/react-native/Libraries/TypeSafety`)
   - React (from `../node_modules/react-native/`)
@@ -261,7 +265,9 @@ SPEC REPOS:
   trunk:
     - boost-for-react-native
     - DeviceDNA
+    - Judo3DS2_iOS
     - JudoKit-iOS
+    - OpenSSL-Universal
     - TrustKit
     - ZappMerchantLib
 
@@ -319,13 +325,15 @@ EXTERNAL SOURCES:
 
 SPEC CHECKSUMS:
   boost-for-react-native: 39c7adb57c4e60d6c5479dd8623128eb5b3f0f2c
-  DeviceDNA: c3d7ba1669cebf7965407e7022769e5a5eda8c35
+  DeviceDNA: 9ff289d1fb983937754b324fa0adade2081210c4
   DoubleConversion: 5805e889d232975c086db112ece9ed034df7a0b2
   FBLazyVector: aaeaf388755e4f29cd74acbc9e3b8da6d807c37f
   FBReactNativeSpec: 118d0d177724c2d67f08a59136eb29ef5943ec75
   Folly: 30e7936e1c45c08d884aa59369ed951a8e68cf51
   glog: 1f3da668190260b06b429bb211bfbee5cd790c28
-  JudoKit-iOS: 434ac818c35ce0fbc7bdd00b93516295d668b496
+  Judo3DS2_iOS: c1ccf49ecacddb4559a73fb7eae6e680e2355b21
+  JudoKit-iOS: 4a96c63d4cfb45bb1a68a1891b2ebaeaa8a46be1
+  OpenSSL-Universal: ee0a7a25f2042782e2df405e66db3e429198e392
   RCTRequired: b153add4da6e7dbc44aebf93f3cf4fcae392ddf1
   RCTTypeSafety: 9aa1b91d7f9310fc6eadc3cf95126ffe818af320
   React: b6a59ef847b2b40bb6e0180a97d0ca716969ac78
@@ -349,6 +357,6 @@ SPEC CHECKSUMS:
   Yoga: f2a7cd4280bfe2cca5a7aed98ba0eb3d1310f18b
   ZappMerchantLib: b14bc5814840426d351190309250347ca9b0983d
 
-PODFILE CHECKSUM: 526e525b881d62f956cd5e564abc0967fde91796
+PODFILE CHECKSUM: bd8176c4a34cb7668ac5120fb4a4145962a52c2c
 
-COCOAPODS: 1.10.1
+COCOAPODS: 1.11.3