framepayments-react-native 3.0.0 → 4.0.0

package/ios/ApplePayBridge.swift

@@ -0,0 +1,262 @@
+import Foundation
+import PassKit
+import React
+
+// Two-step Apple Pay bridge.
+//
+// `presentApplePay` opens the PassKit sheet, waits for the user to authorize a
+// payment, and resolves the JS promise with the resulting PKPayment token plus
+// billing / payer fields. PassKit's authorization completion handler is held
+// open at that point — the sheet stays up with its spinner — so JS can call
+// the Frame backend without flicker.
+//
+// JS finishes by calling `finishApplePay('success' | 'failure')`. We invoke
+// the stored completion handler with the matching status, and PassKit then
+// dismisses the sheet.
+//
+// User cancel: PassKit calls `paymentAuthorizationControllerDidFinish` without
+// first authorizing. We reject the in-flight `presentApplePay` promise with
+// USER_CANCELED. JS must NOT call finishApplePay in this branch — there is no
+// open completion handler.
+
+@objc(FrameApplePay)
+public class FrameApplePay: NSObject, PKPaymentAuthorizationControllerDelegate {
+
+  private var controller: PKPaymentAuthorizationController?
+  private var presentResolve: RCTPromiseResolveBlock?
+  private var presentReject: RCTPromiseRejectBlock?
+  private var authCompletion: ((PKPaymentAuthorizationResult) -> Void)?
+  private var didAuthorize = false
+
+  // MARK: - canMakeApplePay
+
+  @objc public func canMakeApplePay(_ resolve: @escaping RCTPromiseResolveBlock,
+                                     rejecter reject: @escaping RCTPromiseRejectBlock) {
+    let networks = Self.parseNetworks(nil)
+    resolve(PKPaymentAuthorizationController.canMakePayments(usingNetworks: networks))
+  }
+
+  // MARK: - presentApplePay
+
+  @objc public func presentApplePay(_ args: NSDictionary,
+                                     resolver resolve: @escaping RCTPromiseResolveBlock,
+                                     rejecter reject: @escaping RCTPromiseRejectBlock) {
+    DispatchQueue.main.async { [weak self] in
+      guard let self = self else {
+        reject("APPLE_PAY_BRIDGE_GONE", "Apple Pay bridge was deallocated.", nil)
+        return
+      }
+
+      if self.controller != nil {
+        reject("APPLE_PAY_BUSY", "An Apple Pay sheet is already presenting.", nil)
+        return
+      }
+
+      guard let merchantId = args["applePayMerchantId"] as? String, !merchantId.isEmpty else {
+        reject("APPLE_PAY_INVALID_ARGS", "applePayMerchantId is required.", nil)
+        return
+      }
+      // JS numbers cross the RN bridge as NSNumber (backed by Double). Reject
+      // fractional cents explicitly — silently truncating $12.34.56 to 1234
+      // cents would lose half a dollar without surfacing to the caller.
+      let amount: Int
+      if let n = args["amount"] as? NSNumber {
+        let d = n.doubleValue
+        guard d.truncatingRemainder(dividingBy: 1.0) == 0, d.isFinite else {
+          reject("APPLE_PAY_INVALID_ARGS", "amount must be an integer (cents).", nil)
+          return
+        }
+        amount = Int(d)
+      } else if let i = args["amount"] as? Int {
+        amount = i
+      } else {
+        reject("APPLE_PAY_INVALID_ARGS", "amount is required.", nil)
+        return
+      }
+      let currency = (args["currency"] as? String) ?? "USD"
+      let countryCode = (args["countryCode"] as? String) ?? "US"
+      let networks = Self.parseNetworks(args["supportedNetworks"] as? [String])
+
+      let request = PKPaymentRequest()
+      request.merchantIdentifier = merchantId
+      request.supportedNetworks = networks
+      request.merchantCapabilities = .threeDSecure
+      request.countryCode = countryCode
+      request.currencyCode = currency.uppercased()
+      request.requiredBillingContactFields = [.postalAddress, .name, .emailAddress]
+      request.paymentSummaryItems = [
+        PKPaymentSummaryItem(
+          label: "Total",
+          amount: NSDecimalNumber(value: Double(amount) / 100.0)
+        )
+      ]
+
+      let controller = PKPaymentAuthorizationController(paymentRequest: request)
+      controller.delegate = self
+      self.controller = controller
+      self.presentResolve = resolve
+      self.presentReject = reject
+      self.didAuthorize = false
+
+      controller.present { [weak self] presented in
+        if presented { return }
+        DispatchQueue.main.async {
+          guard let self = self else { return }
+          self.failPresent("APPLE_PAY_PRESENT_FAILED", "Apple Pay sheet failed to present.")
+        }
+      }
+    }
+  }
+
+  // MARK: - finishApplePay
+
+  @objc public func finishApplePay(_ status: NSString,
+                                    resolver resolve: @escaping RCTPromiseResolveBlock,
+                                    rejecter reject: @escaping RCTPromiseRejectBlock) {
+    DispatchQueue.main.async { [weak self] in
+      guard let self = self else {
+        reject("APPLE_PAY_BRIDGE_GONE", "Apple Pay bridge was deallocated.", nil)
+        return
+      }
+      guard let completion = self.authCompletion else {
+        // Sheet was already dismissed (user canceled, or didFinish fired). Soft-success
+        // so JS error-cleanup paths don't double-throw.
+        resolve(nil)
+        return
+      }
+      self.authCompletion = nil
+      let pkStatus: PKPaymentAuthorizationStatus = (status as String == "success") ? .success : .failure
+      completion(PKPaymentAuthorizationResult(status: pkStatus, errors: nil))
+      resolve(nil)
+    }
+  }
+
+  // MARK: - PKPaymentAuthorizationControllerDelegate
+
+  public func paymentAuthorizationController(
+    _ controller: PKPaymentAuthorizationController,
+    didAuthorizePayment payment: PKPayment,
+    handler completion: @escaping (PKPaymentAuthorizationResult) -> Void
+  ) {
+    didAuthorize = true
+    authCompletion = completion
+
+    guard let resolve = presentResolve else {
+      // Defensive: PassKit fired didAuthorize without a pending presentApplePay
+      // promise. Settle as failure and dismiss.
+      completion(PKPaymentAuthorizationResult(status: .failure, errors: nil))
+      authCompletion = nil
+      return
+    }
+    presentResolve = nil
+    presentReject = nil
+
+    let response = Self.serializePayment(payment)
+    resolve(response)
+  }
+
+  public func paymentAuthorizationControllerDidFinish(_ controller: PKPaymentAuthorizationController) {
+    controller.dismiss { [weak self] in
+      DispatchQueue.main.async {
+        guard let self = self else { return }
+        if !self.didAuthorize, let reject = self.presentReject {
+          reject("USER_CANCELED", "User dismissed Apple Pay sheet without authorizing.", nil)
+        }
+        self.presentResolve = nil
+        self.presentReject = nil
+        self.authCompletion = nil
+        self.controller = nil
+      }
+    }
+  }
+
+  // MARK: - Helpers
+
+  private func failPresent(_ code: String, _ message: String) {
+    guard let reject = presentReject else { return }
+    presentResolve = nil
+    presentReject = nil
+    controller = nil
+    reject(code, message, nil)
+  }
+
+  private static func parseNetworks(_ raw: [String]?) -> [PKPaymentNetwork] {
+    let defaults: [PKPaymentNetwork] = [.visa, .masterCard, .amex, .discover, .JCB]
+    guard let raw = raw, !raw.isEmpty else { return defaults }
+    return raw.compactMap { name -> PKPaymentNetwork? in
+      switch name.lowercased() {
+      case "visa": return .visa
+      case "mastercard": return .masterCard
+      case "amex": return .amex
+      case "discover": return .discover
+      case "jcb": return .JCB
+      case "interac": return .interac
+      case "chinaunionpay", "cup": return .chinaUnionPay
+      default: return nil
+      }
+    }
+  }
+
+  // Mirrors the ApplePayBridgeResponse JS shape:
+  //   { token: { paymentData (base64), paymentMethod, transactionIdentifier },
+  //     billingContact?, payerName?, payerEmail? }
+  private static func serializePayment(_ payment: PKPayment) -> [String: Any] {
+    let token = payment.token
+    let pm = token.paymentMethod
+
+    let paymentMethod: [String: Any] = [
+      "displayName": pm.displayName ?? "",
+      "network": pm.network?.rawValue ?? "",
+      "type": Self.paymentMethodTypeString(pm.type),
+    ]
+
+    let tokenDict: [String: Any] = [
+      "paymentData": token.paymentData.base64EncodedString(),
+      "paymentMethod": paymentMethod,
+      "transactionIdentifier": token.transactionIdentifier,
+    ]
+
+    var out: [String: Any] = ["token": tokenDict]
+
+    if let billing = payment.billingContact {
+      var billingDict: [String: Any] = [:]
+      if let postal = billing.postalAddress {
+        let lines = postal.street.split(separator: "\n").map(String.init)
+        if !lines.isEmpty {
+          billingDict["addressLines"] = lines
+        }
+        billingDict["locality"] = postal.city
+        billingDict["administrativeArea"] = postal.state
+        billingDict["postalCode"] = postal.postalCode
+        billingDict["countryCode"] = postal.isoCountryCode
+      }
+      if let name = billing.name {
+        let formatter = PersonNameComponentsFormatter()
+        let full = formatter.string(from: name)
+        if !full.isEmpty {
+          out["payerName"] = full
+        }
+      }
+      if let email = billing.emailAddress {
+        out["payerEmail"] = email
+      }
+      if !billingDict.isEmpty {
+        out["billingContact"] = billingDict
+      }
+    }
+
+    return out
+  }
+
+  private static func paymentMethodTypeString(_ type: PKPaymentMethodType) -> String {
+    switch type {
+    case .debit: return "debit"
+    case .credit: return "credit"
+    case .prepaid: return "prepaid"
+    case .store: return "store"
+    case .eMoney: return "eMoney"
+    case .unknown: return "unknown"
+    @unknown default: return "unknown"
+    }
+  }
+}

package/ios/AttestationBridge.m

@@ -0,0 +1,36 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(FrameAttestation, NSObject)
+
+RCT_EXTERN_METHOD(isSupported:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(attestedKeyId:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(generateKey:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(attestKey:(NSString *)keyId
+                  clientDataHashBase64:(NSString *)clientDataHashBase64
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(promoteKey:(NSString *)keyId
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(clearPendingKey:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(generateAssertion:(NSString *)keyId
+                  clientDataHashBase64:(NSString *)clientDataHashBase64
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(resetAttestation:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
++ (BOOL)requiresMainQueueSetup { return NO; }
+
+@end

package/ios/AttestationBridge.swift

@@ -0,0 +1,167 @@
+import Foundation
+import DeviceCheck
+import Security
+import React
+
+// Keychain key strings are deliberately identical to Frame iOS' DeviceAttestationManager
+// so a device that already attested via the native iOS SDK is recognised by the RN SDK
+// (and vice versa). Do not rename without a coordinated migration.
+
+@objc(FrameAttestation)
+public class FrameAttestation: NSObject {
+
+  private let service = DCAppAttestService.shared
+  private let attestedKey = "com.framepayments.device-attest-key-id"
+  private let pendingKey = "com.framepayments.device-attest-key-id-pending"
+
+  @objc public func isSupported(_ resolve: @escaping RCTPromiseResolveBlock,
+                                 rejecter reject: @escaping RCTPromiseRejectBlock) {
+    resolve(service.isSupported)
+  }
+
+  // nil from readKeychainItem bridges through `Any` → NSNull → JS null.
+  @objc public func attestedKeyId(_ resolve: @escaping RCTPromiseResolveBlock,
+                                   rejecter reject: @escaping RCTPromiseRejectBlock) {
+    resolve(readKeychainItem(attestedKey) as Any)
+  }
+
+  @objc public func generateKey(_ resolve: @escaping RCTPromiseResolveBlock,
+                                 rejecter reject: @escaping RCTPromiseRejectBlock) {
+    guard service.isSupported else {
+      reject("ATTESTATION_NOT_SUPPORTED", "App Attest is not supported on this device.", nil)
+      return
+    }
+    service.generateKey { [weak self] keyId, error in
+      guard let self = self else {
+        reject("ATTESTATION_BRIDGE_GONE", "Attestation bridge was deallocated mid-flow.", nil)
+        return
+      }
+      if let error = error {
+        reject("ATTESTATION_KEY_GENERATION_FAILED", error.localizedDescription, error)
+        return
+      }
+      guard let keyId = keyId else {
+        reject("ATTESTATION_KEY_GENERATION_FAILED", "App Attest returned no key id.", nil)
+        return
+      }
+      self.saveKeychainItem(self.pendingKey, value: keyId)
+      resolve(keyId)
+    }
+  }
+
+  @objc public func attestKey(_ keyId: String,
+                               clientDataHashBase64: String,
+                               resolve: @escaping RCTPromiseResolveBlock,
+                               rejecter reject: @escaping RCTPromiseRejectBlock) {
+    guard let hash = Data(base64Encoded: clientDataHashBase64) else {
+      reject("ATTESTATION_INVALID_HASH", "clientDataHash must be base64-encoded.", nil)
+      return
+    }
+    service.attestKey(keyId, clientDataHash: hash) { [weak self] attestationObject, error in
+      guard let self = self else {
+        reject("ATTESTATION_BRIDGE_GONE", "Attestation bridge was deallocated mid-flow.", nil)
+        return
+      }
+      if let error = error {
+        // attestKey is single-use per key — drop the pending entry so the
+        // next attempt starts fresh.
+        self.deleteKeychainItem(self.pendingKey)
+        reject("ATTESTATION_ATTEST_FAILED", error.localizedDescription, error)
+        return
+      }
+      guard let attestationObject = attestationObject else {
+        self.deleteKeychainItem(self.pendingKey)
+        reject("ATTESTATION_ATTEST_FAILED", "App Attest returned no attestation object.", nil)
+        return
+      }
+      resolve(attestationObject.base64EncodedString())
+    }
+  }
+
+  @objc public func promoteKey(_ keyId: String,
+                                resolve: @escaping RCTPromiseResolveBlock,
+                                rejecter reject: @escaping RCTPromiseRejectBlock) {
+    saveKeychainItem(attestedKey, value: keyId)
+    deleteKeychainItem(pendingKey)
+    resolve(nil)
+  }
+
+  // Drops the pending key. JS calls this when the attest flow fails after
+  // App Attest succeeded but before promoteKey (e.g. backend rejects the
+  // attestation, or the challenge fetch fails post-generateKey). Without it,
+  // a stale pending key id sits in Keychain and the next ensureAttested
+  // can't tell it apart from a fresh one.
+  @objc public func clearPendingKey(_ resolve: @escaping RCTPromiseResolveBlock,
+                                      rejecter reject: @escaping RCTPromiseRejectBlock) {
+    deleteKeychainItem(pendingKey)
+    resolve(nil)
+  }
+
+  @objc public func generateAssertion(_ keyId: String,
+                                       clientDataHashBase64: String,
+                                       resolve: @escaping RCTPromiseResolveBlock,
+                                       rejecter reject: @escaping RCTPromiseRejectBlock) {
+    guard let hash = Data(base64Encoded: clientDataHashBase64) else {
+      reject("ATTESTATION_INVALID_HASH", "clientDataHash must be base64-encoded.", nil)
+      return
+    }
+    service.generateAssertion(keyId, clientDataHash: hash) { assertion, error in
+      if let error = error {
+        reject("ATTESTATION_ASSERTION_FAILED", error.localizedDescription, error)
+        return
+      }
+      guard let assertion = assertion else {
+        reject("ATTESTATION_ASSERTION_FAILED", "App Attest returned no assertion.", nil)
+        return
+      }
+      resolve(assertion.base64EncodedString())
+    }
+  }
+
+  @objc public func resetAttestation(_ resolve: @escaping RCTPromiseResolveBlock,
+                                      rejecter reject: @escaping RCTPromiseRejectBlock) {
+    deleteKeychainItem(attestedKey)
+    deleteKeychainItem(pendingKey)
+    resolve(nil)
+  }
+
+  // MARK: - Keychain helpers (mirror DeviceAttestationManager 1:1)
+
+  private func saveKeychainItem(_ key: String, value: String) {
+    guard !key.isEmpty, let data = value.data(using: .utf8) else { return }
+    let query: [String: Any] = [
+      kSecClass as String: kSecClassGenericPassword,
+      kSecAttrAccount as String: key,
+    ]
+    let attributes: [String: Any] = [kSecValueData as String: data]
+    let status = SecItemUpdate(query as CFDictionary, attributes as CFDictionary)
+    if status == errSecItemNotFound {
+      var addQuery = query
+      addQuery[kSecValueData as String] = data
+      SecItemAdd(addQuery as CFDictionary, nil)
+    }
+  }
+
+  private func readKeychainItem(_ key: String) -> String? {
+    guard !key.isEmpty else { return nil }
+    let query: [String: Any] = [
+      kSecClass as String: kSecClassGenericPassword,
+      kSecAttrAccount as String: key,
+      kSecReturnData as String: true,
+      kSecMatchLimit as String: kSecMatchLimitOne,
+    ]
+    var result: AnyObject?
+    let status = SecItemCopyMatching(query as CFDictionary, &result)
+    guard status == errSecSuccess, let data = result as? Data else { return nil }
+    return String(data: data, encoding: .utf8)
+  }
+
+  private func deleteKeychainItem(_ key: String) {
+    guard !key.isEmpty else { return }
+    let query: [String: Any] = [
+      kSecClass as String: kSecClassGenericPassword,
+      kSecAttrAccount as String: key,
+    ]
+    SecItemDelete(query as CFDictionary)
+  }
+}

package/ios/FrameApplePayButtonView.swift

@@ -0,0 +1,115 @@
+import Foundation
+import PassKit
+import UIKit
+import React
+
+// Native wrapper around PKPaymentButton. Exposed to RN as
+// `requireNativeComponent('FrameApplePayButton')`. Apple Pay HIG mandates
+// using the system-drawn button, so we host one inside an RN-managed view.
+
+@objc(FrameApplePayButtonView)
+public class FrameApplePayButtonView: UIView {
+
+  private var button: PKPaymentButton?
+  // RN sets buttonStyle + buttonType in the same render pass. Without batching
+  // we'd allocate the button twice on first mount. Defer the actual rebuild
+  // until layout runs.
+  private var needsRebuild = true
+
+  @objc public var buttonStyle: NSString = "black" {
+    didSet { markRebuildNeeded() }
+  }
+
+  @objc public var buttonType: NSString = "plain" {
+    didSet { markRebuildNeeded() }
+  }
+
+  @objc public var cornerRadius: CGFloat = 10 {
+    didSet { markRebuildNeeded() }
+  }
+
+  // Bridged from the @objc paymentButtonTapped action. RN's RCTBubblingEventBlock
+  // is set on the view from the view manager.
+  @objc public var onPress: RCTBubblingEventBlock?
+
+  public override init(frame: CGRect) {
+    super.init(frame: frame)
+  }
+
+  required init?(coder: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  private func markRebuildNeeded() {
+    needsRebuild = true
+    setNeedsLayout()
+  }
+
+  public override func layoutSubviews() {
+    super.layoutSubviews()
+    if needsRebuild {
+      rebuildButton()
+      needsRebuild = false
+    }
+    button?.frame = bounds
+  }
+
+  private func rebuildButton() {
+    button?.removeFromSuperview()
+    let style = Self.parseStyle(buttonStyle as String)
+    let type = Self.parseType(buttonType as String)
+    let newButton = PKPaymentButton(paymentButtonType: type, paymentButtonStyle: style)
+    newButton.cornerRadius = cornerRadius
+    newButton.addTarget(self, action: #selector(paymentButtonTapped), for: .touchUpInside)
+    newButton.frame = bounds
+    addSubview(newButton)
+    button = newButton
+  }
+
+  @objc private func paymentButtonTapped() {
+    onPress?([:])
+  }
+
+  private static func parseStyle(_ raw: String) -> PKPaymentButtonStyle {
+    switch raw.lowercased() {
+    case "white": return .white
+    case "whiteoutline", "white-outline": return .whiteOutline
+    case "automatic": return .automatic
+    default: return .black
+    }
+  }
+
+  private static func parseType(_ raw: String) -> PKPaymentButtonType {
+    switch raw.lowercased() {
+    case "buy": return .buy
+    case "setup", "set-up": return .setUp
+    case "instore", "in-store": return .inStore
+    case "donate": return .donate
+    case "checkout", "check-out": return .checkout
+    case "book": return .book
+    case "subscribe": return .subscribe
+    case "reload": return .reload
+    case "addmoney", "add-money": return .addMoney
+    case "topup", "top-up": return .topUp
+    case "order": return .order
+    case "rent": return .rent
+    case "support": return .support
+    case "contribute": return .contribute
+    case "tip": return .tip
+    case "continue": return .continue
+    default: return .plain
+    }
+  }
+}
+
+@objc(FrameApplePayButtonViewManager)
+public class FrameApplePayButtonViewManager: RCTViewManager {
+
+  public override class func requiresMainQueueSetup() -> Bool {
+    return true
+  }
+
+  public override func view() -> UIView! {
+    return FrameApplePayButtonView()
+  }
+}

package/ios/FrameApplePayButtonViewManager.m

@@ -0,0 +1,17 @@
+#import <React/RCTViewManager.h>
+#import <React/RCTUIManager.h>
+
+// RN's legacy view-manager name stripping (and the Fabric interop lookup)
+// derives the JS component name by stripping "Manager" from the moduleName.
+// With the default class name `FrameApplePayButtonViewManager`, the stripped
+// name is `FrameApplePayButtonView`, which doesn't match the JS-side
+// `requireNativeComponent('FrameApplePayButton')`. REMAP forces the JS name
+// explicitly so both old-arch and Fabric-interop registries resolve it.
+@interface RCT_EXTERN_REMAP_MODULE(FrameApplePayButton, FrameApplePayButtonViewManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(buttonStyle, NSString)
+RCT_EXPORT_VIEW_PROPERTY(buttonType, NSString)
+RCT_EXPORT_VIEW_PROPERTY(cornerRadius, CGFloat)
+RCT_EXPORT_VIEW_PROPERTY(onPress, RCTBubblingEventBlock)
+
+@end