@virex-tech/paywallo-sdk 1.5.0 → 1.5.2

package/PaywalloSdk.podspec

@@ -11,10 +11,9 @@ Pod::Spec.new do |s|
   s.authors      = { "Paywallo" => "support@paywallo.io" }
   s.platforms    = { :ios => "15.0" }
   s.source       = { :git => "https://github.com/paywallo/sdk-react-native.git", :tag => "v#{s.version}" }
-  s.source_files = "ios/**/*.{h,m,swift}"
-  s.frameworks   = "WebKit", "StoreKit"
+  s.source_files = "ios/**/*.{h,m,mm,swift}"
+  s.frameworks   = "Security", "StoreKit", "WebKit", "CoreTelephony", "AVFoundation"
   s.swift_version = "5.5"
 
   s.dependency "React-Core"
-  s.dependency "FBSDKCoreKit", "~> 17.0"
 end

package/README.md

@@ -8,25 +8,23 @@ Paywalls, subscriptions, analytics and feature flags for React Native.
 npm install @virex-tech/paywallo-sdk
 ```
 
-Peer dependencies:
-
+iOS:
 ```bash
-npm install @react-native-async-storage/async-storage @react-native-community/netinfo react-native-iap react-native-device-info
+cd ios && pod install
 ```
 
-Optional but recommended — persists device ID across reinstalls via Keychain (iOS) and Keystore (Android):
+That's it. The SDK includes its own native modules for storage, device info and StoreKit — no extra dependencies needed.
 
-```bash
-npm install react-native-keychain
-```
+### Optional: Ad tracking (IDFA)
 
-Without it, the SDK falls back to AsyncStorage (works, but device ID resets on reinstall).
+If your app uses Facebook Ads, AppsFlyer or any attribution that needs the Apple IDFA, install the tracking transparency module:
 
-iOS only:
 ```bash
-cd ios && pod install
+npm install expo-tracking-transparency
 ```
 
+This enables the ATT prompt ("Allow this app to track your activity?"). Without it, the SDK skips IDFA collection — everything else works normally.
+
 ## Quick start
 
 ### 1. Wrap your app
@@ -48,28 +46,21 @@ export default function App() {
 }
 ```
 
-### 2. Show a paywall
+### 2. Gate content with a paywall
 
 ```tsx
-import { usePaywallo, useSubscription } from '@virex-tech/paywallo-sdk';
+import { PaywalloClient } from '@virex-tech/paywallo-sdk';
 
-function MyComponent() {
-  const { presentPaywall, hasActiveSubscription } = usePaywallo();
-  const { subscription } = useSubscription();
+const hasAccess = await PaywalloClient.requireSubscriptionWithCampaign('my-campaign');
+if (hasAccess) {
+  // User has an active subscription or just purchased
+}
+```
 
-  const handlePurchase = async () => {
-    const hasAccess = await hasActiveSubscription();
-    if (!hasAccess) {
-      await presentPaywall('default');
-    }
-  };
+### 3. Check subscription status
 
-  return (
-    <Button onPress={handlePurchase}>
-      {subscription ? 'Premium' : 'Upgrade'}
-    </Button>
-  );
-}
+```tsx
+const isActive = await PaywalloClient.hasActiveSubscription();
 ```
 
 ## Hooks
@@ -79,20 +70,32 @@ function MyComponent() {
 | Property | Type | Description |
 |---|---|---|
 | `isInitialized` | `boolean` | SDK ready |
+| `isReady` | `boolean` | SDK ready and products loaded |
 | `distinctId` | `string` | Current user ID |
-| `presentPaywall(placement)` | `Promise<PaywallResult>` | Show a paywall |
+| `presentCampaign(placement)` | `Promise<CampaignResult>` | Show a campaign paywall |
 | `hasActiveSubscription()` | `Promise<boolean>` | Check subscription status |
 | `getSubscription()` | `Promise<Subscription>` | Get subscription data |
-| `restorePurchases()` | `Promise<void>` | Restore previous purchases |
+| `restorePurchases()` | `Promise<RestoreResult>` | Restore previous purchases |
 
 ### useSubscription()
 
 | Property | Type | Description |
 |---|---|---|
 | `subscription` | `Subscription \| null` | Current subscription |
+| `hasActiveSubscription` | `boolean` | Whether subscription is active |
 | `isLoading` | `boolean` | Loading state |
 | `refresh()` | `() => void` | Refetch subscription data |
 
+### usePurchase()
+
+| Property | Type | Description |
+|---|---|---|
+| `purchase(productId)` | `Promise<PurchaseOutcome>` | Purchase a product |
+| `restore()` | `Promise<IAPPurchase[]>` | Restore purchases |
+| `isPurchasing` | `boolean` | Purchase in progress |
+| `isRestoring` | `boolean` | Restore in progress |
+| `error` | `PurchaseError \| null` | Last error |
+
 ## Imperative API
 
 For use outside React components:
@@ -100,23 +103,34 @@ For use outside React components:
 ```tsx
 import { PaywalloClient } from '@virex-tech/paywallo-sdk';
 
-await PaywalloClient.identify('user_123', { email: 'user@example.com' });
+// Identify user
+await PaywalloClient.identify({ email: 'user@example.com' });
 
-await PaywalloClient.track('purchase_completed', { product: 'premium' });
+// Track events
+await PaywalloClient.track('purchase_completed', { properties: { product: 'premium' } });
 
+// Feature flags
 const variant = await PaywalloClient.getVariant('new_feature');
+
+// Subscription gate
+const hasAccess = await PaywalloClient.requireSubscriptionWithCampaign('premium');
 ```
 
-## Types
+## Config options
 
 ```tsx
 interface PaywalloConfig {
-  appKey: string;
-  baseUrl?: string;
-  debug?: boolean;
-  environment?: 'Production' | 'Sandbox';
+  appKey: string;        // Required — your app key from the dashboard
+  apiUrl?: string;       // API URL (default: https://paywallo.com.br)
+  debug?: boolean;       // Enable debug logs (default: false)
+  autoStartSession?: boolean;  // Auto-start session on init (default: true)
+  sessionFlags?: string[];     // Flags to resolve during session start
 }
+```
+
+## Types
 
+```tsx
 interface Subscription {
   productId: string;
   status: 'active' | 'expired' | 'cancelled' | 'in_grace_period';
@@ -125,12 +139,19 @@ interface Subscription {
   autoRenewEnabled: boolean;
 }
 
-interface PaywallResult {
+interface CampaignResult {
   presented: boolean;
   purchased: boolean;
   restored: boolean;
   cancelled: boolean;
   error?: Error;
+  skippedReason?: 'subscriber';
+}
+
+interface PurchaseOutcome {
+  status: 'success' | 'cancelled' | 'failed';
+  purchase?: IAPPurchase;
+  error?: PurchaseError;
 }
 ```
 

package/android/build.gradle

@@ -22,6 +22,7 @@ android {
     defaultConfig {
         minSdkVersion safeExtGet('minSdkVersion', 24)
         targetSdkVersion safeExtGet('targetSdkVersion', 34)
+        consumerProguardFiles "consumer-rules.pro"
     }
 
     compileOptions {
@@ -51,5 +52,7 @@ dependencies {
     implementation "com.android.billingclient:billing-ktx:7.0.0"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
-    implementation "com.facebook.android:facebook-android-sdk:17.+"
+    compileOnly "com.facebook.android:facebook-android-sdk:17.+"
+    implementation "androidx.security:security-crypto:1.0.0"
+    implementation "com.android.installreferrer:installreferrer:2.2"
 }

package/android/consumer-rules.pro

@@ -0,0 +1,24 @@
+# InstallReferrer — keep callback interface used via reflection
+-keep interface com.android.installreferrer.api.InstallReferrerStateListener { *; }
+-keep class com.android.installreferrer.** { *; }
+
+# EncryptedSharedPreferences — uses reflection internally
+-keep class androidx.security.crypto.** { *; }
+
+# Paywallo SDK — keep ReactMethod-annotated methods and module classes
+-keepclassmembers class com.paywallo.sdk.** {
+    @com.facebook.react.bridge.ReactMethod <methods>;
+}
+-keep class com.paywallo.sdk.**Module { *; }
+-keep class com.paywallo.sdk.**Package { *; }
+
+# WebView classes — keep for React Native view manager and JavascriptInterface
+-keep class com.paywallo.sdk.PaywalloWebView { *; }
+-keep class com.paywallo.sdk.PaywalloWebView$WebAppInterface { *; }
+-keep class com.paywallo.sdk.PaywalloWebViewManager { *; }
+-keep class com.paywallo.sdk.PaywalloWebViewEvent { *; }
+
+# JavascriptInterface — keep annotated methods to prevent stripping
+-keepclassmembers class com.paywallo.sdk.** {
+    @android.webkit.JavascriptInterface <methods>;
+}

package/android/src/main/java/com/paywallo/sdk/PaywalloDeviceModule.kt

@@ -0,0 +1,148 @@
+package com.paywallo.sdk
+
+import com.facebook.react.bridge.*
+import android.os.Build
+import android.os.Environment
+import android.os.StatFs
+import android.app.ActivityManager
+import android.content.Context
+import android.provider.Settings
+import android.telephony.TelephonyManager
+import androidx.core.content.pm.PackageInfoCompat
+import com.android.installreferrer.api.InstallReferrerClient
+import com.android.installreferrer.api.InstallReferrerStateListener
+
+class PaywalloDeviceModule(private val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    override fun getName() = "PaywalloDevice"
+
+    @ReactMethod
+    fun getDeviceInfo(promise: Promise) {
+        try {
+            val map = Arguments.createMap()
+
+            // deviceId
+            try {
+                val deviceId = Settings.Secure.getString(
+                    reactContext.contentResolver,
+                    Settings.Secure.ANDROID_ID
+                )
+                map.putString("deviceId", if (deviceId.isNullOrEmpty()) "unknown" else deviceId)
+            } catch (e: Exception) {
+                map.putString("deviceId", "unknown")
+            }
+
+            map.putString("model", Build.MODEL ?: "unknown")
+            map.putString("modelId", Build.DEVICE ?: "unknown")
+            map.putString("systemVersion", Build.VERSION.RELEASE ?: "unknown")
+            map.putString("systemName", "Android")
+            map.putString("brand", Build.BRAND ?: "unknown")
+
+            // appVersion, buildNumber, bundleId
+            try {
+                val packageName = reactContext.packageName
+                val pm = reactContext.packageManager
+                val pkgInfo = pm.getPackageInfo(packageName, 0)
+                map.putString("appVersion", pkgInfo.versionName ?: "unknown")
+                val buildNumber = PackageInfoCompat.getLongVersionCode(pkgInfo).toString()
+                map.putString("buildNumber", buildNumber)
+                map.putString("bundleId", packageName)
+            } catch (e: Exception) {
+                map.putString("appVersion", "unknown")
+                map.putString("buildNumber", "unknown")
+                map.putString("bundleId", reactContext.packageName ?: "unknown")
+            }
+
+            // totalDisk, freeDisk
+            try {
+                val stat = StatFs(Environment.getDataDirectory().path)
+                map.putDouble("totalDisk", stat.totalBytes.toDouble())
+                map.putDouble("freeDisk", stat.availableBytes.toDouble())
+            } catch (e: Exception) {
+                map.putDouble("totalDisk", 0.0)
+                map.putDouble("freeDisk", 0.0)
+            }
+
+            // totalRam
+            try {
+                val activityManager = reactContext.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
+                val memInfo = ActivityManager.MemoryInfo()
+                activityManager.getMemoryInfo(memInfo)
+                map.putDouble("totalRam", memInfo.totalMem.toDouble())
+            } catch (e: Exception) {
+                map.putDouble("totalRam", 0.0)
+            }
+
+            // carrier
+            try {
+                val tm = reactContext.getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager
+                val carrier = tm.networkOperatorName
+                map.putString("carrier", if (carrier.isNullOrEmpty()) "unknown" else carrier)
+            } catch (e: Exception) {
+                map.putString("carrier", "unknown")
+            }
+
+            // installerPackage
+            try {
+                val packageName = reactContext.packageName
+                val pm = reactContext.packageManager
+                val installer = pm.getInstallerPackageName(packageName)
+                if (installer != null) {
+                    map.putString("installerPackage", installer)
+                } else {
+                    map.putNull("installerPackage")
+                }
+            } catch (e: Exception) {
+                map.putNull("installerPackage")
+            }
+
+            // idfv — iOS-only concept
+            map.putNull("idfv")
+
+            promise.resolve(map)
+        } catch (e: Exception) {
+            promise.resolve(Arguments.createMap())
+        }
+    }
+
+    @ReactMethod
+    fun getInstallReferrer(promise: Promise) {
+        try {
+            val client = InstallReferrerClient.newBuilder(reactContext).build()
+            // resolved tracks whether the promise was already settled to prevent
+            // double-resolve when endConnection() triggers onInstallReferrerServiceDisconnected
+            var resolved = false
+
+            client.startConnection(object : InstallReferrerStateListener {
+                override fun onInstallReferrerSetupFinished(responseCode: Int) {
+                    if (resolved) return
+                    if (responseCode == InstallReferrerClient.InstallReferrerResponse.OK) {
+                        try {
+                            val referrer = client.installReferrer.installReferrer
+                            resolved = true
+                            promise.resolve(referrer)
+                        } catch (e: Exception) {
+                            resolved = true
+                            promise.resolve(null)
+                        } finally {
+                            client.endConnection()
+                        }
+                    } else {
+                        resolved = true
+                        client.endConnection()
+                        promise.resolve(null)
+                    }
+                }
+
+                override fun onInstallReferrerServiceDisconnected() {
+                    if (resolved) return
+                    resolved = true
+                    promise.resolve(null)
+                }
+            })
+        } catch (e: Exception) {
+            promise.resolve(null)
+        }
+    }
+}

package/android/src/main/java/com/paywallo/sdk/PaywalloFBBridgeModule.kt

@@ -20,7 +20,8 @@ class PaywalloFBBridgeModule(private val reactContext: ReactApplicationContext)
             } else {
                 promise.resolve(anonId)
             }
-        } catch (e: Exception) {
+        } catch (t: Throwable) {
+            // catches NoClassDefFoundError when Facebook SDK is not present at runtime
             promise.resolve(null)
         }
     }
@@ -32,7 +33,8 @@ class PaywalloFBBridgeModule(private val reactContext: ReactApplicationContext)
             val logger = AppEventsLogger.newLogger(reactApplicationContext)
             logger.logEvent(name, bundle)
             promise.resolve(null)
-        } catch (e: Exception) {
+        } catch (t: Throwable) {
+            // catches NoClassDefFoundError when Facebook SDK is not present at runtime
             promise.resolve(null)
         }
     }
@@ -44,7 +46,8 @@ class PaywalloFBBridgeModule(private val reactContext: ReactApplicationContext)
             val logger = AppEventsLogger.newLogger(reactApplicationContext)
             logger.logPurchase(BigDecimal.valueOf(amount), Currency.getInstance(currency), bundle)
             promise.resolve(null)
-        } catch (e: Exception) {
+        } catch (t: Throwable) {
+            // catches NoClassDefFoundError when Facebook SDK is not present at runtime
             promise.resolve(null)
         }
     }
@@ -53,8 +56,8 @@ class PaywalloFBBridgeModule(private val reactContext: ReactApplicationContext)
     fun setUserID(userId: String) {
         try {
             AppEventsLogger.setUserID(userId)
-        } catch (e: Exception) {
-            // never crash
+        } catch (t: Throwable) {
+            // catches NoClassDefFoundError when Facebook SDK is not present at runtime
         }
     }
 
@@ -62,8 +65,8 @@ class PaywalloFBBridgeModule(private val reactContext: ReactApplicationContext)
     fun flush() {
         try {
             AppEventsLogger.newLogger(reactApplicationContext).flush()
-        } catch (e: Exception) {
-            // never crash
+        } catch (t: Throwable) {
+            // catches NoClassDefFoundError when Facebook SDK is not present at runtime
         }
     }
 

package/android/src/main/java/com/paywallo/sdk/PaywalloSdkPackage.kt

@@ -9,7 +9,9 @@ class PaywalloSdkPackage : ReactPackage {
     override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
         return listOf(
             PaywalloStoreKitModule(reactContext),
-            PaywalloFBBridgeModule(reactContext)
+            PaywalloFBBridgeModule(reactContext),
+            PaywalloStorageModule(reactContext),
+            PaywalloDeviceModule(reactContext)
         )
     }
 

package/android/src/main/java/com/paywallo/sdk/PaywalloStorageModule.kt

@@ -0,0 +1,106 @@
+package com.paywallo.sdk
+
+import android.content.SharedPreferences
+import android.util.Log
+import androidx.security.crypto.EncryptedSharedPreferences
+import androidx.security.crypto.MasterKey
+import com.facebook.react.bridge.*
+
+class PaywalloStorageModule(private val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    override fun getName() = "PaywalloStorage"
+
+    private val TAG = "PaywalloStorage"
+    private val SECURE_FILE = "paywallo_secure"
+    private val REGULAR_FILE = "paywallo_storage"
+    // No prefix — TypeScript layer handles prefixing
+
+    private val encryptedPrefs: SharedPreferences by lazy {
+        try {
+            val masterKey = MasterKey.Builder(reactContext)
+                .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
+                .build()
+            EncryptedSharedPreferences.create(
+                reactContext,
+                SECURE_FILE,
+                masterKey,
+                EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
+                EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
+            )
+        } catch (e: Exception) {
+            Log.w(TAG, "EncryptedSharedPreferences unavailable, falling back to regular prefs: ${e.message}")
+            reactContext.getSharedPreferences(SECURE_FILE, android.content.Context.MODE_PRIVATE)
+        }
+    }
+
+    private val regularPrefs: SharedPreferences by lazy {
+        reactContext.getSharedPreferences(REGULAR_FILE, android.content.Context.MODE_PRIVATE)
+    }
+
+    @ReactMethod
+    fun secureGet(key: String, promise: Promise) {
+        try {
+            val value = encryptedPrefs.getString(key, null)
+            promise.resolve(value)
+        } catch (e: Exception) {
+            Log.w(TAG, "secureGet failed: ${e.message}")
+            promise.resolve(null)
+        }
+    }
+
+    @ReactMethod
+    fun secureSet(key: String, value: String, promise: Promise) {
+        try {
+            encryptedPrefs.edit().putString(key, value).apply()
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.w(TAG, "secureSet failed: ${e.message}")
+            promise.resolve(false)
+        }
+    }
+
+    @ReactMethod
+    fun secureRemove(key: String, promise: Promise) {
+        try {
+            encryptedPrefs.edit().remove(key).apply()
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.w(TAG, "secureRemove failed: ${e.message}")
+            promise.resolve(false)
+        }
+    }
+
+    @ReactMethod
+    fun get(key: String, promise: Promise) {
+        try {
+            val value = regularPrefs.getString(key, null)
+            promise.resolve(value)
+        } catch (e: Exception) {
+            Log.w(TAG, "get failed: ${e.message}")
+            promise.resolve(null)
+        }
+    }
+
+    @ReactMethod
+    fun set(key: String, value: String, promise: Promise) {
+        try {
+            regularPrefs.edit().putString(key, value).apply()
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.w(TAG, "set failed: ${e.message}")
+            promise.resolve(false)
+        }
+    }
+
+    @ReactMethod
+    fun remove(key: String, promise: Promise) {
+        try {
+            regularPrefs.edit().remove(key).apply()
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.w(TAG, "remove failed: ${e.message}")
+            promise.resolve(false)
+        }
+    }
+}

package/android/src/main/java/com/paywallo/sdk/PaywalloStoreKitModule.kt

@@ -174,6 +174,9 @@ class PaywalloStoreKitModule(private val reactContext: ReactApplicationContext)
                     return@launch
                 }
 
+                // If there's already a pending purchase, reject the previous promise
+                // before overwriting it to avoid orphaned promises
+                purchasePromise?.reject("PURCHASE_CANCELLED", "Superseded by a new purchase request")
                 purchasePromise = promise
 
                 val flowParamsBuilder = BillingFlowParams.newBuilder()
@@ -246,14 +249,19 @@ class PaywalloStoreKitModule(private val reactContext: ReactApplicationContext)
 
                 val client = billingClient!!
 
-                // Query purchases to find the one to acknowledge
+                // Query both SUBS and INAPP purchases — one-time purchases also need acknowledgement
                 val subsResult = client.queryPurchasesAsync(
                     QueryPurchasesParams.newBuilder()
                         .setProductType(BillingClient.ProductType.SUBS)
                         .build()
                 )
+                val inappResult = client.queryPurchasesAsync(
+                    QueryPurchasesParams.newBuilder()
+                        .setProductType(BillingClient.ProductType.INAPP)
+                        .build()
+                )
 
-                val allPurchases = subsResult.purchasesList
+                val allPurchases = subsResult.purchasesList + inappResult.purchasesList
 
                 val purchase = allPurchases.firstOrNull {
                     it.orderId == transactionId || it.purchaseToken == transactionId
@@ -317,6 +325,9 @@ class PaywalloStoreKitModule(private val reactContext: ReactApplicationContext)
     }
 
     override fun onCatalystInstanceDestroy() {
+        // Reject any pending purchase promise so the JS side doesn't hang forever
+        purchasePromise?.reject("MODULE_DESTROYED", "Module was destroyed before purchase completed")
+        purchasePromise = null
         scope.cancel()
         billingClient?.endConnection()
         billingClient = null

package/android/src/main/java/com/paywallo/sdk/PaywalloWebView.kt

@@ -13,6 +13,7 @@ import android.webkit.WebView
 import android.webkit.WebViewClient
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReactContext
+import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.uimanager.events.RCTEventEmitter
 import org.json.JSONObject
 
@@ -30,11 +31,36 @@ class PaywalloWebView(context: ReactContext) : WebView(context) {
             javaScriptEnabled = true
             domStorageEnabled = true
             mediaPlaybackRequiresUserGesture = false
-            mixedContentMode = WebSettings.MIXED_CONTENT_ALWAYS_ALLOW
+            mixedContentMode = WebSettings.MIXED_CONTENT_NEVER_ALLOW
             cacheMode = WebSettings.LOAD_DEFAULT
         }
 
         webViewClient = object : WebViewClient() {
+            // Allow HTTPS and about: (initial blank) to load inside the WebView.
+            // Redirect mailto:, intent:, and market: to the OS. Block everything else
+            // (plain HTTP, javascript:, data:, blob:) to prevent mixed-content and injection.
+            override fun shouldOverrideUrlLoading(view: WebView?, request: WebResourceRequest?): Boolean {
+                val uri = request?.url ?: return true
+                val scheme = uri.scheme?.lowercase()
+
+                val osSchemes = setOf("mailto", "intent", "market")
+                if (scheme != null && scheme in osSchemes) {
+                    try {
+                        val intent = android.content.Intent(android.content.Intent.ACTION_VIEW, uri)
+                        intent.addFlags(android.content.Intent.FLAG_ACTIVITY_NEW_TASK)
+                        context.startActivity(intent)
+                    } catch (_: Exception) {
+                        // No app installed to handle this scheme — silently ignore.
+                    }
+                    return true // prevent WebView from loading it
+                }
+
+                if (scheme != null && scheme != "https" && scheme != "about") {
+                    return true // block the navigation
+                }
+                return false
+            }
+
             override fun onPageFinished(view: WebView?, url: String?) {
                 super.onPageFinished(view, url)
                 dispatchEvent("onLoadEnd", null)
@@ -88,6 +114,7 @@ class PaywalloWebView(context: ReactContext) : WebView(context) {
     private var pendingHtml: String? = null
 
     fun setSourceUrl(url: String?) {
+        // Only load URL if no inline HTML has been set — HTML takes precedence over URL
         if (pendingHtml.isNullOrEmpty()) {
             url?.let { loadUrl(it) }
         }
@@ -106,8 +133,17 @@ class PaywalloWebView(context: ReactContext) : WebView(context) {
         val event = Arguments.createMap().apply {
             data?.let { putString("data", it) }
         }
-        reactContext.getJSModule(RCTEventEmitter::class.java)
-            .receiveEvent(id, eventName, event)
+        // UIManagerHelper is the New Architecture path; fall back to legacy RCTEventEmitter
+        // for compatibility with React Native < 0.71 (Old Architecture)
+        val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, id)
+        if (dispatcher != null) {
+            val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
+            dispatcher.dispatchEvent(PaywalloWebViewEvent(surfaceId, id, eventName, event))
+        } else {
+            @Suppress("DEPRECATION")
+            reactContext.getJSModule(RCTEventEmitter::class.java)
+                ?.receiveEvent(id, eventName, event)
+        }
     }
 
     inner class WebAppInterface {