@stripe/stripe-react-native 0.65.1 → 0.66.0

package/ios/Mappers+Checkout.swift

@@ -6,188 +6,332 @@
 //
 
 import Foundation
-@_spi(CheckoutSessionsPreview) import StripePaymentSheet
+@_spi(ReactNativeSDK) import StripePaymentSheet
 
 extension Mappers {
+
+    // MARK: - State & Session
+
     class func mapFromCheckoutState(_ state: Checkout.State) -> NSDictionary {
-        return [
+        [
             "status": state.isLoading ? "loading" : "loaded",
             "session": mapFromCheckoutSession(state.session),
         ]
     }
 
-    class func mapFromCheckoutSession(_ session: any Checkout.Session) -> NSDictionary {
+    class func mapFromCheckoutSession(_ session: Checkout.Session) -> NSDictionary {
         let result = NSMutableDictionary()
         result["id"] = session.id
-        result["paymentStatus"] = mapFromCheckoutPaymentStatus(session.paymentStatus)
         result["livemode"] = session.livemode
-        result["lineItems"] = session.lineItems.map(mapFromCheckoutLineItem)
-        result["shippingOptions"] = session.shippingOptions.map(mapFromCheckoutShippingOption)
-        result["discounts"] = session.discounts.map(mapFromCheckoutDiscount)
-
-        if let status = mapFromCheckoutStatus(session.status) {
-            result["status"] = status
+        result["lineItems"] = session.lineItems.map(mapFromLineItem)
+        result["shippingOptions"] = session.shippingOptions.map(mapFromShippingOption)
+        result["discountAmounts"] = session.discountAmounts.map(mapFromDiscountAmount)
+        result["currencyOptions"] = session.currencyOptions.map(mapFromCurrencyOption)
+        result["tax"] = mapFromTax(session.tax)
+
+        if let businessName = session.businessName {
+            result["businessName"] = businessName
         }
-
         if let currency = session.currency {
             result["currency"] = currency
         }
-
-        if let totals = session.totals {
-            result["totals"] = mapFromCheckoutTotals(totals)
+        if let email = session.email {
+            result["email"] = email
         }
-
-        if let customerId = session.customerId {
-            result["customerId"] = customerId
+        if let minorUnitsAmountDivisor = session.minorUnitsAmountDivisor {
+            result["minorUnitsAmountDivisor"] = minorUnitsAmountDivisor
         }
-
-        if let customerEmail = session.customerEmail {
-            result["customerEmail"] = customerEmail
+        if let status = session.status {
+            result["status"] = mapFromStatus(status)
+        }
+        if let total = session.total {
+            result["total"] = mapFromTotal(total)
+        }
+        if let shipping = session.shipping {
+            result["shipping"] = mapFromSelectedShipping(shipping)
         }
-
         if let billingAddress = session.billingAddress {
-            result["billingAddress"] = mapFromCheckoutAddressUpdate(billingAddress)
+            result["billingAddress"] = mapFromContactAddress(billingAddress)
         }
-
         if let shippingAddress = session.shippingAddress {
-            result["shippingAddress"] = mapFromCheckoutAddressUpdate(shippingAddress)
+            result["shippingAddress"] = mapFromContactAddress(shippingAddress)
         }
 
         return result
     }
 
-    class func mapFromCheckoutAddressUpdate(_ addressUpdate: Checkout.AddressUpdate) -> NSDictionary {
+    // MARK: - Amount
+
+    class func mapFromAmount(_ amount: Checkout.Amount) -> NSDictionary {
+        [
+            "amount": amount.amount,
+            "minorUnitsAmount": amount.minorUnitsAmount,
+        ]
+    }
+
+    class func mapFromDecimalAmount(_ decimalAmount: Checkout.DecimalAmount) -> NSDictionary {
+        [
+            "amount": decimalAmount.amount,
+            "minorUnitsAmount": NSDecimalNumber(decimal: decimalAmount.minorUnitsAmount).doubleValue,
+        ]
+    }
+
+    // MARK: - Status
+
+    class func mapFromStatus(_ status: Checkout.Status) -> NSDictionary {
         let result = NSMutableDictionary()
-        result["address"] = mapFromCheckoutAddress(addressUpdate.address)
+        result["type"] = mapFromStatusType(status.type)
 
-        if let name = addressUpdate.name {
-            result["name"] = name
+        if let paymentStatus = status.paymentStatus {
+            result["paymentStatus"] = mapFromPaymentStatus(paymentStatus)
         }
 
-        if let phone = addressUpdate.phone {
-            result["phone"] = phone
+        return result
+    }
+
+    private class func mapFromStatusType(_ type: Checkout.StatusType) -> String {
+        switch type {
+        case .open: return "open"
+        case .complete: return "complete"
+        case .expired: return "expired"
+        case .unknown: return "unknown"
+        @unknown default: return "unknown"
         }
+    }
 
-        return result
+    private class func mapFromPaymentStatus(_ paymentStatus: Checkout.PaymentStatus) -> String {
+        switch paymentStatus {
+        case .paid: return "paid"
+        case .unpaid: return "unpaid"
+        case .noPaymentRequired: return "noPaymentRequired"
+        case .unknown: return "unknown"
+        @unknown default: return "unknown"
+        }
     }
 
-    private class func mapFromCheckoutAddress(_ address: Checkout.Address) -> NSDictionary {
+    // MARK: - Total
+
+    class func mapFromTotal(_ total: Checkout.Total) -> NSDictionary {
+        [
+            "subtotal": mapFromAmount(total.subtotal),
+            "taxExclusive": mapFromAmount(total.taxExclusive),
+            "taxInclusive": mapFromAmount(total.taxInclusive),
+            "shippingRate": mapFromAmount(total.shippingRate),
+            "discount": mapFromAmount(total.discount),
+            "total": mapFromAmount(total.total),
+            "appliedBalance": mapFromAmount(total.appliedBalance),
+            "balanceAppliedToNextInvoice": total.balanceAppliedToNextInvoice,
+        ]
+    }
+
+    // MARK: - Tax
+
+    class func mapFromTax(_ tax: Checkout.Tax) -> NSDictionary {
         let result = NSMutableDictionary()
-        result["country"] = address.country
+        result["status"] = mapFromTaxStatus(tax.status)
 
-        if let line1 = address.line1 {
-            result["line1"] = line1
+        if let taxAmounts = tax.taxAmounts {
+            result["taxAmounts"] = taxAmounts.map(mapFromTaxAmount)
         }
 
-        if let line2 = address.line2 {
-            result["line2"] = line2
+        return result
+    }
+
+    private class func mapFromTaxStatus(_ status: Checkout.TaxStatus) -> String {
+        switch status {
+        case .ready: return "ready"
+        case .requiresShippingAddress: return "requiresShippingAddress"
+        case .requiresBillingAddress: return "requiresBillingAddress"
+        case .unknown: return "unknown"
+        @unknown default: return "unknown"
         }
+    }
 
-        if let city = address.city {
-            result["city"] = city
+    private class func mapFromTaxAmount(_ taxAmount: Checkout.TaxAmount) -> NSDictionary {
+        [
+            "amount": mapFromAmount(taxAmount.amount),
+            "inclusive": taxAmount.inclusive,
+            "displayName": taxAmount.displayName,
+        ]
+    }
+
+    // MARK: - Line Items
+
+    class func mapFromLineItem(_ lineItem: Checkout.LineItem) -> NSDictionary {
+        let result = NSMutableDictionary()
+        result["id"] = lineItem.id
+        result["name"] = lineItem.name
+        result["images"] = lineItem.images
+        result["quantity"] = lineItem.quantity
+        result["discountAmounts"] = lineItem.discountAmounts.map(mapFromDiscountAmount)
+        result["taxAmounts"] = lineItem.taxAmounts.map(mapFromTaxAmount)
+
+        if let description = lineItem.description {
+            result["description"] = description
+        }
+        if let unitAmount = lineItem.unitAmount {
+            result["unitAmount"] = mapFromAmount(unitAmount)
+        }
+        if let unitAmountDecimal = lineItem.unitAmountDecimal {
+            result["unitAmountDecimal"] = mapFromDecimalAmount(unitAmountDecimal)
+        }
+        if let subtotal = lineItem.subtotal {
+            result["subtotal"] = mapFromAmount(subtotal)
+        }
+        if let discount = lineItem.discount {
+            result["discount"] = mapFromAmount(discount)
+        }
+        if let taxExclusive = lineItem.taxExclusive {
+            result["taxExclusive"] = mapFromAmount(taxExclusive)
+        }
+        if let taxInclusive = lineItem.taxInclusive {
+            result["taxInclusive"] = mapFromAmount(taxInclusive)
+        }
+        if let total = lineItem.total {
+            result["total"] = mapFromAmount(total)
+        }
+        if let adjustableQuantity = lineItem.adjustableQuantity {
+            result["adjustableQuantity"] = mapFromAdjustableQuantity(adjustableQuantity)
         }
 
-        if let state = address.state {
-            result["state"] = state
+        return result
+    }
+
+    private class func mapFromAdjustableQuantity(_ adjustableQuantity: Checkout.AdjustableQuantity) -> NSDictionary {
+        [
+            "minimum": adjustableQuantity.minimum,
+            "maximum": adjustableQuantity.maximum,
+        ]
+    }
+
+    // MARK: - Shipping
+
+    class func mapFromShippingOption(_ shippingOption: Checkout.ShippingOption) -> NSDictionary {
+        let result = NSMutableDictionary()
+        result["id"] = shippingOption.id
+        result["amount"] = mapFromAmount(shippingOption.amount)
+        result["currency"] = shippingOption.currency
+
+        if let displayName = shippingOption.displayName {
+            result["displayName"] = displayName
+        }
+        if let deliveryEstimate = shippingOption.deliveryEstimate {
+            result["deliveryEstimate"] = mapFromDeliveryEstimate(deliveryEstimate)
         }
 
-        if let postalCode = address.postalCode {
-            result["postalCode"] = postalCode
+        return result
+    }
+
+    private class func mapFromDeliveryEstimate(_ estimate: Checkout.DeliveryEstimate) -> NSDictionary {
+        let result = NSMutableDictionary()
+
+        if let minimum = estimate.minimum {
+            result["minimum"] = mapFromDeliveryEstimateBound(minimum)
+        }
+        if let maximum = estimate.maximum {
+            result["maximum"] = mapFromDeliveryEstimateBound(maximum)
         }
 
         return result
     }
 
-    private class func mapFromCheckoutTotals(_ totals: Checkout.Totals) -> NSDictionary {
-        return [
-            "subtotal": totals.subtotal,
-            "total": totals.total,
-            "due": totals.due,
-            "discount": totals.discount,
-            "shipping": totals.shipping,
-            "tax": totals.tax,
+    private class func mapFromDeliveryEstimateBound(_ bound: Checkout.DeliveryEstimate.Bound) -> NSDictionary {
+        [
+            "unit": mapFromDeliveryEstimateUnit(bound.unit),
+            "value": bound.value,
         ]
     }
 
-    private class func mapFromCheckoutLineItem(_ lineItem: Checkout.LineItem) -> NSDictionary {
-        return [
-            "id": lineItem.id,
-            "name": lineItem.name,
-            "quantity": lineItem.quantity,
-            "unitAmount": lineItem.unitAmount,
-            "currency": lineItem.currency,
-        ]
+    private class func mapFromDeliveryEstimateUnit(_ unit: Checkout.DeliveryEstimate.Bound.Unit) -> String {
+        switch unit {
+        case .hour: return "hour"
+        case .day: return "day"
+        case .businessDay: return "businessDay"
+        case .week: return "week"
+        case .month: return "month"
+        case .unknown: return "unknown"
+        @unknown default: return "unknown"
+        }
     }
 
-    private class func mapFromCheckoutShippingOption(_ shippingOption: Checkout.ShippingOption) -> NSDictionary {
-        return [
-            "id": shippingOption.id,
-            "displayName": shippingOption.displayName,
-            "amount": shippingOption.amount,
-            "currency": shippingOption.currency,
+    class func mapFromSelectedShipping(_ selectedShipping: Checkout.SelectedShipping) -> NSDictionary {
+        [
+            "shippingOption": mapFromShippingOption(selectedShipping.shippingOption),
+            "taxAmounts": selectedShipping.taxAmounts.map(mapFromTaxAmount),
         ]
     }
 
-    private class func mapFromCheckoutDiscount(_ discount: Checkout.Discount) -> NSDictionary {
+    // MARK: - Discounts
+
+    class func mapFromDiscountAmount(_ discountAmount: Checkout.DiscountAmount) -> NSDictionary {
         let result = NSMutableDictionary()
-        result["coupon"] = mapFromCheckoutCoupon(discount.coupon)
-        result["amount"] = discount.amount
+        result["amount"] = mapFromAmount(discountAmount.amount)
+        result["displayName"] = discountAmount.displayName
 
-        if let promotionCode = discount.promotionCode {
+        if let promotionCode = discountAmount.promotionCode {
             result["promotionCode"] = promotionCode
         }
 
         return result
     }
 
-    private class func mapFromCheckoutCoupon(_ coupon: Checkout.Coupon) -> NSDictionary {
+    // MARK: - Currency Options
+
+    class func mapFromCurrencyOption(_ currencyOption: Checkout.CurrencyOption) -> NSDictionary {
         let result = NSMutableDictionary()
-        result["id"] = coupon.id
+        result["amount"] = mapFromAmount(currencyOption.amount)
+        result["currency"] = currencyOption.currency
 
-        if let name = coupon.name {
-            result["name"] = name
+        if let currencyConversion = currencyOption.currencyConversion {
+            result["currencyConversion"] = mapFromCurrencyConversion(currencyConversion)
         }
 
-        if let percentOff = coupon.percentOff {
-            result["percentOff"] = percentOff
-        }
+        return result
+    }
+
+    private class func mapFromCurrencyConversion(_ conversion: Checkout.CurrencyConversion) -> NSDictionary {
+        [
+            "fxRate": conversion.fxRate,
+            "sourceCurrency": conversion.sourceCurrency,
+        ]
+    }
+
+    // MARK: - Address
+
+    class func mapFromContactAddress(_ contactAddress: Checkout.ContactAddress) -> NSDictionary {
+        let result = NSMutableDictionary()
+        result["address"] = mapFromCheckoutAddress(contactAddress.address)
 
-        if let amountOff = coupon.amountOff {
-            result["amountOff"] = amountOff
+        if let name = contactAddress.name {
+            result["name"] = name
+        }
+        if let phone = contactAddress.phone {
+            result["phone"] = phone
         }
 
         return result
     }
 
-    private class func mapFromCheckoutStatus(_ status: Checkout.Status?) -> String? {
-        switch status {
-        case .open:
-            return "open"
-        case .complete:
-            return "complete"
-        case .expired:
-            return "expired"
-        case .unknown:
-            return "unknown"
-        case nil:
-            return nil
-        @unknown default:
-            return "unknown"
-        }
-    }
-
-    private class func mapFromCheckoutPaymentStatus(_ paymentStatus: Checkout.PaymentStatus) -> String {
-        switch paymentStatus {
-        case .paid:
-            return "paid"
-        case .unpaid:
-            return "unpaid"
-        case .noPaymentRequired:
-            return "noPaymentRequired"
-        case .unknown:
-            return "unknown"
-        @unknown default:
-            return "unknown"
+    private class func mapFromCheckoutAddress(_ address: Checkout.Address) -> NSDictionary {
+        let result = NSMutableDictionary()
+        result["country"] = address.country
+
+        if let line1 = address.line1 {
+            result["line1"] = line1
         }
+        if let line2 = address.line2 {
+            result["line2"] = line2
+        }
+        if let city = address.city {
+            result["city"] = city
+        }
+        if let state = address.state {
+            result["state"] = state
+        }
+        if let postalCode = address.postalCode {
+            result["postalCode"] = postalCode
+        }
+
+        return result
     }
 }

package/ios/Mappers.swift

@@ -3,7 +3,7 @@ import Stripe
 @_spi(ConfirmationTokensPublicPreview) import StripePayments
 #if canImport(StripeCryptoOnramp)
 @_spi(CryptoOnrampAlpha) import StripeCryptoOnramp
-@_spi(STP) import StripePaymentSheet
+@_spi(CryptoOnrampAlpha) import StripePaymentSheet
 #else
 import StripePaymentSheet
 #endif
@@ -1262,13 +1262,20 @@ class Mappers {
     class func mapToKycInfo(_ params: [String: Any]) throws -> KycInfo {
         let address = try mapOptionalKycAddress(params["address"])
         let dateOfBirth = try mapOptionalDateOfBirth(params["dateOfBirth"])
+        let nationalities = try mapOptionalNormalizedStringArray(
+            params["nationalities"],
+            field: "nationalities"
+        )
 
         return KycInfo(
             firstName: normalizedString(params["firstName"]),
             lastName: normalizedString(params["lastName"]),
             idNumber: normalizedString(params["idNumber"]),
             address: address,
-            dateOfBirth: dateOfBirth
+            dateOfBirth: dateOfBirth,
+            birthCountry: normalizedString(params["birthCountry"]),
+            birthCity: normalizedString(params["birthCity"]),
+            nationalities: nationalities
         )
     }
 
@@ -1295,6 +1302,18 @@ class Mappers {
             result["dateOfBirth"] = mapFromDateOfBirth(dateOfBirth)
         }
 
+        if let birthCountry = kycInfo.birthCountry {
+            result["birthCountry"] = birthCountry
+        }
+
+        if let birthCity = kycInfo.birthCity {
+            result["birthCity"] = birthCity
+        }
+
+        if let nationalities = kycInfo.nationalities {
+            result["nationalities"] = nationalities
+        }
+
         return result
     }
 
@@ -1336,6 +1355,48 @@ class Mappers {
         ]
     }
 
+    class func mapToComplianceIdentifier(_ params: [String: Any]) throws -> ComplianceIdentifier {
+        guard let type = normalizedString(params["type"]) else {
+            throw ComplianceIdentifierError.invalidField("type")
+        }
+
+        guard let value = normalizedString(params["value"]) else {
+            throw ComplianceIdentifierError.invalidField("value")
+        }
+
+        return ComplianceIdentifier(type: ComplianceIdentifierType(rawValue: type), value: value)
+    }
+
+    class func mapFromComplianceIdentifierRequirements(_ requirements: ComplianceIdentifierRequirements) -> [String: Any] {
+        [
+            "identifiers": requirements.identifiers.map(mapFromComplianceIdentifierRequirement),
+            "alternatives": requirements.alternatives.map(mapFromComplianceIdentifierAlternativeGroup),
+        ]
+    }
+
+    class func mapFromSubmitIdentifiersResult(_ result: SubmitIdentifiersResult) -> [String: Any] {
+        [
+            "valid": result.valid,
+            "identifiers": result.identifiers.map(mapFromComplianceIdentifierRequirement),
+            "alternatives": result.alternatives.map(mapFromComplianceIdentifierAlternativeGroup),
+            "invalidIdentifiers": result.invalidIdentifiers.map(\.rawValue),
+        ]
+    }
+
+    private class func mapFromComplianceIdentifierRequirement(_ requirement: ComplianceIdentifierRequirement) -> [String: String] {
+        [
+            "type": requirement.type.rawValue,
+            "regulation": requirement.regulation.rawValue,
+        ]
+    }
+
+    private class func mapFromComplianceIdentifierAlternativeGroup(_ group: ComplianceIdentifierAlternativeGroup) -> [String: [String]] {
+        [
+            "originalMissingIdentifiers": group.originalMissingIdentifiers.map(\.rawValue),
+            "alternativeMissingIdentifiers": group.alternativeMissingIdentifiers.map(\.rawValue),
+        ]
+    }
+
     private class func mapOptionalKycAddress(_ value: Any?) throws -> Address? {
         guard let value else {
             return nil
@@ -1380,6 +1441,29 @@ class Mappers {
         return nil
     }
 
+    private class func mapOptionalNormalizedStringArray(
+        _ value: Any?,
+        field: String
+    ) throws -> [String]? {
+        guard let value else {
+            return nil
+        }
+
+        guard let values = value as? [Any] else {
+            throw KycInfoError.invalidField(field)
+        }
+
+        let normalizedValues = try values.map { value in
+            guard let normalizedValue = normalizedString(value) else {
+                throw KycInfoError.invalidField(field)
+            }
+
+            return normalizedValue
+        }
+
+        return normalizedValues.isEmpty ? nil : normalizedValues
+    }
+
     private class func normalizedString(_ value: Any?) -> String? {
         guard let stringValue = value as? String else {
             return nil
@@ -1415,5 +1499,9 @@ class Mappers {
     enum KycInfoError: Swift.Error {
         case invalidField(String)
     }
+
+    enum ComplianceIdentifierError: Swift.Error {
+        case invalidField(String)
+    }
 #endif
 }

package/ios/NewArch/StripeCurrencySelectorElementComponentView.mm

@@ -41,6 +41,20 @@ using namespace facebook::react;
 {
   _view = [[StripeCurrencySelectorElementContainerView alloc] initWithFrame:self.frame];
   self.contentView = _view;
+
+  __weak __typeof(self) weakSelf = self;
+
+  _view.onHeightChange = ^(NSDictionary *event) {
+    __typeof(self) strongSelf = weakSelf;
+    if (!strongSelf || !strongSelf->_eventEmitter) {
+      return;
+    }
+    StripeCurrencySelectorElementEventEmitter::OnHeightChange emitterEvent = {
+      .height = [(NSNumber *)event[@"height"] doubleValue],
+    };
+    std::static_pointer_cast<const StripeCurrencySelectorElementEventEmitter>(strongSelf->_eventEmitter)
+        ->onHeightChange(std::move(emitterEvent));
+  };
 }
 
 - (void)updateProps:(const facebook::react::Props::Shared &)props

package/ios/OldArch/StripeSdkEventEmitterCompat.h

@@ -26,5 +26,6 @@
 - (void)emitOnCheckoutClientSecretRequested:(NSDictionary *)value;
 - (void)emitPaymentMethodMessagingElementDidUpdateHeight:(NSDictionary *)value;
 - (void)emitPaymentMethodMessagingElementConfigureResult:(NSDictionary *)value;
+- (void)emitCheckoutSessionDidChangeState:(NSDictionary *)value;
 @end
 

package/ios/OldArch/StripeSdkEventEmitterCompat.m

@@ -27,6 +27,7 @@
     @"onCheckoutClientSecretRequested",
     @"paymentMethodMessagingElementDidUpdateHeight",
     @"paymentMethodMessagingElementConfigureResult",
+    @"checkoutSessionDidChangeState",
   ];
 }
 
@@ -140,4 +141,9 @@
   [self sendEventWithName:@"paymentMethodMessagingElementConfigureResult" body:value];
 }
 
+- (void)emitCheckoutSessionDidChangeState:(NSDictionary *)value
+{
+  [self sendEventWithName:@"checkoutSessionDidChangeState" body:value];
+}
+
 @end

package/ios/PaymentOptionDisplayData+ReactNative.swift

@@ -6,7 +6,7 @@
 //
 
 import Foundation
-@_spi(EmbeddedPaymentElementPrivateBeta) import StripePaymentSheet
+import StripePaymentSheet
 
 extension EmbeddedPaymentElement.PaymentOptionDisplayData {
     /// Convert `PaymentOptionDisplayData` into a dictionary compatible with React Native bridge.

package/ios/PaymentSheetAppearance.swift

@@ -4,7 +4,7 @@
 //
 //  Created by Charles Cruzan on 5/11/22.
 //
-@_spi(EmbeddedPaymentElementPrivateBeta) import StripePaymentSheet
+import StripePaymentSheet
 
 internal class PaymentSheetAppearance {
     class func buildAppearanceFromParams(userParams: NSDictionary?) throws -> PaymentSheet.Appearance {

package/ios/StripeOnrampSdk.mm

@@ -65,6 +65,25 @@ RCT_EXPORT_METHOD(attachKycInfo:(nonnull NSDictionary *)info
   [StripeSdkImpl.shared attachKycInfo:info resolver:resolve rejecter:reject];
 }
 
+RCT_EXPORT_METHOD(retrieveMissingIdentifiers:(nonnull RCTPromiseResolveBlock)resolve
+                                      reject:(nonnull RCTPromiseRejectBlock)reject)
+{
+  [StripeSdkImpl.shared retrieveMissingIdentifiers:resolve rejecter:reject];
+}
+
+RCT_EXPORT_METHOD(submitIdentifiers:(nonnull NSArray *)identifiers
+                            resolve:(nonnull RCTPromiseResolveBlock)resolve
+                             reject:(nonnull RCTPromiseRejectBlock)reject)
+{
+  [StripeSdkImpl.shared submitIdentifiers:identifiers resolver:resolve rejecter:reject];
+}
+
+RCT_EXPORT_METHOD(presentCRSCARFDeclaration:(nonnull RCTPromiseResolveBlock)resolve
+                                     reject:(nonnull RCTPromiseRejectBlock)reject)
+{
+  [StripeSdkImpl.shared presentCRSCARFDeclaration:resolve rejecter:reject];
+}
+
 RCT_EXPORT_METHOD(presentKycInfoVerification:(NSDictionary *)updatedAddress
                                      resolve:(nonnull RCTPromiseResolveBlock)resolve
                                       reject:(nonnull RCTPromiseRejectBlock)reject)