react-native-revnix 1.4.0 → 1.5.0

package/android/build.gradle

@@ -0,0 +1,34 @@
+apply plugin: "com.android.library"
+apply plugin: "org.jetbrains.kotlin.android"
+
+def safeExtGet(prop, fallback) {
+  rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+android {
+  namespace "com.revnix.reactnative"
+  compileSdkVersion safeExtGet("compileSdkVersion", 35)
+
+  defaultConfig {
+    minSdkVersion safeExtGet("minSdkVersion", 24)
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = "17"
+  }
+}
+
+repositories {
+  google()
+  mavenCentral()
+}
+
+dependencies {
+  implementation "com.facebook.react:react-native:+"
+  implementation "com.android.billingclient:billing:8.3.0"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest />

package/android/src/main/kotlin/com/revnix/reactnative/RevnixStoreModule.kt

@@ -0,0 +1,247 @@
+package com.revnix.reactnative
+
+import android.util.Log
+import com.android.billingclient.api.AcknowledgePurchaseParams
+import com.android.billingclient.api.BillingClient
+import com.android.billingclient.api.BillingClient.BillingResponseCode
+import com.android.billingclient.api.BillingClient.ProductType
+import com.android.billingclient.api.BillingClientStateListener
+import com.android.billingclient.api.BillingFlowParams
+import com.android.billingclient.api.BillingResult
+import com.android.billingclient.api.PendingPurchasesParams
+import com.android.billingclient.api.ProductDetails
+import com.android.billingclient.api.Purchase
+import com.android.billingclient.api.PurchasesUpdatedListener
+import com.android.billingclient.api.QueryProductDetailsParams
+import com.android.billingclient.api.QueryPurchasesParams
+import com.facebook.react.bridge.Arguments
+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.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicReference
+
+class RevnixStoreModule(context: ReactApplicationContext) :
+  ReactContextBaseJavaModule(context), PurchasesUpdatedListener {
+
+  private class PendingPurchase(val productId: String, val promise: Promise)
+
+  private val pending = AtomicReference<PendingPurchase?>(null)
+  private val acknowledged = ConcurrentHashMap.newKeySet<String>()
+  private val waitingForSetup = mutableListOf<(BillingResult) -> Unit>()
+
+  private val billing: BillingClient = BillingClient.newBuilder(context)
+    .setListener(this)
+    .enablePendingPurchases(PendingPurchasesParams.newBuilder().enableOneTimeProducts().build())
+    .enableAutoServiceReconnection()
+    .build()
+
+  override fun getName() = "RevnixStore"
+
+  override fun invalidate() {
+    billing.endConnection()
+  }
+
+  @ReactMethod
+  fun addListener(eventName: String) {
+    withBilling {}
+  }
+
+  @ReactMethod
+  fun removeListeners(count: Int) {}
+
+  @ReactMethod
+  fun purchase(productId: String, customerId: String, promise: Promise) {
+    withBilling { setup ->
+      if (setup.responseCode != BillingResponseCode.OK) {
+        promise.reject("store_error", setup.debugMessage)
+        return@withBilling
+      }
+      queryProduct(productId, ProductType.SUBS) { subs ->
+        if (subs != null) {
+          launch(subs, customerId, promise)
+          return@queryProduct
+        }
+        queryProduct(productId, ProductType.INAPP) { inapp ->
+          if (inapp != null) launch(inapp, customerId, promise)
+          else promise.reject("product_not_found", "No Play product with id $productId")
+        }
+      }
+    }
+  }
+
+  @ReactMethod
+  fun restore(promise: Promise) {
+    withBilling { setup ->
+      if (setup.responseCode != BillingResponseCode.OK) {
+        promise.reject("store_error", setup.debugMessage)
+        return@withBilling
+      }
+      val restored = Arguments.createArray()
+      queryPurchases(ProductType.SUBS) { subs ->
+        subs.forEach { restored.pushMap(toMap(it)) }
+        queryPurchases(ProductType.INAPP) { inapp ->
+          inapp.forEach { restored.pushMap(toMap(it)) }
+          promise.resolve(restored)
+        }
+      }
+    }
+  }
+
+  // ponytail: acknowledges every purchase; consumable INAPP products need consumeAsync to be bought again
+  @ReactMethod
+  fun finish(purchaseToken: String, promise: Promise) {
+    if (purchaseToken in acknowledged) {
+      promise.resolve(null)
+      return
+    }
+    withBilling { setup ->
+      if (setup.responseCode != BillingResponseCode.OK) {
+        promise.reject("store_error", "${setup.responseCode} ${setup.debugMessage}")
+        return@withBilling
+      }
+      val params = AcknowledgePurchaseParams.newBuilder().setPurchaseToken(purchaseToken).build()
+      billing.acknowledgePurchase(params) { result ->
+        if (result.responseCode == BillingResponseCode.OK) {
+          acknowledged.add(purchaseToken)
+          promise.resolve(null)
+        } else {
+          promise.reject("store_error", "acknowledgePurchase failed: ${result.responseCode} ${result.debugMessage}")
+        }
+      }
+    }
+  }
+
+  override fun onPurchasesUpdated(result: BillingResult, purchases: List<Purchase>?) {
+    if (result.responseCode != BillingResponseCode.OK) {
+      settle(pending.getAndSet(null) ?: return, result)
+      return
+    }
+    for (purchase in purchases.orEmpty()) {
+      val waiting = pending.get()
+      if (waiting != null && purchase.products.contains(waiting.productId) &&
+        pending.compareAndSet(waiting, null)
+      ) {
+        val purchased = purchase.purchaseState == Purchase.PurchaseState.PURCHASED
+        waiting.promise.resolve(if (purchased) toMap(purchase) else null)
+      } else if (purchase.purchaseState == Purchase.PurchaseState.PURCHASED) {
+        emit(toMap(purchase))
+      }
+    }
+  }
+
+  private fun withBilling(onReady: (BillingResult) -> Unit) {
+    if (billing.isReady) {
+      onReady(BillingResult.newBuilder().setResponseCode(BillingResponseCode.OK).build())
+      return
+    }
+    synchronized(waitingForSetup) {
+      waitingForSetup.add(onReady)
+      if (waitingForSetup.size > 1) return
+    }
+    billing.startConnection(object : BillingClientStateListener {
+      override fun onBillingSetupFinished(result: BillingResult) {
+        val ready = synchronized(waitingForSetup) {
+          waitingForSetup.toList().also { waitingForSetup.clear() }
+        }
+        if (result.responseCode == BillingResponseCode.OK) {
+          queryPurchases(ProductType.SUBS) { subs ->
+            queryPurchases(ProductType.INAPP) { inapp ->
+              (subs + inapp).filterNot { it.isAcknowledged }.forEach { emit(toMap(it)) }
+            }
+          }
+        }
+        ready.forEach { it(result) }
+      }
+
+      override fun onBillingServiceDisconnected() {}
+    })
+  }
+
+  private fun settle(waiting: PendingPurchase, result: BillingResult) {
+    when (result.responseCode) {
+      BillingResponseCode.USER_CANCELED -> waiting.promise.resolve(null)
+      BillingResponseCode.ITEM_ALREADY_OWNED -> queryPurchases(ProductType.SUBS) { subs ->
+        queryPurchases(ProductType.INAPP) { inapp ->
+          val owned = (subs + inapp).firstOrNull { waiting.productId in it.products }
+          if (owned != null) waiting.promise.resolve(toMap(owned))
+          else waiting.promise.reject("store_error", "${result.responseCode} ${result.debugMessage}")
+        }
+      }
+      else -> waiting.promise.reject("store_error", "${result.responseCode} ${result.debugMessage}")
+    }
+  }
+
+  private fun queryProduct(productId: String, type: String, then: (ProductDetails?) -> Unit) {
+    val product = QueryProductDetailsParams.Product.newBuilder()
+      .setProductId(productId)
+      .setProductType(type)
+      .build()
+    val params = QueryProductDetailsParams.newBuilder().setProductList(listOf(product)).build()
+    billing.queryProductDetailsAsync(params) { _, details ->
+      then(details.productDetailsList.firstOrNull())
+    }
+  }
+
+  private fun queryPurchases(type: String, then: (List<Purchase>) -> Unit) {
+    val params = QueryPurchasesParams.newBuilder().setProductType(type).build()
+    billing.queryPurchasesAsync(params) { result, purchases ->
+      if (result.responseCode != BillingResponseCode.OK) {
+        Log.w(TAG, "queryPurchases($type) failed: ${result.responseCode} ${result.debugMessage}")
+      }
+      then(purchases.filter { it.purchaseState == Purchase.PurchaseState.PURCHASED })
+    }
+  }
+
+  private fun launch(details: ProductDetails, customerId: String, promise: Promise) {
+    val activity = reactApplicationContext.currentActivity
+    if (activity == null) {
+      promise.reject("no_activity", "No foreground Activity to show Google Play billing")
+      return
+    }
+    val productParams = BillingFlowParams.ProductDetailsParams.newBuilder()
+      .setProductDetails(details)
+      .apply {
+        // ponytail: first base plan/offer wins; products with several base plans need a basePlanId/offerId selector passed through purchase()
+        details.subscriptionOfferDetails?.firstOrNull()?.let { setOfferToken(it.offerToken) }
+      }
+      .build()
+    val params = BillingFlowParams.newBuilder()
+      .setProductDetailsParamsList(listOf(productParams))
+      .setObfuscatedAccountId(customerId)
+      .build()
+    activity.runOnUiThread {
+      val waiting = PendingPurchase(details.productId, promise)
+      pending.getAndSet(waiting)?.promise?.resolve(null)
+      val result = billing.launchBillingFlow(activity, params)
+      if (result.responseCode != BillingResponseCode.OK && pending.compareAndSet(waiting, null)) {
+        settle(waiting, result)
+      }
+    }
+  }
+
+  private fun toMap(purchase: Purchase): WritableMap {
+    if (purchase.isAcknowledged) acknowledged.add(purchase.purchaseToken)
+    return Arguments.createMap().apply {
+      putString("store", "google")
+      putString("productId", purchase.products.firstOrNull())
+      putString("transactionId", purchase.purchaseToken)
+      putString("token", purchase.purchaseToken)
+      putDouble("occurredAt", purchase.purchaseTime.toDouble())
+    }
+  }
+
+  private fun emit(transaction: WritableMap) {
+    if (!reactApplicationContext.hasActiveReactInstance()) return
+    reactApplicationContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit("revnixStoreTransaction", transaction)
+  }
+
+  private companion object {
+    const val TAG = "RevnixStore"
+  }
+}

package/android/src/main/kotlin/com/revnix/reactnative/RevnixStorePackage.kt

@@ -0,0 +1,14 @@
+package com.revnix.reactnative
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class RevnixStorePackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
+    listOf(RevnixStoreModule(reactContext))
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
+    emptyList()
+}

package/dist/client.d.ts

@@ -33,6 +33,7 @@ export declare class RevnixClient {
     private implicitConfigPromise;
     private implicitConfigRetryAt;
     private lifecycleUnsubscribe;
+    private stopStoreObserver;
     /** The cold-start batch while it runs, resolving to whether it presented a
      *  paywall. A deep link delivered on the first frame — SwiftUI's onOpenURL,
      *  RN's getInitialURL — must wait for it, or the customer gets the launch
@@ -90,6 +91,17 @@ export declare class RevnixClient {
      *  PurchaseBlockedError when the token belongs to another customer and the
      *  app's transfer behavior forbids reassignment. */
     registerPurchase(input: RegisterPurchaseInput): Promise<RegisterPurchaseResult>;
+    /** Buys `productId` through the native store (StoreKit 2 / Play Billing),
+     *  registers it with Revnix, then finishes the store transaction. Resolves
+     *  null when the customer cancelled or the purchase is pending approval.
+     *  Needs `import "react-native-revnix/store"` before configure(). A refused
+     *  claim (PurchaseBlockedError) is never finished, so Google refunds it. */
+    purchase(productId: string, opts?: Pick<RegisterPurchaseInput, "viewId" | "paywallId" | "placementKey">): Promise<RegisterPurchaseResult | null>;
+    /** Re-registers every purchase the store still holds for this device and
+     *  resolves how many registered. Per-purchase failures go to onDiagnostic. */
+    restore(): Promise<number>;
+    private requireStore;
+    private registerStoreTransaction;
     private postPurchase;
     /** C7: retry purchases that failed to register and were persisted locally.
      *  Runs automatically at construction; call again when connectivity returns.

package/dist/client.js

@@ -5,6 +5,7 @@ const errors_js_1 = require("./errors.js");
 const storage_js_1 = require("./storage.js");
 const device_js_1 = require("./device.js");
 const version_js_1 = require("./version.js");
+const store_js_1 = require("./store.js");
 const implicit_js_1 = require("./implicit.js");
 const CUSTOMER_ID_KEY = "revnix.customerId";
 const SESSION_STARTED_AT_KEY = "revnix.sessionStartedAt";
@@ -75,6 +76,7 @@ class RevnixClient {
         this.implicitConfigPromise = null;
         this.implicitConfigRetryAt = 0;
         this.lifecycleUnsubscribe = null;
+        this.stopStoreObserver = null;
         /** The cold-start batch while it runs, resolving to whether it presented a
          *  paywall. A deep link delivered on the first frame — SwiftUI's onOpenURL,
          *  RN's getInitialURL — must wait for it, or the customer gets the launch
@@ -151,6 +153,10 @@ class RevnixClient {
         // C7: retry any purchases that failed to register on a previous launch, so
         // a paying user never stays locked out because a POST didn't land.
         void this.retryPendingPurchases().catch((err) => this.diag("retryPendingPurchases", err));
+        const store = (0, store_js_1.getStoreAdapter)();
+        if (store) {
+            this.stopStoreObserver = store.observe((tx) => void this.registerStoreTransaction(store, tx).catch((err) => this.diag("storeObserver", err)));
+        }
         // REV-157: warm the placement cache at launch, so the first paywall of the
         // session can render offline. Fire-and-forget; a failed key just stays on
         // whatever an earlier launch cached.
@@ -293,6 +299,66 @@ class RevnixClient {
             throw err;
         }
     }
+    /** Buys `productId` through the native store (StoreKit 2 / Play Billing),
+     *  registers it with Revnix, then finishes the store transaction. Resolves
+     *  null when the customer cancelled or the purchase is pending approval.
+     *  Needs `import "react-native-revnix/store"` before configure(). A refused
+     *  claim (PurchaseBlockedError) is never finished, so Google refunds it. */
+    async purchase(productId, opts) {
+        const store = this.requireStore();
+        const customerId = await this.customerIdPromise;
+        const tx = await store.purchase(productId, { customerId });
+        if (!tx)
+            return null;
+        return this.registerStoreTransaction(store, tx, opts);
+    }
+    /** Re-registers every purchase the store still holds for this device and
+     *  resolves how many registered. Per-purchase failures go to onDiagnostic. */
+    async restore() {
+        const store = this.requireStore();
+        let restored = 0;
+        for (const tx of await store.restore()) {
+            try {
+                await this.registerStoreTransaction(store, tx, undefined, tx.store === "google");
+                restored += 1;
+            }
+            catch (err) {
+                this.diag("storeRestore", err);
+            }
+        }
+        return restored;
+    }
+    requireStore() {
+        const store = (0, store_js_1.getStoreAdapter)();
+        if (!store) {
+            throw new Error('Revnix: native purchases need `import "react-native-revnix/store"` before Revnix.configure(...) and a rebuilt app (pod install / Expo development build)');
+        }
+        return store;
+    }
+    async registerStoreTransaction(store, tx, opts, finish = true) {
+        const finishTx = () => finish
+            ? store.finish(tx.transactionId).catch((err) => this.diag("storeFinish", err))
+            : undefined;
+        try {
+            const result = await this.registerPurchase({
+                source: tx.store,
+                token: tx.token,
+                productId: tx.productId,
+                transactionId: tx.transactionId,
+                occurredAt: tx.occurredAt,
+                expiresAt: tx.expiresAt,
+                signedTransactionInfo: tx.signedTransactionInfo,
+                ...opts,
+            });
+            await finishTx();
+            return result;
+        }
+        catch (err) {
+            if (!(err instanceof errors_js_1.PurchaseBlockedError))
+                await finishTx();
+            throw err;
+        }
+    }
     postPurchase(customerId, input) {
         return this.request("POST", "/v1/purchases", {
             customerId,
@@ -1255,6 +1321,8 @@ class RevnixClient {
         // every return alongside its successor.
         this.lifecycleUnsubscribe?.();
         this.lifecycleUnsubscribe = null;
+        this.stopStoreObserver?.();
+        this.stopStoreObserver = null;
     }
     /** A block paywall reporting a paint string it could not read. Routed to the
      *  same sink as every other swallowed failure, so a host that already wired
@@ -1592,7 +1660,7 @@ class RevnixClient {
                     Authorization: `Bearer ${this.apiKey}`,
                     // L3: identify the SDK on EVERY request (reads included) so the
                     // backend can triage by version without depending on body fields.
-                    "X-Revnix-SDK": `revnix-react/${version_js_1.SDK_VERSION}`,
+                    "X-Revnix-SDK": `react-native-revnix/${version_js_1.SDK_VERSION}`,
                     ...(reportedBgFailures > 0
                         ? { "X-Revnix-Bg-Failures": String(reportedBgFailures) }
                         : {}),

package/dist/esm/client.js

@@ -2,6 +2,7 @@ import { PurchaseBlockedError, RevnixAuthError, RevnixError, RevnixNetworkError,
 import { generateAnonymousId, generateEventId, generateViewId, resolveStorage, } from "./storage.js";
 import { DEVICE_HEADER, INSTALLED_AT_KEY, compactPayload, detectDeviceFacts, encodeDeviceHeader, } from "./device.js";
 import { SDK_VERSION } from "./version.js";
+import { getStoreAdapter, } from "./store.js";
 import { browserLifecycle, DEFAULT_SESSION_TIMEOUT_MS, IMPLICIT_CONFIG_RETRY_MS, IMPLICIT_PLACEMENTS, PREVIEW_PLACEMENT_KEY, } from "./implicit.js";
 const CUSTOMER_ID_KEY = "revnix.customerId";
 const SESSION_STARTED_AT_KEY = "revnix.sessionStartedAt";
@@ -72,6 +73,7 @@ export class RevnixClient {
         this.implicitConfigPromise = null;
         this.implicitConfigRetryAt = 0;
         this.lifecycleUnsubscribe = null;
+        this.stopStoreObserver = null;
         /** The cold-start batch while it runs, resolving to whether it presented a
          *  paywall. A deep link delivered on the first frame — SwiftUI's onOpenURL,
          *  RN's getInitialURL — must wait for it, or the customer gets the launch
@@ -148,6 +150,10 @@ export class RevnixClient {
         // C7: retry any purchases that failed to register on a previous launch, so
         // a paying user never stays locked out because a POST didn't land.
         void this.retryPendingPurchases().catch((err) => this.diag("retryPendingPurchases", err));
+        const store = getStoreAdapter();
+        if (store) {
+            this.stopStoreObserver = store.observe((tx) => void this.registerStoreTransaction(store, tx).catch((err) => this.diag("storeObserver", err)));
+        }
         // REV-157: warm the placement cache at launch, so the first paywall of the
         // session can render offline. Fire-and-forget; a failed key just stays on
         // whatever an earlier launch cached.
@@ -290,6 +296,66 @@ export class RevnixClient {
             throw err;
         }
     }
+    /** Buys `productId` through the native store (StoreKit 2 / Play Billing),
+     *  registers it with Revnix, then finishes the store transaction. Resolves
+     *  null when the customer cancelled or the purchase is pending approval.
+     *  Needs `import "react-native-revnix/store"` before configure(). A refused
+     *  claim (PurchaseBlockedError) is never finished, so Google refunds it. */
+    async purchase(productId, opts) {
+        const store = this.requireStore();
+        const customerId = await this.customerIdPromise;
+        const tx = await store.purchase(productId, { customerId });
+        if (!tx)
+            return null;
+        return this.registerStoreTransaction(store, tx, opts);
+    }
+    /** Re-registers every purchase the store still holds for this device and
+     *  resolves how many registered. Per-purchase failures go to onDiagnostic. */
+    async restore() {
+        const store = this.requireStore();
+        let restored = 0;
+        for (const tx of await store.restore()) {
+            try {
+                await this.registerStoreTransaction(store, tx, undefined, tx.store === "google");
+                restored += 1;
+            }
+            catch (err) {
+                this.diag("storeRestore", err);
+            }
+        }
+        return restored;
+    }
+    requireStore() {
+        const store = getStoreAdapter();
+        if (!store) {
+            throw new Error('Revnix: native purchases need `import "react-native-revnix/store"` before Revnix.configure(...) and a rebuilt app (pod install / Expo development build)');
+        }
+        return store;
+    }
+    async registerStoreTransaction(store, tx, opts, finish = true) {
+        const finishTx = () => finish
+            ? store.finish(tx.transactionId).catch((err) => this.diag("storeFinish", err))
+            : undefined;
+        try {
+            const result = await this.registerPurchase({
+                source: tx.store,
+                token: tx.token,
+                productId: tx.productId,
+                transactionId: tx.transactionId,
+                occurredAt: tx.occurredAt,
+                expiresAt: tx.expiresAt,
+                signedTransactionInfo: tx.signedTransactionInfo,
+                ...opts,
+            });
+            await finishTx();
+            return result;
+        }
+        catch (err) {
+            if (!(err instanceof PurchaseBlockedError))
+                await finishTx();
+            throw err;
+        }
+    }
     postPurchase(customerId, input) {
         return this.request("POST", "/v1/purchases", {
             customerId,
@@ -1252,6 +1318,8 @@ export class RevnixClient {
         // every return alongside its successor.
         this.lifecycleUnsubscribe?.();
         this.lifecycleUnsubscribe = null;
+        this.stopStoreObserver?.();
+        this.stopStoreObserver = null;
     }
     /** A block paywall reporting a paint string it could not read. Routed to the
      *  same sink as every other swallowed failure, so a host that already wired
@@ -1589,7 +1657,7 @@ export class RevnixClient {
                     Authorization: `Bearer ${this.apiKey}`,
                     // L3: identify the SDK on EVERY request (reads included) so the
                     // backend can triage by version without depending on body fields.
-                    "X-Revnix-SDK": `revnix-react/${SDK_VERSION}`,
+                    "X-Revnix-SDK": `react-native-revnix/${SDK_VERSION}`,
                     ...(reportedBgFailures > 0
                         ? { "X-Revnix-Bg-Failures": String(reportedBgFailures) }
                         : {}),

package/dist/esm/index.js

@@ -3,6 +3,7 @@ import { setLocale } from "./blocks/locale.js";
 export { RevnixClient } from "./client.js";
 export { PurchaseBlockedError, RevnixAuthError, RevnixError, RevnixNetworkError, RevnixRateLimitError, RevnixTimeoutError, } from "./errors.js";
 export { purchaseInputFromIap } from "./iap.js";
+export { setStoreAdapter, } from "./store.js";
 export { memoryStorage, generateAnonymousId } from "./storage.js";
 export { SDK_VERSION } from "./version.js";
 export { DEVICE_HEADER, encodeDeviceHeader } from "./device.js";

package/dist/esm/store/index.js

@@ -0,0 +1,22 @@
+import { NativeEventEmitter, NativeModules } from "react-native";
+import { setStoreAdapter, } from "../store.js";
+const native = NativeModules.RevnixStore;
+const missing = () => Promise.reject(new Error("Revnix: RevnixStore native module not found. Run pod install / rebuild the app (Expo: use a development build)."));
+export const RevnixStore = native
+    ? {
+        purchase: (productId, { customerId }) => native.purchase(productId, customerId),
+        restore: () => native.restore(),
+        finish: (transactionId) => native.finish(transactionId),
+        observe(onTransaction) {
+            const sub = new NativeEventEmitter(NativeModules.RevnixStore).addListener("revnixStoreTransaction", (tx) => onTransaction(tx));
+            return () => sub.remove();
+        },
+    }
+    : {
+        purchase: missing,
+        restore: missing,
+        finish: missing,
+        observe: () => () => { },
+    };
+if (native)
+    setStoreAdapter(RevnixStore);

package/dist/esm/store.js

@@ -0,0 +1,9 @@
+let adapter = null;
+/** Installs the store that `RevnixClient.purchase()` / `restore()` drive.
+ *  `import "react-native-revnix/store"` calls this with the native bridge. */
+export function setStoreAdapter(next) {
+    adapter = next;
+}
+export function getStoreAdapter() {
+    return adapter;
+}

package/dist/esm/ui/RevnixPaywall.js

@@ -12,11 +12,12 @@
 // An unrecognized template (config published by a newer dashboard) falls
 // back to the classic structure instead of rendering nothing.
 //
-// Import from "revnix-react/ui" — the core entrypoint stays free of
+// Import from "react-native-revnix/ui" — the core entrypoint stays free of
 // react / react-native so non-RN consumers are unaffected.
 import * as React from "react";
 import { ActivityIndicator, Alert, Image, Linking, Pressable, ScrollView, StyleSheet, Text, View, } from "react-native";
 import { PREVIEW_PLACEMENT_KEY } from "../implicit.js";
+import { getStoreAdapter } from "../store.js";
 import { withAlpha } from "../blocks/color.js";
 import { RevnixBlockPaywall, } from "./RevnixBlockPaywall.js";
 /** `config.blocks` is opaque on the core config (the non-UI entrypoint must
@@ -141,7 +142,7 @@ export function RevnixPaywall(props) {
         });
         onSelectPackage?.(packageId);
     }, [onSelectPackage, report, productOf]);
-    const { onPurchase } = props;
+    const { onPurchase, onPurchaseCompleted } = props;
     // Rises per attempt so a retry after a failure is its own occurrence rather
     // than being absorbed as a duplicate of the first try.
     const attemptRef = React.useRef(0);
@@ -168,9 +169,26 @@ export function RevnixPaywall(props) {
                 eventId: occurrence,
             });
         };
+        const purchase = onPurchase ??
+            (async () => {
+                if (!productId) {
+                    return { status: "failed", message: "package has no productId" };
+                }
+                if (!client?.purchase) {
+                    return { status: "failed", message: "pass client or onPurchase" };
+                }
+                const result = await client.purchase(productId, {
+                    viewId: viewIdRef.current,
+                    placementKey,
+                    paywallId,
+                });
+                if (result)
+                    onPurchaseCompleted?.(result);
+                return { status: result ? "completed" : "cancelled" };
+            });
         let returned;
         try {
-            returned = onPurchase(packageId);
+            returned = purchase(packageId);
         }
         catch (err) {
             // A host that throws synchronously has failed the purchase as surely
@@ -183,14 +201,23 @@ export function RevnixPaywall(props) {
             return;
         }
         settle(returned);
-    }, [onPurchase, report, productOf, placementKey]);
+    }, [onPurchase, onPurchaseCompleted, report, productOf, placementKey, paywallId, client]);
     const { onRestore } = props;
-    const handleRestore = React.useMemo(() => onRestore
-        ? () => {
-            report("restore");
-            onRestore();
+    const handleRestore = React.useMemo(() => {
+        if (onRestore) {
+            return () => {
+                report("restore");
+                onRestore();
+            };
         }
-        : undefined, [onRestore, report]);
+        const restore = client?.restore?.bind(client);
+        if (!restore || !getStoreAdapter())
+            return undefined;
+        return () => {
+            report("restore");
+            void restore().catch((err) => client?.reportRenderDiagnostic?.(String(err?.message ?? err)));
+        };
+    }, [onRestore, report, client]);
     // The host's dismissal runs whatever happens to the beacon — an analytics
     // failure must never trap the customer on the screen (REV-252).
     const { onClose } = props;

package/dist/esm/version.js

@@ -1,4 +1,4 @@
 // L3: the single source of the SDK version inside src/. Must match
 // package.json "version" — version.test.ts fails the build when they drift
 // (they had: client.ts said 0.7.0 while the package shipped 0.9.0).
-export const SDK_VERSION = "1.4.0";
+export const SDK_VERSION = "1.5.0";