framepayments-react-native 3.0.1 → 4.0.0

package/android/src/main/java/com/framepayments/reactnativeframe/GooglePayBridge.kt

@@ -0,0 +1,255 @@
+package com.framepayments.reactnativeframe
+
+import android.app.Activity
+import android.content.Intent
+import com.facebook.react.bridge.ActivityEventListener
+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.facebook.react.bridge.WritableNativeMap
+import com.google.android.gms.tasks.Task
+import com.google.android.gms.wallet.AutoResolveHelper
+import com.google.android.gms.wallet.IsReadyToPayRequest
+import com.google.android.gms.wallet.PaymentData
+import com.google.android.gms.wallet.PaymentDataRequest
+import com.google.android.gms.wallet.PaymentsClient
+import com.google.android.gms.wallet.Wallet
+import com.google.android.gms.wallet.WalletConstants
+import org.json.JSONArray
+import org.json.JSONObject
+import java.util.Locale
+
+/**
+ * Token-out Google Pay bridge.
+ *
+ * `isGooglePayReady` returns whether the device has a usable Google Pay setup.
+ * `presentGooglePay` builds the PaymentDataRequest, opens the wallet sheet,
+ * and resolves with the raw PaymentData JSON parsed into a map. JS hands that
+ * blob to frame-node, which forwards it to Frame's backend for tokenization.
+ */
+class GooglePayBridge(private val reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext), ActivityEventListener {
+
+  init {
+    reactContext.addActivityEventListener(this)
+  }
+
+  private var pendingPromise: Promise? = null
+
+  override fun getName(): String = "FrameGooglePay"
+
+  // MARK: - isGooglePayReady
+
+  @ReactMethod
+  fun isGooglePayReady(args: ReadableMap, promise: Promise) {
+    val environment = args.getString("environment") ?: "PRODUCTION"
+    val client = paymentsClient(environment)
+    val request = IsReadyToPayRequest.fromJson(buildIsReadyToPayRequest().toString())
+    val task: Task<Boolean> = client.isReadyToPay(request)
+    task.addOnCompleteListener { completed ->
+      if (completed.isSuccessful) {
+        promise.resolve(completed.result == true)
+      } else {
+        promise.resolve(false)
+      }
+    }
+  }
+
+  // MARK: - presentGooglePay
+
+  @ReactMethod
+  fun presentGooglePay(args: ReadableMap, promise: Promise) {
+    if (pendingPromise != null) {
+      promise.reject("GOOGLE_PAY_BUSY", "A Google Pay sheet is already presenting.")
+      return
+    }
+
+    val activity = reactApplicationContext.currentActivity
+    if (activity == null) {
+      promise.reject("GOOGLE_PAY_NO_ACTIVITY", "No current Activity. Open the sheet from a foregrounded screen.")
+      return
+    }
+
+    val amountCents = if (args.hasKey("amountCents")) args.getInt("amountCents") else 0
+    if (amountCents <= 0) {
+      promise.reject("GOOGLE_PAY_INVALID_ARGS", "amountCents must be > 0.")
+      return
+    }
+    val currencyCode = args.getString("currencyCode") ?: "USD"
+    val merchantId = args.getString("googlePayMerchantId") ?: ""
+    if (merchantId.isEmpty()) {
+      promise.reject("GOOGLE_PAY_INVALID_ARGS", "googlePayMerchantId is required.")
+      return
+    }
+    val environment = args.getString("environment") ?: "PRODUCTION"
+    val walletConfig = args.getMap("walletConfig")
+    val gateway = walletConfig?.getString("processor") ?: ""
+    val gatewayMerchantId = walletConfig?.getString("processor_key") ?: ""
+    if (gateway.isEmpty() || gatewayMerchantId.isEmpty()) {
+      promise.reject(
+        "GOOGLE_PAY_INVALID_ARGS",
+        "walletConfig.processor and walletConfig.processor_key are required.",
+      )
+      return
+    }
+
+    val requestJson = buildPaymentDataRequest(
+      amountCents = amountCents,
+      currencyCode = currencyCode,
+      gateway = gateway,
+      gatewayMerchantId = gatewayMerchantId,
+      googlePayMerchantId = merchantId,
+    )
+    val request = PaymentDataRequest.fromJson(requestJson.toString())
+    val client = paymentsClient(environment)
+
+    pendingPromise = promise
+    AutoResolveHelper.resolveTask(client.loadPaymentData(request), activity, REQUEST_CODE)
+  }
+
+  // MARK: - ActivityEventListener
+
+  override fun onActivityResult(activity: Activity, requestCode: Int, resultCode: Int, data: Intent?) {
+    if (requestCode != REQUEST_CODE) return
+    val promise = pendingPromise ?: return
+    pendingPromise = null
+
+    when (resultCode) {
+      Activity.RESULT_OK -> {
+        val paymentData = data?.let { PaymentData.getFromIntent(it) }
+        if (paymentData == null) {
+          promise.reject("PAYMENT_FAILED", "Google Pay returned no PaymentData.")
+          return
+        }
+        val json = try {
+          JSONObject(paymentData.toJson())
+        } catch (e: Exception) {
+          promise.reject("PAYMENT_FAILED", "Could not parse Google Pay response.", e)
+          return
+        }
+        val response = WritableNativeMap().apply {
+          putInt("apiVersion", json.optInt("apiVersion", 2))
+          putInt("apiVersionMinor", json.optInt("apiVersionMinor", 0))
+          json.optString("email").takeIf { it.isNotEmpty() }?.let { putString("email", it) }
+          val pmd = json.optJSONObject("paymentMethodData")
+          if (pmd != null) {
+            putMap("paymentMethodData", jsonObjectToWritableMap(pmd))
+          } else {
+            putMap("paymentMethodData", WritableNativeMap())
+          }
+        }
+        promise.resolve(response)
+      }
+      Activity.RESULT_CANCELED -> {
+        promise.reject("USER_CANCELED", "User dismissed Google Pay sheet without authorizing.")
+      }
+      AutoResolveHelper.RESULT_ERROR -> {
+        val status = AutoResolveHelper.getStatusFromIntent(data)
+        val code = status?.statusCode ?: -1
+        val message = status?.statusMessage ?: "Google Pay failed."
+        promise.reject("PAYMENT_FAILED", "Google Pay error ($code): $message")
+      }
+      else -> {
+        promise.reject("PAYMENT_FAILED", "Google Pay returned unexpected result code $resultCode.")
+      }
+    }
+  }
+
+  override fun onNewIntent(intent: Intent) {
+    // no-op: Google Pay results arrive via onActivityResult, not intents.
+  }
+
+  override fun invalidate() {
+    // RN 0.70+ uses invalidate() as the module-teardown hook (replacing the
+    // deprecated onCatalystInstanceDestroy). Remove the ActivityEventListener
+    // so we don't leak an Activity reference across hot-reloads in dev.
+    reactContext.removeActivityEventListener(this)
+    super.invalidate()
+  }
+
+  // MARK: - Helpers
+
+  private fun paymentsClient(environment: String): PaymentsClient {
+    val env = if (environment == "PRODUCTION") {
+      WalletConstants.ENVIRONMENT_PRODUCTION
+    } else {
+      WalletConstants.ENVIRONMENT_TEST
+    }
+    val activity = reactApplicationContext.currentActivity
+    val options = Wallet.WalletOptions.Builder()
+      .setEnvironment(env)
+      .build()
+    return if (activity != null) {
+      Wallet.getPaymentsClient(activity, options)
+    } else {
+      Wallet.getPaymentsClient(reactContext, options)
+    }
+  }
+
+  private fun buildIsReadyToPayRequest(): JSONObject {
+    return JSONObject().apply {
+      put("apiVersion", 2)
+      put("apiVersionMinor", 0)
+      put("allowedPaymentMethods", JSONArray().apply {
+        put(JSONObject().apply {
+          put("type", "CARD")
+          put("parameters", JSONObject().apply {
+            put("allowedAuthMethods", JSONArray(listOf("PAN_ONLY", "CRYPTOGRAM_3DS")))
+            put("allowedCardNetworks", JSONArray(listOf("AMEX", "DISCOVER", "MASTERCARD", "VISA")))
+          })
+        })
+      })
+    }
+  }
+
+  private fun buildPaymentDataRequest(
+    amountCents: Int,
+    currencyCode: String,
+    gateway: String,
+    gatewayMerchantId: String,
+    googlePayMerchantId: String,
+  ): JSONObject {
+    return JSONObject().apply {
+      put("apiVersion", 2)
+      put("apiVersionMinor", 0)
+      put("allowedPaymentMethods", JSONArray().apply {
+        put(JSONObject().apply {
+          put("type", "CARD")
+          put("parameters", JSONObject().apply {
+            put("allowedAuthMethods", JSONArray(listOf("PAN_ONLY", "CRYPTOGRAM_3DS")))
+            put("allowedCardNetworks", JSONArray(listOf("AMEX", "DISCOVER", "MASTERCARD", "VISA")))
+            put("billingAddressRequired", true)
+            put("billingAddressParameters", JSONObject().apply {
+              put("format", "FULL")
+            })
+          })
+          put("tokenizationSpecification", JSONObject().apply {
+            put("type", "PAYMENT_GATEWAY")
+            put("parameters", JSONObject().apply {
+              put("gateway", gateway)
+              put("gatewayMerchantId", gatewayMerchantId)
+            })
+          })
+        })
+      })
+      put("transactionInfo", JSONObject().apply {
+        put("totalPriceStatus", "FINAL")
+        // Locale.US forces "12.50" (decimal point). Default locale would
+        // produce "12,50" on de_DE/fr_FR/etc., which Google Pay rejects.
+        put("totalPrice", String.format(Locale.US, "%.2f", amountCents / 100.0))
+        put("currencyCode", currencyCode)
+      })
+      put("merchantInfo", JSONObject().apply {
+        put("merchantId", googlePayMerchantId)
+        put("merchantName", "Frame Payments")
+      })
+      put("emailRequired", true)
+    }
+  }
+
+  companion object {
+    const val REQUEST_CODE = 9100
+  }
+}

package/android/src/main/java/com/framepayments/reactnativeframe/IpAddressBridge.kt

@@ -0,0 +1,63 @@
+package com.framepayments.reactnativeframe
+
+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 kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import java.io.BufferedReader
+import java.io.InputStreamReader
+import java.net.URL
+
+// Resolves the device's public IP via api.ipify.org so the SDK can attach it
+// to every outgoing API request as the `ip_address` header. Matches Frame
+// Android's SiftManager.getPublicIp() — caches the result for app lifecycle
+// after the first successful lookup; failed lookups are not cached so the
+// next call retries.
+//
+// Network I/O runs on Dispatchers.IO; the JS-facing method is async (resolves
+// the Promise once the lookup completes). On any failure, the promise
+// resolves null so callers fall back to "no header" rather than blocking
+// initialization on a network round-trip.
+
+class IpAddressBridge(reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+
+  private val scope = CoroutineScope(Dispatchers.IO + Job())
+
+  @Volatile
+  private var cachedIp: String? = null
+
+  override fun getName(): String = "FrameIpAddress"
+
+  @ReactMethod
+  fun getIpAddress(promise: Promise) {
+    cachedIp?.let {
+      promise.resolve(it)
+      return
+    }
+    scope.launch {
+      val ip = fetchPublicIp()
+      if (ip != null) cachedIp = ip
+      promise.resolve(ip)
+    }
+  }
+
+  override fun invalidate() {
+    scope.cancel()
+    super.invalidate()
+  }
+
+  private fun fetchPublicIp(): String? = try {
+    val url = URL("https://api.ipify.org")
+    BufferedReader(InputStreamReader(url.openStream())).use {
+      it.readLine()?.trim()?.takeIf(String::isNotEmpty)
+    }
+  } catch (_: Throwable) {
+    null
+  }
+}

package/android/src/main/java/com/framepayments/reactnativeframe/ProveAuthBridge.kt

@@ -0,0 +1,215 @@
+package com.framepayments.reactnativeframe
+
+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.WritableNativeMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.prove.sdk.proveauth.AuthFinishStep
+import com.prove.sdk.proveauth.OtpFinishInput
+import com.prove.sdk.proveauth.OtpFinishStep
+import com.prove.sdk.proveauth.OtpStartInput
+import com.prove.sdk.proveauth.OtpStartStep
+import com.prove.sdk.proveauth.ProveAuth
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+
+// Android bridge for Prove's ProveAuth SDK. Surface mirrors the iOS bridge:
+//
+//   authenticate(authToken) -> Promise<{ status: 'success' | 'failed' }>
+//   submitOtp(code) -> void   (resumes a suspended OTP request)
+//   cancelOtp() -> void
+//   cancelAuth() -> void
+//
+//   Event: FrameProveOtpNeeded — fires when Prove falls back to OTP.
+//
+// The Prove Android SDK (com.prove.sdk:proveauth) is declared as compileOnly
+// in our android/build.gradle so this file compiles without forcing host apps
+// that don't ship phone_verification to pull it in. Host apps that DO ship
+// phone_verification add `implementation 'com.prove.sdk:proveauth:<version>'`
+// to their own app/build.gradle. At runtime, we probe for the SDK class and
+// resolve PROVE_UNAVAILABLE if missing so JS falls back to the Frame OTP path.
+//
+// Call sequence verified against frame-android's ProveAuthService.kt.
+
+class ProveAuthBridge(private val reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+
+  private val scope = CoroutineScope(Dispatchers.Default + Job())
+  private var authPromise: Promise? = null
+  private var otpDeferred: CompletableDeferred<String?>? = null
+
+  // Retained across the auth lifecycle so the Prove SDK's step closures don't
+  // outlive the bridge's reference to them; cleared on terminal resolution.
+  private var proveAuth: ProveAuth? = null
+
+  override fun getName(): String = "FrameProveAuth"
+
+  // RTNDeviceEventEmitter is the documented mechanism for arbitrary RN events
+  // from a non-RCTEventEmitter module. JS subscribes via NativeEventEmitter.
+  @ReactMethod
+  fun addListener(@Suppress("UNUSED_PARAMETER") eventName: String) {}
+
+  @ReactMethod
+  fun removeListeners(@Suppress("UNUSED_PARAMETER") count: Int) {}
+
+  // ─── JS API ───
+
+  @ReactMethod
+  fun authenticate(authToken: String, promise: Promise) {
+    if (authPromise != null) {
+      promise.reject("PROVE_BUSY", "A Prove authentication is already in flight.")
+      return
+    }
+
+    if (!isProveSdkLinked()) {
+      promise.reject("PROVE_UNAVAILABLE", "Prove SDK is not linked in this app.")
+      return
+    }
+
+    authPromise = promise
+    scope.launch {
+      try {
+        runProveFlow(authToken)
+        finishAuthSuccess()
+      } catch (e: NoClassDefFoundError) {
+        finishAuthFailure("Prove SDK is not linked in this app.")
+      } catch (e: Throwable) {
+        finishAuthFailure(e.message ?: "Prove authentication failed.")
+      }
+    }
+  }
+
+  @ReactMethod
+  fun submitOtp(code: String, promise: Promise) {
+    val deferred = otpDeferred
+    if (deferred == null) {
+      promise.resolve(null)
+      return
+    }
+    otpDeferred = null
+    deferred.complete(code)
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun cancelOtp(promise: Promise) {
+    otpDeferred?.complete(null)
+    otpDeferred = null
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun cancelAuth(promise: Promise) {
+    otpDeferred?.complete(null)
+    otpDeferred = null
+    finishAuthFailure("Prove authentication canceled by user.")
+    promise.resolve(null)
+  }
+
+  override fun invalidate() {
+    scope.cancel()
+    super.invalidate()
+  }
+
+  // ─── Internal ───
+
+  private fun isProveSdkLinked(): Boolean = try {
+    Class.forName("com.prove.sdk.proveauth.ProveAuth")
+    true
+  } catch (_: Throwable) {
+    false
+  }
+
+  private fun emitOtpNeeded() {
+    val params = WritableNativeMap()
+    reactContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit("FrameProveOtpNeeded", params)
+  }
+
+  private suspend fun runProveFlow(authToken: String) {
+    val resultDeferred = CompletableDeferred<Result<Boolean>>()
+
+    // AuthFinishStep fires when Prove signals "device auth ok". JS owns the
+    // backend confirm step, so we resolve the bridge promise as soon as the
+    // SDK reaches this point.
+    val authFinishStep = AuthFinishStep { _ ->
+      resultDeferred.complete(Result.success(true))
+    }
+
+    // The phone number is encoded in the authToken; phoneNumberNeeded=true is
+    // a misconfiguration → error. Mirrors frame-android ProveAuthService.kt.
+    val otpStartStep = OtpStartStep { phoneNumberNeeded, _, callback ->
+      if (phoneNumberNeeded) {
+        callback.onError()
+      } else {
+        callback.onSuccess(OtpStartInput(""))
+      }
+    }
+
+    // OtpFinishStep — Prove falls back to OTP. Emit the event so JS shows its
+    // entry sheet, then suspend on otpDeferred until submitOtp/cancelOtp
+    // resolves it. Null means the user cancelled.
+    val otpFinishStep = OtpFinishStep { _, callback ->
+      scope.launch {
+        // Guard against a stale deferred from a previous OTP request (Prove
+        // can re-request OTP if the first code fails validation).
+        otpDeferred?.complete(null)
+        val deferred = CompletableDeferred<String?>()
+        otpDeferred = deferred
+        emitOtpNeeded()
+        val otp = deferred.await()
+        otpDeferred = null
+        if (otp != null) {
+          callback.onSuccess(OtpFinishInput(otp))
+        } else {
+          callback.onError()
+        }
+      }
+    }
+
+    val sdk = ProveAuth.builder()
+      .withContext(reactContext.applicationContext)
+      .withAuthFinishStep(authFinishStep)
+      .withOtpFallback(otpStartStep, otpFinishStep)
+      .build()
+    proveAuth = sdk
+
+    try {
+      sdk.authenticate(authToken)
+    } catch (e: Throwable) {
+      releaseRetainedSDKObjects()
+      resultDeferred.complete(Result.failure(e))
+    }
+
+    resultDeferred.await().getOrThrow()
+    releaseRetainedSDKObjects()
+  }
+
+  private fun releaseRetainedSDKObjects() {
+    proveAuth = null
+  }
+
+  private fun finishAuthSuccess() {
+    val promise = authPromise ?: return
+    authPromise = null
+    val result = WritableNativeMap().apply { putString("status", "success") }
+    promise.resolve(result)
+  }
+
+  private fun finishAuthFailure(message: String) {
+    val promise = authPromise ?: return
+    authPromise = null
+    val result = WritableNativeMap().apply {
+      putString("status", "failed")
+      putString("message", message)
+    }
+    promise.resolve(result)
+  }
+}

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require('./plugin/withFrameReactNative');

package/ios/ApplePayBridge.m

@@ -0,0 +1,23 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(FrameApplePay, NSObject)
+
+RCT_EXTERN_METHOD(canMakeApplePay:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(presentApplePay:(NSDictionary *)args
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(finishApplePay:(NSString *)status
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+// PKPaymentAuthorizationController must be allocated + presented from the
+// main thread. The Swift implementation wraps every public call in
+// DispatchQueue.main.async, but RN may invoke the first method on a
+// background queue if requiresMainQueueSetup is false. Defensively require
+// main-queue setup.
++ (BOOL)requiresMainQueueSetup { return YES; }
+
+@end