framepayments-react-native 3.0.0 → 4.0.0

package/android/build.gradle

@@ -1,23 +1,21 @@
-import groovy.json.JsonSlurper
-
 apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
-apply plugin: 'org.jetbrains.kotlin.plugin.compose'
 
 def safeExtGet(prop, fallback) {
   rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
 }
 
-// Single source of truth for Frame native SDK versions — see package.json:frameNativeVersions.
-def frameNativeVersions = new JsonSlurper().parse(file("$projectDir/../package.json")).frameNativeVersions
-def frameAndroidVersion = frameNativeVersions.android
-
 android {
   namespace "com.framepayments.reactnativeframe"
   compileSdk safeExtGet('compileSdkVersion', 36)
   defaultConfig {
     minSdk safeExtGet('minSdkVersion', 26)
     targetSdk safeExtGet('targetSdkVersion', 36)
+    // Apply consumer-rules.pro to host apps so R8 / ProGuard minification
+    // doesn't break the Prove SDK classes the bridge calls directly, the
+    // Frame RN module bridge (RN annotations), or play-services-wallet
+    // reflection.
+    consumerProguardFiles 'consumer-rules.pro'
   }
   compileOptions {
     sourceCompatibility JavaVersion.VERSION_17
@@ -26,29 +24,20 @@ android {
   kotlinOptions {
     jvmTarget = '17'
   }
-  buildFeatures {
-    compose true
-  }
-  composeOptions {
-    kotlinCompilerExtensionVersion = "1.5.14"
-  }
 }
 
 dependencies {
   implementation 'com.facebook.react:react-native:+'
   implementation "org.jetbrains.kotlin:kotlin-stdlib:2.1.0"
-  implementation "com.framepayments:framesdk:${frameAndroidVersion}"
-  implementation "com.framepayments:framesdk_ui:${frameAndroidVersion}"
-  implementation "com.framepayments:framesdk_onboarding:${frameAndroidVersion}"
-  // Required by FrameGooglePayButton (PaymentsClient, WalletConstants).
-  // framesdk_ui declares this as `implementation`, so it is not exposed transitively.
+  // PaymentsClient, WalletConstants, PaymentDataRequest used by GooglePayBridge.
   implementation 'com.google.android.gms:play-services-wallet:19.4.0'
-  // AppCompat is needed because FrameGooglePayButton casts its host to AppCompatActivity.
-  implementation 'androidx.appcompat:appcompat:1.7.0'
-  implementation 'com.google.code.gson:gson:2.10.1'
-  implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
-  // Frame SDK UI uses Compose; LocalLifecycleOwner requires lifecycle-runtime-compose 2.8+
-  implementation 'androidx.lifecycle:lifecycle-runtime-compose:2.8.2'
-  // Compose support for FrameOnboardingActivity
-  implementation 'androidx.activity:activity-compose:1.12.2'
+  // Suspending Prove flow inside ProveAuthBridge.
+  implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.8.1'
+  // Prove Android SDK. compileOnly so the bridge can use real types without
+  // forcing host apps that don't ship phone_verification to pull it in. At
+  // runtime, ProveAuthBridge probes for the class and degrades to
+  // PROVE_UNAVAILABLE if missing. Host apps that DO ship phone_verification
+  // must add it to their own app/build.gradle:
+  //   implementation 'com.prove.sdk:proveauth:6.10.3'
+  compileOnly 'com.prove.sdk:proveauth:6.10.3'
 }

package/android/consumer-rules.pro

@@ -0,0 +1,34 @@
+# Frame React Native consumer ProGuard rules. Applied to host apps via the
+# consumerProguardFiles entry in android/build.gradle. Keeps classes referenced
+# by reflection at runtime so R8 / ProGuard minification doesn't break the SDK.
+
+# Prove SDK — ProveAuthBridge calls com.prove.sdk.proveauth.* directly (the
+# dep is compileOnly, so host apps that ship phone_verification add it as
+# implementation in their own app/build.gradle). The bridge also probes via
+# Class.forName at runtime to short-circuit when the dep isn't linked. Keep
+# the package so R8 doesn't obfuscate or strip the SDK classes in host apps.
+-keep class com.prove.sdk.proveauth.** { *; }
+-dontwarn com.prove.sdk.proveauth.**
+
+# Google Pay SDK reflection. play-services-wallet uses reflection internally
+# for PaymentDataRequest serialization. Keep the relevant classes.
+-keep class com.google.android.gms.wallet.** { *; }
+-dontwarn com.google.android.gms.wallet.**
+-keep class com.google.android.gms.tasks.** { *; }
+
+# Frame React Native modules. RN's ReactPackage discovers modules + view
+# managers via reflection on @ReactMethod / @ReactProp annotations. Keep
+# everything in the Frame namespace so the bridge survives minification.
+-keep class com.framepayments.reactnativeframe.** { *; }
+-keep @com.facebook.react.bridge.ReactMethod public class * { *; }
+-keepclassmembers class * {
+    @com.facebook.react.bridge.ReactMethod *;
+}
+-keepclassmembers class * {
+    @com.facebook.react.uimanager.annotations.ReactProp *;
+}
+
+# RCTEventEmitter event names. The Prove bridge emits "FrameProveOtpNeeded"
+# via DeviceEventManagerModule which uses reflection. Keep the emitter
+# package + the event method names.
+-keep class com.facebook.react.modules.core.DeviceEventManagerModule** { *; }

package/android/src/main/AndroidManifest.xml

@@ -1,21 +1,13 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="com.framepayments.reactnativeframe">
-  <application>
-    <activity
-      android:name="com.framepayments.reactnativeframe.FrameCheckoutActivity"
-      android:theme="@style/Theme.Frame.NoActionBar"
-      android:exported="false" />
-    <activity
-      android:name="com.framepayments.reactnativeframe.FrameFlowActivity"
-      android:theme="@style/Theme.Frame.NoActionBar"
-      android:exported="false" />
-    <activity
-      android:name="com.framepayments.reactnativeframe.FrameOnboardingActivity"
-      android:theme="@style/Theme.Frame.NoActionBar"
-      android:exported="false" />
-    <activity
-      android:name="com.framepayments.reactnativeframe.FrameGooglePayActivity"
-      android:theme="@style/Theme.Frame.GooglePay.Translucent"
-      android:exported="false" />
-  </application>
+  <!--
+    INTERNET is required by IpAddressBridge.kt, which fetches the device's
+    public IP from api.ipify.org so the SDK can attach `ip_address` to every
+    API request (matching the native Frame Android SDK's SiftManager behavior).
+    Declared here so the Android manifest merger propagates it into host apps
+    without any per-host configuration — both bare RN and Expo consumers
+    inherit it automatically.
+  -->
+  <uses-permission android:name="android.permission.INTERNET" />
+  <application />
 </manifest>

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

@@ -0,0 +1,110 @@
+package com.framepayments.reactnativeframe
+
+import android.content.Context
+import android.widget.FrameLayout
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.uimanager.events.RCTEventEmitter
+import com.google.android.gms.wallet.button.ButtonConstants
+import com.google.android.gms.wallet.button.ButtonOptions
+import com.google.android.gms.wallet.button.PayButton
+import org.json.JSONArray
+import org.json.JSONObject
+
+// Native wrapper around Google's PayButton (play-services-wallet:19.4.0+).
+// Brand guidelines require the system button; we host it inside an RN-managed
+// FrameLayout and forward taps to JS via the `onPress` event.
+
+class FrameGooglePayButtonView(context: Context) : FrameLayout(context) {
+
+  private val payButton = PayButton(context).apply {
+    layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+  }
+
+  private var theme: Int = ButtonConstants.ButtonTheme.DARK
+  private var type: Int = ButtonConstants.ButtonType.PAY
+  private var cornerRadiusDp: Int = 8
+
+  // Defers the first PayButton.initialize() call until the view is attached to
+  // a window. Google's PaymentsClient surface implicitly needs a host activity
+  // context; initializing pre-attach has produced "no current activity" crashes
+  // in the wild. Prop setters mark the button dirty; onAttachedToWindow + each
+  // post-attach prop change call refresh().
+  private var attached = false
+  private var pendingRefresh = true
+
+  init {
+    addView(payButton)
+    payButton.setOnClickListener {
+      val ctx = context
+      if (ctx is ReactContext) {
+        ctx
+          .getJSModule(RCTEventEmitter::class.java)
+          .receiveEvent(id, "topPress", null)
+      }
+    }
+  }
+
+  fun setButtonTheme(value: String) {
+    theme = when (value.lowercase()) {
+      "light" -> ButtonConstants.ButtonTheme.LIGHT
+      else -> ButtonConstants.ButtonTheme.DARK
+    }
+    markDirty()
+  }
+
+  fun setButtonType(value: String) {
+    type = when (value.lowercase()) {
+      "buy" -> ButtonConstants.ButtonType.BUY
+      "book" -> ButtonConstants.ButtonType.BOOK
+      "checkout" -> ButtonConstants.ButtonType.CHECKOUT
+      "donate" -> ButtonConstants.ButtonType.DONATE
+      "order" -> ButtonConstants.ButtonType.ORDER
+      "subscribe" -> ButtonConstants.ButtonType.SUBSCRIBE
+      "plain" -> ButtonConstants.ButtonType.PLAIN
+      else -> ButtonConstants.ButtonType.PAY
+    }
+    markDirty()
+  }
+
+  fun setCornerRadiusDp(value: Int) {
+    cornerRadiusDp = value.coerceAtLeast(0)
+    markDirty()
+  }
+
+  private fun markDirty() {
+    pendingRefresh = true
+    if (attached) refresh()
+  }
+
+  private fun refresh() {
+    if (!pendingRefresh) return
+    val allowed = 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")))
+        })
+      })
+    }
+    val options = ButtonOptions.newBuilder()
+      .setButtonTheme(theme)
+      .setButtonType(type)
+      .setCornerRadius(cornerRadiusDp)
+      .setAllowedPaymentMethods(allowed.toString())
+      .build()
+    payButton.initialize(options)
+    pendingRefresh = false
+  }
+
+  override fun onAttachedToWindow() {
+    super.onAttachedToWindow()
+    attached = true
+    refresh()
+  }
+
+  override fun onDetachedFromWindow() {
+    attached = false
+    super.onDetachedFromWindow()
+  }
+}

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

@@ -0,0 +1,44 @@
+package com.framepayments.reactnativeframe
+
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+
+class FrameGooglePayButtonViewManager : SimpleViewManager<FrameGooglePayButtonView>() {
+
+  override fun getName(): String = REACT_CLASS
+
+  override fun createViewInstance(reactContext: ThemedReactContext): FrameGooglePayButtonView {
+    return FrameGooglePayButtonView(reactContext)
+  }
+
+  @ReactProp(name = "buttonTheme")
+  fun setButtonTheme(view: FrameGooglePayButtonView, value: String?) {
+    view.setButtonTheme(value ?: "dark")
+  }
+
+  @ReactProp(name = "buttonType")
+  fun setButtonType(view: FrameGooglePayButtonView, value: String?) {
+    view.setButtonType(value ?: "pay")
+  }
+
+  @ReactProp(name = "cornerRadiusDp", defaultInt = 8)
+  fun setCornerRadiusDp(view: FrameGooglePayButtonView, value: Int) {
+    view.setCornerRadiusDp(value)
+  }
+
+  override fun getExportedCustomBubblingEventTypeConstants(): MutableMap<String, Any> {
+    return MapBuilder.of(
+      "topPress",
+      MapBuilder.of(
+        "phasedRegistrationNames",
+        MapBuilder.of("bubbled", "onPress"),
+      ),
+    )
+  }
+
+  companion object {
+    const val REACT_CLASS = "FrameGooglePayButton"
+  }
+}

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

@@ -1,266 +1,39 @@
 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.ReadableArray
 import com.facebook.react.bridge.ReadableMap
-import com.facebook.react.bridge.WritableNativeMap
-import com.framepayments.framesdk.FrameNetworking
 
+/**
+ * Single-method native module shim for 4.0.0. All JS-callable surfaces
+ * (Checkout, Cart, Onboarding, Google Pay, Prove) live in their own modules.
+ * initialize() is intentionally a no-op — src/config.ts holds the truth.
+ */
 class FrameSDKModule(reactContext: ReactApplicationContext) :
-  ReactContextBaseJavaModule(reactContext), ActivityEventListener {
-
-  init {
-    reactContext.addActivityEventListener(this)
-  }
-
-  private var checkoutPromise: Promise? = null
-  private var cartPromise: Promise? = null
-  private var onboardingPromise: Promise? = null
-  private var googlePayPromise: Promise? = null
+  ReactContextBaseJavaModule(reactContext) {
 
   override fun getName(): String = "FrameSDK"
 
-  companion object {
-    @JvmStatic
-    var pendingGooglePayCallback: ((Int, Intent?) -> Unit)? = null
-  }
-
   @ReactMethod
   fun initialize(
     secretKey: String,
     publishableKey: String,
     debugMode: Boolean,
-    theme: ReadableMap?,
-    promise: Promise
-  ) {
-    try {
-      val ctx = reactApplicationContext.applicationContext
-      FrameNetworking.initializeWithAPIKey(ctx, secretKey, publishableKey, debugMode)
-      FrameRNTheme.current = theme?.takeIf { it.keySetIterator().hasNextKey() }?.let {
-        FrameRNTheme.parse(ctx, it)
-      }
-      promise.resolve(null)
-    } catch (e: Exception) {
-      promise.reject("INIT_FAILED", e.message, e)
-    }
-  }
-
-  @ReactMethod
-  fun presentCheckout(accountId: String?, amount: Double, promise: Promise) {
-    val activity = reactApplicationContext.currentActivity ?: run {
-      promise.reject("NO_ACTIVITY", "No current activity", null)
-      return
-    }
-    checkoutPromise = promise
-    activity.runOnUiThread {
-      val intent = Intent(activity, FrameCheckoutActivity::class.java).apply {
-        putExtra(FrameCheckoutActivity.EXTRA_ACCOUNT_ID, accountId)
-        putExtra(FrameCheckoutActivity.EXTRA_AMOUNT, amount.toInt())
-      }
-      activity.startActivityForResult(intent, FrameCheckoutActivity.REQUEST_CODE)
-    }
-  }
-
-  @ReactMethod
-  fun presentCart(
-    accountId: String?,
-    items: ReadableArray,
-    shippingAmountInCents: Double,
-    promise: Promise
-  ) {
-    val activity = reactApplicationContext.currentActivity ?: run {
-      promise.reject("NO_ACTIVITY", "No current activity", null)
-      return
-    }
-    val itemsJson = readableArrayToJson(items) ?: run {
-      promise.reject("INVALID_ITEMS", "Invalid cart items", null)
-      return
-    }
-    cartPromise = promise
-    activity.runOnUiThread {
-      val intent = Intent(activity, FrameFlowActivity::class.java).apply {
-        putExtra(FrameFlowActivity.EXTRA_ACCOUNT_ID, accountId)
-        putExtra(FrameFlowActivity.EXTRA_ITEMS_JSON, itemsJson)
-        putExtra(FrameFlowActivity.EXTRA_SHIPPING_CENTS, shippingAmountInCents.toInt())
-      }
-      activity.startActivityForResult(intent, FrameFlowActivity.REQUEST_CODE)
-    }
-  }
-
-  @ReactMethod
-  fun presentGooglePay(
-    amountCents: Double,
-    ownerType: String?,
-    ownerId: String?,
-    currencyCode: String?,
-    googlePayMerchantId: String?,
-    promise: Promise
-  ) {
-    val activity = reactApplicationContext.currentActivity ?: run {
-      promise.reject("NO_ACTIVITY", "No current activity", null)
-      return
-    }
-    val amountInt = amountCents.toInt()
-    if (amountInt <= 0) {
-      promise.reject("INVALID_AMOUNT", "amountCents must be positive", null)
-      return
-    }
-    if (ownerType != "customer" && ownerType != "account") {
-      promise.reject("INVALID_OWNER", "owner.type must be 'customer' or 'account'", null)
-      return
-    }
-    if (ownerId.isNullOrEmpty()) {
-      promise.reject("INVALID_OWNER", "owner.id is required", null)
-      return
-    }
-    googlePayPromise = promise
-    pendingGooglePayCallback = { resultCode, data ->
-      handleGooglePayResult(resultCode, data)
-    }
-    activity.runOnUiThread {
-      val intent = Intent(activity, FrameGooglePayActivity::class.java).apply {
-        putExtra(FrameGooglePayActivity.EXTRA_AMOUNT_CENTS, amountInt)
-        putExtra(FrameGooglePayActivity.EXTRA_OWNER_TYPE, ownerType)
-        putExtra(FrameGooglePayActivity.EXTRA_OWNER_ID, ownerId)
-        putExtra(FrameGooglePayActivity.EXTRA_CURRENCY, currencyCode ?: "USD")
-        putExtra(FrameGooglePayActivity.EXTRA_MERCHANT_ID, googlePayMerchantId)
-      }
-      activity.startActivity(intent)
-    }
-  }
-
-  @ReactMethod
-  fun presentOnboarding(
-    accountId: String?,
-    capabilities: ReadableArray,
+    applePayMerchantId: String?,
     googlePayMerchantId: String?,
+    theme: ReadableMap?,
     promise: Promise
   ) {
-    val activity = reactApplicationContext.currentActivity ?: run {
-      promise.reject("NO_ACTIVITY", "No current activity", null)
-      return
-    }
-    val capabilitiesJson = readableArrayToJsonArray(capabilities)
-    onboardingPromise = promise
-    activity.runOnUiThread {
-      val intent = Intent(activity, FrameOnboardingActivity::class.java).apply {
-        putExtra(FrameOnboardingActivity.EXTRA_ACCOUNT_ID, accountId)
-        putExtra(FrameOnboardingActivity.EXTRA_CAPABILITIES_JSON, capabilitiesJson)
-        putExtra(FrameOnboardingActivity.EXTRA_GOOGLE_PAY_MERCHANT_ID, googlePayMerchantId)
-      }
-      activity.startActivityForResult(intent, FrameOnboardingActivity.REQUEST_CODE)
-    }
-  }
-
-  private fun readableArrayToJson(items: ReadableArray): String? {
-    val arr = org.json.JSONArray()
-    for (i in 0 until items.size()) {
-      val item = items.getMap(i) ?: return null
-      val obj = org.json.JSONObject()
-      obj.put("id", item.getString("id"))
-      obj.put("title", item.getString("title"))
-      obj.put("amountInCents", item.getDouble("amountInCents").toInt())
-      obj.put("imageUrl", item.getString("imageUrl") ?: "")
-      arr.put(obj)
-    }
-    return arr.toString()
-  }
-
-  private fun readableArrayToJsonArray(arr: ReadableArray): String {
-    val jsonArr = org.json.JSONArray()
-    for (i in 0 until arr.size()) {
-      arr.getString(i)?.let { jsonArr.put(it) }
-    }
-    return jsonArr.toString()
-  }
-
-  override fun onActivityResult(activity: Activity, requestCode: Int, resultCode: Int, data: Intent?) {
-    when (requestCode) {
-      FrameCheckoutActivity.REQUEST_CODE -> handleCheckoutResult(resultCode, data)
-      FrameFlowActivity.REQUEST_CODE -> handleCartResult(resultCode, data)
-      FrameOnboardingActivity.REQUEST_CODE -> handleOnboardingResult(resultCode, data)
-      FrameGooglePayActivity.REQUEST_CODE -> handleGooglePayResult(resultCode, data)
-      else -> return
-    }
-  }
-
-  private fun handleCheckoutResult(resultCode: Int, data: Intent?) {
-    val promise = checkoutPromise ?: return
-    checkoutPromise = null
-    if (resultCode == Activity.RESULT_OK && data != null) {
-      val transferId = data.getStringExtra(FrameCheckoutActivity.EXTRA_TRANSFER_ID)
-      if (!transferId.isNullOrEmpty()) {
-        promise.resolve(transferId)
-      } else {
-        promise.reject("NO_RESULT", "No transfer id in result", null)
-      }
-    } else {
-      promise.reject("USER_CANCELED", "User cancelled checkout", null)
-    }
-  }
-
-  private fun handleCartResult(resultCode: Int, data: Intent?) {
-    val promise = cartPromise ?: return
-    cartPromise = null
-    if (resultCode == Activity.RESULT_OK && data != null) {
-      val transferId = data.getStringExtra(FrameFlowActivity.EXTRA_TRANSFER_ID)
-      if (!transferId.isNullOrEmpty()) {
-        promise.resolve(transferId)
-      } else {
-        promise.reject("NO_RESULT", "No transfer id in result", null)
-      }
-    } else {
-      promise.reject("USER_CANCELED", "User cancelled", null)
-    }
+    @Suppress("UNUSED_PARAMETER") val unused = listOf(
+      secretKey,
+      publishableKey,
+      debugMode,
+      applePayMerchantId,
+      googlePayMerchantId,
+      theme,
+    )
+    promise.resolve(null)
   }
-
-  private fun handleGooglePayResult(resultCode: Int, data: Intent?) {
-    val promise = googlePayPromise ?: return
-    googlePayPromise = null
-    when (resultCode) {
-      Activity.RESULT_OK -> {
-        val id = data?.getStringExtra(FrameGooglePayActivity.EXTRA_CHARGE_ID)
-        if (id.isNullOrEmpty()) {
-          promise.reject("NO_RESULT", "Google Pay returned no charge id", null)
-        } else {
-          promise.resolve(id)
-        }
-      }
-      FrameGooglePayActivity.RESULT_FAILURE -> {
-        val message = data?.getStringExtra(FrameGooglePayActivity.EXTRA_FAILURE_MESSAGE) ?: "Google Pay failed"
-        promise.reject("PAYMENT_FAILED", message, null)
-      }
-      FrameGooglePayActivity.RESULT_UNAVAILABLE -> {
-        promise.reject("GOOGLE_PAY_UNAVAILABLE", "Google Pay is not available on this device", null)
-      }
-      else -> {
-        promise.reject("USER_CANCELED", "User cancelled Google Pay", null)
-      }
-    }
-  }
-
-  private fun handleOnboardingResult(resultCode: Int, data: Intent?) {
-    val promise = onboardingPromise ?: return
-    onboardingPromise = null
-    val map = WritableNativeMap()
-    if (resultCode == Activity.RESULT_OK) {
-      map.putString("status", "completed")
-      val paymentMethodId = data?.getStringExtra(FrameOnboardingActivity.EXTRA_PAYMENT_METHOD_ID)
-      if (paymentMethodId != null) {
-        map.putString("paymentMethodId", paymentMethodId)
-      }
-      promise.resolve(map)
-    } else {
-      map.putString("status", "cancelled")
-      promise.resolve(map)
-    }
-  }
-
-  override fun onNewIntent(intent: Intent) {}
 }

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

@@ -7,10 +7,15 @@ import com.facebook.react.uimanager.ViewManager
 
 class FrameSDKPackage : ReactPackage {
   override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-    return listOf(FrameSDKModule(reactContext))
+    return listOf(
+      FrameSDKModule(reactContext),
+      GooglePayBridge(reactContext),
+      ProveAuthBridge(reactContext),
+      IpAddressBridge(reactContext),
+    )
   }
 
   override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-    return emptyList()
+    return listOf(FrameGooglePayButtonViewManager())
   }
 }