@advenue/react-native 0.4.0 → 0.5.0

package/README.md

@@ -8,11 +8,11 @@ engine.
 ## Install
 
 ```sh
-npx expo install @advenue/react-native @advenue/sdk-android @advenue/sdk-ios \
+npx expo install @advenue/react-native \
   react-native-mmkv expo-secure-store
 ```
 
-`@advenue/sdk-android` and `@advenue/sdk-ios` are Expo native modules built by
+The iOS and Android Expo native modules ship inside this package (`ios/`, `android/`) and are built by
 your app's own Gradle/Xcode build — no manual linking.
 
 ## Quick start

package/android/build.gradle

@@ -0,0 +1,22 @@
+apply plugin: 'com.android.library'
+apply plugin: 'org.jetbrains.kotlin.android'
+
+group = 'expo.modules.advenue'
+version = '0.0.0'
+
+android {
+  namespace = 'expo.modules.advenue'
+  compileSdk = 35
+  defaultConfig {
+    minSdk = 24
+  }
+}
+
+dependencies {
+  implementation 'com.android.installreferrer:installreferrer:2.2'
+  implementation("com.google.android.gms:play-services-ads-identifier:18.0.1")
+  // App Set ID — non-advertising, developer-scoped id for first-party fraud/dedup (not ads).
+  implementation("com.google.android.gms:play-services-appset:16.0.2")
+  // Play Integrity Standard API — device attestation (G3.1n).
+  implementation("com.google.android.play:integrity:1.4.0")
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,8 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <!-- Android 11+ package visibility for the Meta Install Referrer providers. -->
+  <queries>
+    <package android:name="com.facebook.katana" />
+    <package android:name="com.instagram.android" />
+    <package android:name="com.facebook.lite" />
+  </queries>
+</manifest>

package/android/src/main/java/expo/modules/advenue/AdvenueAndroidModule.kt

@@ -0,0 +1,354 @@
+package expo.modules.advenue
+
+import android.content.pm.ApplicationInfo
+import com.android.installreferrer.api.InstallReferrerClient
+import com.android.installreferrer.api.InstallReferrerStateListener
+import com.google.android.gms.ads.identifier.AdvertisingIdClient
+import com.google.android.gms.appset.AppSet
+import com.google.android.play.core.integrity.IntegrityManagerFactory
+import com.google.android.play.core.integrity.StandardIntegrityManager
+import com.google.android.play.core.integrity.StandardIntegrityManager.PrepareIntegrityTokenRequest
+import com.google.android.play.core.integrity.StandardIntegrityManager.StandardIntegrityTokenRequest
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.kotlin.Promise
+
+// Advenue Android native module. Fetches the Google Play Install Referrer; the
+// referrer string is parsed in TS (@advenue/install-referrer).
+class AdvenueAndroidModule : Module() {
+  // Standard Integrity token provider, warmed once at module init. Null when
+  // Play Integrity is unavailable (side-loaded APK, emulator, no Play Services).
+  // Warming is best-effort — a failure leaves this null and getIntegrityToken
+  // will reject with a clear error.
+  private var integrityProvider: StandardIntegrityManager.StandardIntegrityTokenProvider? = null
+
+  override fun definition() = ModuleDefinition {
+    Name("AdvenueAndroid")
+
+    // Warm the Standard Integrity token provider when the module is created.
+    // The Google Cloud project number is read from the application's <meta-data>
+    // tag in AndroidManifest.xml:
+    //
+    //   <meta-data
+    //       android:name="io.advenue.INTEGRITY_CLOUD_PROJECT_NUMBER"
+    //       android:value="<your-GCP-project-number>" />
+    //
+    // This is the numeric project ID shown in the Google Cloud Console URL:
+    // https://console.cloud.google.com/home/dashboard?project=<project-id>
+    // The number itself lives in Settings → Project info → Project number.
+    OnCreate {
+      val ctx = appContext.reactContext?.applicationContext ?: return@OnCreate
+      try {
+        val ai: ApplicationInfo = ctx.packageManager.getApplicationInfo(
+          ctx.packageName,
+          android.content.pm.PackageManager.GET_META_DATA,
+        )
+        // GCP project numbers are large longs (12+ digits). Android meta-data
+        // stores them as String when declared as android:value="123..." (no type
+        // suffix). We try getLong() first (works when stored as an integer
+        // resource), then fall back to getString() + toLong() for string values.
+        val metaBundle = ai.metaData
+        val cloudProjectNumber: Long = metaBundle?.getLong(
+          "io.advenue.INTEGRITY_CLOUD_PROJECT_NUMBER", 0L
+        )?.takeIf { it != 0L }
+          ?: metaBundle?.getString("io.advenue.INTEGRITY_CLOUD_PROJECT_NUMBER")
+            ?.toLongOrNull()
+          ?: 0L
+        if (cloudProjectNumber == 0L) {
+          // Project number not configured — attestation will be unavailable.
+          // Callers can still call getIntegrityToken(); it will reject with ECONFIG.
+          return@OnCreate
+        }
+        val manager = IntegrityManagerFactory.createStandard(ctx)
+        manager.prepareIntegrityToken(
+          PrepareIntegrityTokenRequest.builder()
+            .setCloudProjectNumber(cloudProjectNumber)
+            .build()
+        )
+          .addOnSuccessListener { provider -> integrityProvider = provider }
+          .addOnFailureListener { /* provider stays null — getIntegrityToken will reject */ }
+      } catch (_: Exception) {
+        // Play Integrity unavailable (no Play Services, side-loaded build, etc.)
+      }
+    }
+
+    AsyncFunction("getInstallReferrer") { promise: Promise ->
+      val context = appContext.reactContext ?: run {
+        promise.reject("ECTX", "No React context", null)
+        return@AsyncFunction
+      }
+      val client = InstallReferrerClient.newBuilder(context).build()
+      // The Play Install Referrer callback can fire setup-finished, disconnect, or
+      // never respond (offline / unavailable). Settle the promise EXACTLY once and
+      // release the service binding on every exit path — otherwise a disconnect or
+      // a hung connection leaks the binding and hangs trackInstall forever.
+      val settled = java.util.concurrent.atomic.AtomicBoolean(false)
+      val handler = android.os.Handler(android.os.Looper.getMainLooper())
+      fun release() {
+        try { client.endConnection() } catch (_: Exception) {}
+      }
+      // Watchdog: if the service never calls back, resolve null (referrer is
+      // best-effort enrichment) so the JS promise always settles.
+      handler.postDelayed({
+        if (settled.compareAndSet(false, true)) {
+          release()
+          promise.resolve(null)
+        }
+      }, 5_000)
+
+      client.startConnection(object : InstallReferrerStateListener {
+        override fun onInstallReferrerSetupFinished(responseCode: Int) {
+          if (!settled.compareAndSet(false, true)) return
+          handler.removeCallbacksAndMessages(null)
+          try {
+            if (responseCode == InstallReferrerClient.InstallReferrerResponse.OK) {
+              val response = client.installReferrer
+              promise.resolve(mapOf(
+                "referrer" to response.installReferrer,
+                "clickTimestamp" to response.referrerClickTimestampSeconds,
+                "installTimestamp" to response.installBeginTimestampSeconds,
+                // Server-clock getters (G1): Play returns 0 when the install is
+                // unverified. The JS layer forwards these as server-trusted keys
+                // only when non-zero. Do NOT confuse with the device-clock
+                // *TimestampSeconds getters above.
+                "clickServerTimestamp" to response.referrerClickTimestampServerSeconds,
+                "installServerTimestamp" to response.installBeginTimestampServerSeconds,
+                "googlePlayInstant" to response.googlePlayInstantParam,
+              ))
+            } else {
+              promise.resolve(null)
+            }
+          } catch (e: Exception) {
+            promise.reject("EREFERRER", e.message, e)
+          } finally {
+            release()
+          }
+        }
+
+        override fun onInstallReferrerServiceDisconnected() {
+          // Service dropped before setup finished (e.g. low memory). Release the
+          // binding and settle as best-effort null instead of hanging forever.
+          if (settled.compareAndSet(false, true)) {
+            handler.removeCallbacksAndMessages(null)
+            release()
+            promise.resolve(null)
+          }
+        }
+      })
+    }
+
+    // Meta (Facebook/Instagram) install referrer via content provider. The
+    // payload is parsed in TS and the encrypted blob decrypted server-side
+    // (@advenue/install-referrer). Resolves null when no Meta app is installed.
+    AsyncFunction("getMetaInstallReferrer") { promise: Promise ->
+      val context = appContext.reactContext ?: run {
+        promise.reject("ECTX", "No React context", null)
+        return@AsyncFunction
+      }
+      val providers = listOf("com.facebook.katana", "com.instagram.android", "com.facebook.lite")
+      try {
+        for (pkg in providers) {
+          val uri = android.net.Uri.parse(
+            "content://$pkg.provider.InstallReferrerProvider/${context.packageName}"
+          )
+          val cursor = try {
+            context.contentResolver.query(
+              uri,
+              arrayOf("install_referrer", "is_ct", "actual_timestamp"),
+              null,
+              null,
+              null,
+            )
+          } catch (_: Exception) {
+            null
+          } ?: continue
+          cursor.use {
+            if (it.moveToFirst()) {
+              val referrerIdx = it.getColumnIndex("install_referrer")
+              val ctIdx = it.getColumnIndex("is_ct")
+              val tsIdx = it.getColumnIndex("actual_timestamp")
+              if (referrerIdx >= 0) {
+                promise.resolve(mapOf(
+                  "installReferrer" to it.getString(referrerIdx),
+                  "isClickThrough" to (ctIdx >= 0 && it.getInt(ctIdx) == 1),
+                  "actualTimestamp" to (if (tsIdx >= 0) it.getLong(tsIdx) else 0L),
+                  "provider" to pkg,
+                ))
+                return@AsyncFunction
+              }
+            }
+          }
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject("EMETAREF", e.message, e)
+      }
+    }
+
+    // Google Advertising ID (GAID) + limit-ad-tracking flag. The blocking
+    // Play Services call is run on a background thread.
+    AsyncFunction("getAdvertisingId") { promise: Promise ->
+      Thread {
+        try {
+          val ctx = appContext.reactContext?.applicationContext
+          if (ctx == null) { promise.resolve(null); return@Thread }
+          val info = AdvertisingIdClient.getAdvertisingIdInfo(ctx)
+          val id = info.id
+          val zeroGaid = "00000000-0000-0000-0000-000000000000"
+          if (id.isNullOrEmpty() || id == zeroGaid) promise.resolve(null)
+          else promise.resolve(mapOf("id" to id, "limitAdTracking" to info.isLimitAdTrackingEnabled))
+        } catch (e: Exception) {
+          promise.resolve(null)
+        }
+      }.start()
+    }
+
+    // App Set ID — non-advertising, developer-scoped id. First-party fraud/dedup
+    // use only; Google forbids using it for ads or measurement.
+    AsyncFunction("getAppSetId") { promise: Promise ->
+      val ctx = appContext.reactContext?.applicationContext
+      if (ctx == null) { promise.resolve(null); return@AsyncFunction }
+      AppSet.getClient(ctx).appSetIdInfo
+        .addOnSuccessListener { info -> promise.resolve(info.id) }
+        .addOnFailureListener { promise.resolve(null) }
+    }
+
+    // Play Integrity Standard API — device attestation (G3.1n).
+    //
+    // `requestHash` MUST be sha256_hex("<appId>:<deviceId>") — lowercase hex of
+    // SHA-256 over the literal string "<appId>:<deviceId>". The server's
+    // mapIntegrityVerdict (Task 3) re-derives the same string and compares it to
+    // the token's requestHash field; the strings must match byte-for-byte.
+    //
+    // The provider is warmed in OnCreate (above). If it is null — because the
+    // manifest meta-data key is absent, Play Integrity is unsupported, or warming
+    // failed — this rejects with ECONFIG / EUNSUPPORTED. The JS layer treats any
+    // rejection as "no attestation" and omits the token from the install event.
+    AsyncFunction("getIntegrityToken") { requestHash: String, promise: Promise ->
+      val provider = integrityProvider
+      if (provider == null) {
+        // Distinguish "project number not set" from "Play Integrity not available".
+        val ctx = appContext.reactContext?.applicationContext
+        if (ctx != null) {
+          val ai = try {
+            ctx.packageManager.getApplicationInfo(
+              ctx.packageName,
+              android.content.pm.PackageManager.GET_META_DATA,
+            )
+          } catch (_: Exception) { null }
+          val mb = ai?.metaData
+          val cfgNum: Long = mb?.getLong("io.advenue.INTEGRITY_CLOUD_PROJECT_NUMBER", 0L)
+            ?.takeIf { it != 0L }
+            ?: mb?.getString("io.advenue.INTEGRITY_CLOUD_PROJECT_NUMBER")?.toLongOrNull()
+            ?: 0L
+          if (cfgNum == 0L) {
+            promise.reject(
+              "ECONFIG",
+              "Play Integrity not configured: add io.advenue.INTEGRITY_CLOUD_PROJECT_NUMBER to AndroidManifest.xml meta-data",
+              null,
+            )
+            return@AsyncFunction
+          }
+        }
+        promise.reject(
+          "EUNSUPPORTED",
+          "Play Integrity token provider not ready (Play Services may be unavailable or warming failed)",
+          null,
+        )
+        return@AsyncFunction
+      }
+
+      val request = StandardIntegrityTokenRequest.builder()
+        .setRequestHash(requestHash)
+        .build()
+
+      provider.request(request)
+        .addOnSuccessListener { response -> promise.resolve(response.token()) }
+        .addOnFailureListener { e ->
+          promise.reject("EINTEGRITY", e.message ?: "Play Integrity request failed", e)
+        }
+    }
+
+    // Device metadata for Meta CAPI `extinfo` (Task 3n). Synchronous — every
+    // API used here is a cheap local read (no network, no blocking I/O beyond
+    // a local StatFs stat call). Best-effort per field: a field is simply
+    // omitted (not defaulted) when its source is unavailable, so the JS-side
+    // fail-safe (collectDeviceInfo) degrades gracefully rather than sending
+    // misleading zeros.
+    Function("getDeviceInfo") {
+      val map = mutableMapOf<String, Any?>()
+      map["model"] = android.os.Build.MODEL
+      map["locale"] = java.util.Locale.getDefault().toString()
+      map["timezone"] = java.util.TimeZone.getDefault().id
+      map["cpuCores"] = Runtime.getRuntime().availableProcessors()
+
+      val ctx = appContext.reactContext?.applicationContext
+      if (ctx != null) {
+        try {
+          val dm = ctx.resources.displayMetrics
+          map["screenWidth"] = dm.widthPixels
+          map["screenHeight"] = dm.heightPixels
+          map["screenDensity"] = dm.density.toDouble()
+        } catch (_: Exception) {
+          // screen metrics best-effort
+        }
+        try {
+          val statFs = android.os.StatFs(ctx.filesDir.path)
+          val blockSize = statFs.blockSizeLong
+          val gb = 1024.0 * 1024.0 * 1024.0
+          map["totalStorageGb"] = (statFs.blockCountLong * blockSize).toDouble() / gb
+          map["freeStorageGb"] = (statFs.availableBlocksLong * blockSize).toDouble() / gb
+        } catch (_: Exception) {
+          // storage stat best-effort
+        }
+        try {
+          val tm = ctx.getSystemService(android.content.Context.TELEPHONY_SERVICE)
+            as? android.telephony.TelephonyManager
+          val carrier = tm?.networkOperatorName
+          if (!carrier.isNullOrEmpty()) map["carrier"] = carrier
+        } catch (_: Exception) {
+          // carrier best-effort
+        }
+      }
+      map
+    }
+
+    // Built-in SDK storage (Adjust-style: the app supplies nothing). A
+    // dedicated SharedPreferences file keeps SDK keys out of the app's prefs.
+    // Wiped on uninstall — Android has no reinstall-durable store, so a
+    // reinstall legitimately re-fires the install (backend window dedups).
+    Function("storageGetItem") { key: String ->
+      sdkPrefs()?.getString(key, null)
+    }
+    Function("storageSetItem") { key: String, value: String ->
+      sdkPrefs()?.edit()?.putString(key, value)?.apply()
+    }
+    Function("storageRemoveItem") { key: String ->
+      sdkPrefs()?.edit()?.remove(key)?.apply()
+    }
+
+    // SSAID (ANDROID_ID): signing-key-scoped, stable across reinstalls, reset
+    // only by factory reset. Read by the JS facade ONLY when no usable GAID
+    // exists, as a first-party fraud/dedup + reinstall-detection signal (Play
+    // policy: never linked to the advertising id, never used for ads).
+    Function("getAndroidId") { ->
+      try {
+        val ctx = appContext.reactContext?.applicationContext
+        if (ctx != null) {
+          android.provider.Settings.Secure.getString(
+            ctx.contentResolver,
+            android.provider.Settings.Secure.ANDROID_ID,
+          )
+        } else {
+          null
+        }
+      } catch (_: Exception) {
+        null // best-effort: a missing SSAID never blocks anything
+      }
+    }
+  }
+
+  private fun sdkPrefs(): android.content.SharedPreferences? =
+    appContext.reactContext?.applicationContext
+      ?.getSharedPreferences("io.advenue.sdk", android.content.Context.MODE_PRIVATE)
+}

package/dist/index.d.ts

@@ -1,8 +1,5 @@
 import { StorageAdapter, SecureStorageAdapter, DeepLink, AdvenueConfig, AdvenueClient, TrackOptions, Consent, DeviceInfo } from '@advenue/sdk-core';
 export { AdvenueConfig, Consent, DeepLink, TrackOptions } from '@advenue/sdk-core';
-import { AdvenueIosNativeModule, TrackingAuthorizationStatus } from '@advenue/sdk-ios';
-export { TrackingAuthorizationStatus } from '@advenue/sdk-ios';
-import { AdvenueAndroidNativeModule } from '@advenue/sdk-android';
 
 /**
  * Minimal structural type for the bits of `react-native-mmkv`'s MMKV instance
@@ -17,6 +14,172 @@ interface MMKVLike {
 /** Wraps an MMKV instance as an Advenue StorageAdapter (synchronous, fast). */
 declare function createMMKVStorage(mmkv: MMKVLike): StorageAdapter;
 
+interface InstallReferrerResult {
+    referrer: string;
+    /** Device-clock: referrerClickTimestampSeconds. */
+    clickTimestamp: number;
+    /** Device-clock: installBeginTimestampSeconds. */
+    installTimestamp: number;
+    /**
+     * Server-clock: referrerClickTimestampServerSeconds (G1 fraud trust —
+     * referrerTrust:'server'). 0 = unverified; absent on older native builds.
+     */
+    clickServerTimestamp?: number;
+    /** Server-clock: installBeginTimestampServerSeconds. 0 = unverified. */
+    installServerTimestamp?: number;
+    googlePlayInstant: boolean;
+}
+interface MetaInstallReferrerResult {
+    installReferrer: string;
+    isClickThrough: boolean;
+    actualTimestamp: number;
+    /** Which Meta app served the referrer (e.g. com.facebook.katana). */
+    provider: string;
+}
+/**
+ * Device metadata for Meta CAPI `extinfo` (Task 3n). Structurally mirrors
+ * `DeviceInfo` from `@advenue/shared` — kept as a local subset type (rather
+ * than importing that package) so this native-module-only package stays
+ * dependency-free; the RN facade's `collectDeviceInfo()` merges it into the
+ * real `DeviceInfo` shape.
+ */
+interface AdvenueDeviceInfo {
+    model?: string;
+    locale?: string;
+    carrier?: string;
+    timezone?: string;
+    screenWidth?: number;
+    screenHeight?: number;
+    screenDensity?: number;
+    cpuCores?: number;
+    totalStorageGb?: number;
+    freeStorageGb?: number;
+}
+interface AdvenueAndroidNativeModule {
+    /** Raw Play Install Referrer; parse with @advenue/install-referrer. */
+    getInstallReferrer(): Promise<InstallReferrerResult | null>;
+    /**
+     * Meta install referrer (null when no Facebook/Instagram app is installed);
+     * parse with parseMetaInstallReferrer from @advenue/install-referrer.
+     */
+    getMetaInstallReferrer(): Promise<MetaInstallReferrerResult | null>;
+    /** Google Advertising ID (GAID) + limit-ad-tracking flag; null when unavailable. */
+    getAdvertisingId(): Promise<{
+        id: string;
+        limitAdTracking: boolean;
+    } | null>;
+    /** App Set ID — non-advertising, developer-scoped fallback id; null when unavailable. */
+    getAppSetId(): Promise<string | null>;
+    /**
+     * Play Integrity Standard API token (G3.1n).
+     *
+     * `requestHash` MUST be sha256_hex("<appId>:<deviceId>") — lowercase hex SHA-256
+     * of the literal string "<appId>:<deviceId>". The server's mapIntegrityVerdict
+     * re-derives the same string and compares it byte-for-byte.
+     *
+     * Rejects when:
+     *  - ECONFIG: `io.advenue.INTEGRITY_CLOUD_PROJECT_NUMBER` meta-data is absent.
+     *  - EUNSUPPORTED: Play Services unavailable or provider warming failed.
+     *  - EINTEGRITY: Play returned an API-level error (network, quota, etc.).
+     *
+     * The JS bridge treats any rejection as "no attestation" and omits the token
+     * from the install event — rejection must never block the install track call.
+     */
+    getIntegrityToken(requestHash: string): Promise<string>;
+    /**
+     * Device metadata (model, locale, screen, cpu, storage, timezone) used to
+     * populate Meta CAPI `extinfo` (Task 3n). Synchronous, best-effort — the JS
+     * facade (`collectDeviceInfo`) treats a thrown error as "unavailable" and
+     * degrades to `{}` rather than blocking anything.
+     */
+    getDeviceInfo(): AdvenueDeviceInfo;
+    /**
+     * Built-in SDK storage (SharedPreferences `io.advenue.sdk`, MODE_PRIVATE) —
+     * the durable offline buffer + SDK state, so the app never supplies storage.
+     * Optional: absent on native builds predating this capability; the RN facade
+     * feature-detects and falls back to in-memory buffering. (No secure variant:
+     * Android has no reinstall-durable store — a reinstall legitimately re-fires
+     * the install, which the backend per-device window deduplicates.)
+     */
+    storageGetItem?(key: string): string | null;
+    storageSetItem?(key: string, value: string): void;
+    storageRemoveItem?(key: string): void;
+    /**
+     * Android SSAID (Settings.Secure.ANDROID_ID) — signing-key-scoped, stable
+     * across reinstalls. The RN facade reads it ONLY when no usable GAID exists
+     * (Adjust-style fallback) and it is used strictly as a first-party
+     * fraud/dedup + reinstall-detection signal, never for ad attribution (Play
+     * policy). Optional: absent on older native builds; feature-detected.
+     */
+    getAndroidId?(): string | null;
+}
+type TrackingAuthorizationStatus = 'notDetermined' | 'restricted' | 'denied' | 'authorized';
+interface AdvenueIosNativeModule {
+    registerAppForAttribution(): void;
+    /**
+     * Conversion value: fine 0–63, coarse 'low'|'medium'|'high'. Updates the
+     * SKAN 4.0 postback, and on iOS 17.4+ the AdAttributionKit postback too.
+     */
+    updateConversionValue(fineValue: number, coarse: string, lockWindow: boolean): Promise<void>;
+    /** Apple Search Ads attribution token (resolve server-side). */
+    getAttributionToken(): Promise<string | null>;
+    /**
+     * Shows the ATT consent prompt; requires NSUserTrackingUsageDescription in
+     * the app's Info.plist. Resolves with the resulting status.
+     */
+    requestTrackingAuthorization(): Promise<TrackingAuthorizationStatus>;
+    getTrackingAuthorizationStatus(): TrackingAuthorizationStatus;
+    getAdvertisingId(): Promise<string | null>;
+    /** Vendor-scoped device id (IDFV) — available without ATT; a fallback anchor. */
+    getIdentifierForVendor(): string | null;
+    /** Clipboard match token (advmatch:<id>) for deterministic deferred deep linking; null if absent. */
+    getPasteboardMatchToken(): string | null;
+    /**
+     * G3.2n — App Attest. Generates (or reuses a keychain-cached) DCAppAttest
+     * key, computes clientDataHash = SHA-256(challenge), and calls
+     * DCAppAttestService.attestKey. Resolves { keyId, attestationObject } where
+     * attestationObject is a base64-encoded CBOR attestation for the server.
+     * Rejects with code EUNSUPPORTED on simulators (isSupported == false).
+     */
+    attestKey(challenge: string): Promise<{
+        keyId: string;
+        attestationObject: string;
+    }>;
+    /**
+     * G3.3n — DeviceCheck. Calls DCDevice.current.generateToken to obtain the
+     * opaque base64 token that identifies this physical device to the Apple
+     * DeviceCheck API. The server queries/updates the persistent 2-bit per-device
+     * flag to detect reinstall abuse. Rejects with code EUNSUPPORTED on devices
+     * where DCDevice.current.isSupported is false (simulator, Catalyst, etc.).
+     */
+    getDeviceCheckToken(): Promise<string>;
+    /**
+     * Device metadata (model, locale, screen, cpu, storage, timezone) used to
+     * populate Meta CAPI `extinfo` (Task 3n). Synchronous, best-effort — the JS
+     * facade (`collectDeviceInfo`) treats a thrown error as "unavailable" and
+     * degrades to `{}` rather than blocking anything.
+     */
+    getDeviceInfo(): AdvenueDeviceInfo;
+    /**
+     * Built-in SDK storage (UserDefaults suite `io.advenue.sdk`) — the durable
+     * offline buffer + SDK state, so the app never supplies storage. Optional:
+     * absent on native builds predating this capability; the RN facade
+     * feature-detects and falls back to in-memory buffering.
+     */
+    storageGetItem?(key: string): string | null;
+    storageSetItem?(key: string, value: string): void;
+    storageRemoveItem?(key: string): void;
+    /**
+     * Built-in secure storage (Keychain, kSecAttrAccessibleAfterFirstUnlock,
+     * ThisDeviceOnly) — survives app reinstall, which is what makes the device
+     * identity and the install guard reinstall-resilient (Adjust-style).
+     * Optional: absent on older native builds; feature-detected.
+     */
+    secureGetItem?(key: string): string | null;
+    secureSetItem?(key: string, value: string): void;
+    secureRemoveItem?(key: string): void;
+}
+
 /**
  * Minimal structural type for the bits of `expo-secure-store` we use. Declared
  * locally so this package needs no expo types at compile time — the app passes
@@ -40,9 +203,11 @@ declare function createSecureStore(secureStore: SecureStoreLike): SecureStorageA
 declare function parseDirectLink(url: string): DeepLink;
 
 /**
- * Lazy access to the optional native modules. `requireNativeModule` throws at
- * import time when the native side isn't installed (Expo Go, web, missing
- * pods), so resolution happens inside try/catch — never at module scope.
+ * Lazy access to the native modules that ship inside this package (ios/ and
+ * android/, registered via expo-module.config.json). `requireNativeModule`
+ * throws when the native side isn't built (Expo Go, web, missing pods), so
+ * resolution happens inside try/catch — never at module scope.
+ * expo-modules-core is resolved from the consuming app's Expo install.
  */
 declare function getIosNative(): AdvenueIosNativeModule | null;
 declare function getAndroidNative(): AdvenueAndroidNativeModule | null;
@@ -99,7 +264,7 @@ interface RNAdvenueConfig extends Omit<AdvenueConfig, 'storage' | 'platform'> {
     /**
      * G3.1n — Play Integrity (Android) / App Attest (iOS) attestation.
      *
-     * Your app's Advenue appId (the UUID shown in the dashboard). When set on
+     * Your app's Advenue appId (the UUID in Settings → API Keys). When set on
      * Android, the automatic install obtains a Play Integrity Standard token and
      * attaches it to the install event. The requestHash is computed as
      * `sha256Hex("<appId>:<deviceId>")`, matching the server's verification
@@ -178,4 +343,4 @@ declare const Advenue: {
  */
 declare function trackInstall(): Promise<void>;
 
-export { Advenue, type MMKVLike, type RNAdvenueConfig, type SecureStoreLike, applyAppState, collectDeviceInfo, createMMKVStorage, createSecureStore, getAndroidNative, getIosNative, parseDirectLink, resolveAdvertisingId, resolveClipboardMatch, trackInstall };
+export { Advenue, type AdvenueAndroidNativeModule, type AdvenueDeviceInfo, type AdvenueIosNativeModule, type InstallReferrerResult, type MMKVLike, type MetaInstallReferrerResult, type RNAdvenueConfig, type SecureStoreLike, type TrackingAuthorizationStatus, applyAppState, collectDeviceInfo, createMMKVStorage, createSecureStore, getAndroidNative, getIosNative, parseDirectLink, resolveAdvertisingId, resolveClipboardMatch, trackInstall };

package/dist/index.js

@@ -174,10 +174,10 @@ function parseDirectLink(url) {
     const path = parsed.pathname.replace(/^\/+/, "");
     const isHttp = parsed.protocol === "http:" || parsed.protocol === "https:";
     deepLinkValue = isHttp ? path : [parsed.host, path].filter(Boolean).join("/");
-    for (const [k, v] of parsed.searchParams.entries()) {
+    parsed.searchParams.forEach((v, k) => {
       params ??= {};
       params[k] = v;
-    }
+    });
   } catch {
     deepLinkValue = url;
   }
@@ -217,14 +217,16 @@ function createMMKVStorage(mmkv) {
 // src/native.ts
 function getIosNative() {
   try {
-    return __require("@advenue/sdk-ios").AdvenueIos;
+    const core = __require("expo-modules-core");
+    return core.requireNativeModule("AdvenueIos");
   } catch {
     return null;
   }
 }
 function getAndroidNative() {
   try {
-    return __require("@advenue/sdk-android").AdvenueAndroid;
+    const core = __require("expo-modules-core");
+    return core.requireNativeModule("AdvenueAndroid");
   } catch {
     return null;
   }

package/expo-module.config.json

@@ -0,0 +1,9 @@
+{
+  "platforms": ["apple", "android"],
+  "apple": {
+    "modules": ["AdvenueIosModule"]
+  },
+  "android": {
+    "modules": ["expo.modules.advenue.AdvenueAndroidModule"]
+  }
+}

package/ios/AdvenueIos.podspec

@@ -0,0 +1,20 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name             = 'AdvenueIos'
+  s.version          = package['version']
+  s.summary          = package['description']
+  s.license          = package['license']
+  s.author           = 'Advenue'
+  s.homepage         = 'https://github.com/broverse/advenue'
+  s.platforms        = { :ios => '15.1' }
+  s.swift_version    = '5.4'
+  s.source           = { git: 'https://github.com/broverse/advenue.git' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  s.source_files = '**/*.{h,m,swift}'
+end