@advenue/react-native 0.4.0 → 0.5.0

package/ios/AdvenueIosModule.swift

@@ -0,0 +1,461 @@
+import ExpoModulesCore
+import StoreKit
+import AdServices
+import AdSupport
+import AppTrackingTransparency
+import UIKit
+import DeviceCheck
+import CryptoKit
+#if canImport(AdAttributionKit)
+import AdAttributionKit
+#endif
+
+// Advenue iOS native module. Exposes SKAdNetwork conversion-value updates
+// (SKAN 4.0 fine + coarse) and the Apple Search Ads attribution token to JS.
+// The conversion-value POLICY lives in TS (@advenue/skadnetwork); this module
+// only performs the privileged StoreKit/AdServices calls.
+public class AdvenueIosModule: Module {
+  // UIKit (UIScreen/UIDevice/UIPasteboard) is main-thread-only, but synchronous
+  // `Function` handlers run on whatever thread invoked them (the JS thread on
+  // RN's bridge). Hop to main when needed; `sync` is safe because these are
+  // cheap local reads and the guard prevents a same-thread deadlock.
+  private static func onMainSync<T>(_ work: () -> T) -> T {
+    if Thread.isMainThread {
+      return work()
+    }
+    return DispatchQueue.main.sync(execute: work)
+  }
+
+  public func definition() -> ModuleDefinition {
+    Name("AdvenueIos")
+
+    // Call once at launch so SKAdNetwork starts the measurement window.
+    Function("registerAppForAttribution") {
+      if #available(iOS 16.1, *) {
+        // No-op: updatePostbackConversionValue implicitly registers.
+      } else {
+        SKAdNetwork.registerAppForAdNetworkAttribution()
+      }
+    }
+
+    // SKAN 4.0: fine value 0–63 + coarse "low" | "medium" | "high". On
+    // iOS 17.4+ the AdAttributionKit postback is updated as well, since an
+    // impression may be signed for either rail.
+    AsyncFunction("updateConversionValue") { (fineValue: Int, coarse: String, lockWindow: Bool, promise: Promise) in
+      #if canImport(AdAttributionKit)
+      if #available(iOS 17.4, *) {
+        let aakCoarse: CoarseConversionValue = {
+          switch coarse {
+          case "high": return .high
+          case "medium": return .medium
+          default: return .low
+          }
+        }()
+        Task {
+          do {
+            try await Postback.updateConversionValue(fineValue, coarseConversionValue: aakCoarse, lockPostback: lockWindow)
+          } catch {
+            // Expected when no AAK-signed impression exists; logged so SKAN/AAK
+            // postback divergence on iOS 17.4+ is diagnosable. The SKAN call
+            // below still resolves the promise.
+            NSLog("[Advenue] AdAttributionKit conversion update skipped: %@", error.localizedDescription)
+          }
+        }
+      }
+      #endif
+      if #available(iOS 16.1, *) {
+        let coarseValue: SKAdNetwork.CoarseConversionValue = {
+          switch coarse {
+          case "high": return .high
+          case "medium": return .medium
+          default: return .low
+          }
+        }()
+        SKAdNetwork.updatePostbackConversionValue(fineValue, coarseValue: coarseValue, lockWindow: lockWindow) { error in
+          if let error = error { promise.reject("ESKAN", error.localizedDescription) }
+          else { promise.resolve(nil) }
+        }
+      } else if #available(iOS 15.4, *) {
+        SKAdNetwork.updatePostbackConversionValue(fineValue) { error in
+          if let error = error { promise.reject("ESKAN", error.localizedDescription) }
+          else { promise.resolve(nil) }
+        }
+      } else {
+        SKAdNetwork.updateConversionValue(fineValue)
+        promise.resolve(nil)
+      }
+    }
+
+    // Apple Search Ads attribution token; resolved server-side via @advenue/skadnetwork.
+    AsyncFunction("getAttributionToken") { (promise: Promise) in
+      if #available(iOS 14.3, *) {
+        do {
+          let token = try AAAttribution.attributionToken()
+          promise.resolve(token)
+        } catch {
+          promise.reject("EASA", error.localizedDescription)
+        }
+      } else {
+        promise.resolve(nil)
+      }
+    }
+
+    // ATT consent prompt. The consumer app must declare
+    // NSUserTrackingUsageDescription in Info.plist, or iOS rejects the call.
+    AsyncFunction("requestTrackingAuthorization") { (promise: Promise) in
+      if #available(iOS 14, *) {
+        ATTrackingManager.requestTrackingAuthorization { status in
+          promise.resolve(Self.attStatusString(status))
+        }
+      } else {
+        promise.resolve("authorized")
+      }
+    }
+
+    AsyncFunction("getAdvertisingId") { (promise: Promise) in
+      if #available(iOS 14, *) {
+        guard ATTrackingManager.trackingAuthorizationStatus == .authorized else {
+          promise.resolve(nil)
+          return
+        }
+      }
+      let idfa = ASIdentifierManager.shared().advertisingIdentifier.uuidString
+      promise.resolve(idfa == "00000000-0000-0000-0000-000000000000" ? nil : idfa)
+    }
+
+    Function("getTrackingAuthorizationStatus") { () -> String in
+      if #available(iOS 14, *) {
+        return Self.attStatusString(ATTrackingManager.trackingAuthorizationStatus)
+      }
+      return "authorized"
+    }
+
+    // Vendor-scoped device id (identifierForVendor). Available WITHOUT ATT because
+    // it is NOT an advertising identifier. First-party fraud/dedup use only — it
+    // must not be used for cross-network attribution, which would be "tracking".
+    Function("getIdentifierForVendor") { () -> String? in
+      return Self.onMainSync { UIDevice.current.identifierForVendor?.uuidString }
+    }
+
+    // Reads our clipboard match token (advmatch:<id>) written by the link
+    // redirector, for deterministic deferred deep linking. Returns ONLY our
+    // token, never arbitrary clipboard contents. (Reading the pasteboard shows
+    // the iOS paste notification — expected, user-visible, deterministic path.)
+    Function("getPasteboardMatchToken") { () -> String? in
+      return Self.onMainSync { () -> String? in
+        guard let s = UIPasteboard.general.string, s.hasPrefix("advmatch:") else { return nil }
+        return s
+      }
+    }
+
+    // G3.3 — DeviceCheck token. Calls DCDevice.current.generateToken to obtain
+    // the opaque base64 token that identifies this physical device to the Apple
+    // DeviceCheck API. The server uses it (with the per-app DeviceCheck key) to
+    // query/update the persistent 2-bit per-device flag. Unlike App Attest, this
+    // requires no challenge/server round-trip — just generate and attach.
+    //
+    // Rejects with EUNSUPPORTED when DCDevice.current.isSupported is false (iOS
+    // simulator, Catalyst, etc.) so the JS layer can fail-safe and omit the token.
+    // IMPORTANT: NOT compile/on-device verified here; reviewed against the
+    // DCDevice API. The JS fail-safe in sdk-react-native ensures missing token
+    // never blocks attribution.
+    AsyncFunction("getDeviceCheckToken") { (promise: Promise) in
+      guard DCDevice.current.isSupported else {
+        promise.reject("EUNSUPPORTED", "DCDevice is not supported on this device")
+        return
+      }
+      DCDevice.current.generateToken { tokenData, error in
+        if let error = error {
+          promise.reject("EDEVICECHECK", error.localizedDescription)
+          return
+        }
+        guard let tokenData = tokenData else {
+          promise.reject("EDEVICECHECK", "generateToken returned nil data")
+          return
+        }
+        promise.resolve(tokenData.base64EncodedString())
+      }
+    }
+
+    // G3.2n — App Attest. Takes the server-supplied challenge string, computes
+    // clientDataHash = SHA-256(challenge UTF-8), generates (or reuses a
+    // keychain-cached) DCAppAttest key, and calls attestKey to obtain the
+    // CBOR attestation object. Resolves { keyId, attestationObject } where
+    // attestationObject is base64-encoded — pass directly to the server's
+    // verifyAppAttest endpoint. Rejects with a code on any failure so the JS
+    // layer can fail-safe (omit attestation rather than blocking the install).
+    // IMPORTANT: DCAppAttestService.isSupported is false on simulators; this
+    // causes the JS layer to skip attestation entirely (server sees 'unavailable').
+    AsyncFunction("attestKey") { (challenge: String, promise: Promise) in
+      guard #available(iOS 14.0, *) else {
+        promise.reject("EUNSUPPORTED", "App Attest requires iOS 14.0+")
+        return
+      }
+      let service = DCAppAttestService.shared
+      guard service.isSupported else {
+        promise.reject("EUNSUPPORTED", "DCAppAttestService is not supported on this device")
+        return
+      }
+
+      // Compute clientDataHash = SHA-256 of the UTF-8 challenge bytes.
+      guard let challengeData = challenge.data(using: .utf8) else {
+        promise.reject("EBADCHALLENGE", "Failed to encode challenge as UTF-8")
+        return
+      }
+      let clientDataHash = Data(SHA256.hash(data: challengeData))
+
+      // Load a previously generated key from Keychain, or generate a new one.
+      // Key is cached per-install/device so we only call generateKey once.
+      Self.resolveKeyId(service: service) { result in
+        switch result {
+        case .failure(let error):
+          promise.reject("EKEYID", error.localizedDescription)
+        case .success(let keyId):
+          service.attestKey(keyId, clientDataHash: clientDataHash) { attestationObject, error in
+            if let error = error {
+              // A key can be attested only once. If Apple rejects this keyId as
+              // invalid (e.g. it was already attested but the server never recorded
+              // it, or the key became invalid), the cached id is permanently
+              // unusable — drop it so the NEXT call generates a fresh key instead
+              // of looping on the dead id forever.
+              if (error as? DCError)?.code == .invalidKey {
+                Self.deleteKeyId()
+              }
+              promise.reject("EATTEST", error.localizedDescription)
+              return
+            }
+            guard let attestationObject = attestationObject else {
+              promise.reject("EATTEST", "attestKey returned nil attestation object")
+              return
+            }
+            let base64Attest = attestationObject.base64EncodedString()
+            promise.resolve(["keyId": keyId, "attestationObject": base64Attest])
+          }
+        }
+      }
+    }
+
+    // Device metadata for Meta CAPI `extinfo` (Task 3n). Synchronous — every
+    // API used here is a cheap local read (no network I/O). Best-effort per
+    // field: a field is simply omitted when its source is unavailable, so the
+    // JS-side fail-safe (collectDeviceInfo) degrades gracefully rather than
+    // sending misleading placeholder values.
+    // IMPORTANT: NOT compile/on-device verified here; reviewed against the
+    // UIKit/Foundation APIs. The JS fail-safe in sdk-react-native ensures a
+    // missing/partial result never blocks attribution.
+    Function("getDeviceInfo") { () -> [String: Any] in
+      var info: [String: Any] = [:]
+
+      // Hardware model identifier (e.g. "iPhone16,1") via utsname, not the
+      // marketing name — matches the Android side's Build.MODEL granularity.
+      var systemInfo = utsname()
+      uname(&systemInfo)
+      let model = withUnsafePointer(to: &systemInfo.machine) {
+        $0.withMemoryRebound(to: CChar.self, capacity: 1) { ptr in
+          String(cString: ptr)
+        }
+      }
+      info["model"] = model
+      info["locale"] = Locale.current.identifier
+      info["timezone"] = TimeZone.current.identifier
+      info["cpuCores"] = ProcessInfo.processInfo.activeProcessorCount
+
+      let (screenWidth, screenHeight, screenDensity) = Self.onMainSync { () -> (Int, Int, Double) in
+        let screen = UIScreen.main
+        return (
+          Int(screen.bounds.width * screen.scale),
+          Int(screen.bounds.height * screen.scale),
+          Double(screen.scale)
+        )
+      }
+      info["screenWidth"] = screenWidth
+      info["screenHeight"] = screenHeight
+      info["screenDensity"] = screenDensity
+
+      if let attrs = try? FileManager.default.attributesOfFileSystem(forPath: NSHomeDirectory()) {
+        let gb = 1024.0 * 1024.0 * 1024.0
+        if let total = attrs[.systemSize] as? NSNumber {
+          info["totalStorageGb"] = total.doubleValue / gb
+        }
+        if let free = attrs[.systemFreeSize] as? NSNumber {
+          info["freeStorageGb"] = free.doubleValue / gb
+        }
+      }
+
+      return info
+    }
+
+    // MARK: - Built-in SDK storage (Adjust-style: the app supplies nothing)
+
+    // Sync key/value storage backing the SDK's offline buffer + state. A
+    // dedicated UserDefaults suite keeps SDK keys out of the app's defaults.
+    Function("storageGetItem") { (key: String) -> String? in
+      Self.sdkDefaults.string(forKey: key)
+    }
+    Function("storageSetItem") { (key: String, value: String) in
+      Self.sdkDefaults.set(value, forKey: key)
+    }
+    Function("storageRemoveItem") { (key: String) in
+      Self.sdkDefaults.removeObject(forKey: key)
+    }
+
+    // Keychain-backed secure storage for the reinstall-durable identifiers
+    // (device id, install guard). kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly:
+    // survives app reinstall, readable after first unlock (background events),
+    // and never migrates via device-to-device backup restore — a restored
+    // backup must NOT clone another device's attribution identity.
+    Function("secureGetItem") { (key: String) -> String? in
+      Self.keychainGet(key)
+    }
+    Function("secureSetItem") { (key: String, value: String) in
+      Self.keychainSet(key, value)
+    }
+    Function("secureRemoveItem") { (key: String) in
+      Self.keychainRemove(key)
+    }
+  }
+
+  // MARK: - Built-in storage helpers
+
+  private static let sdkDefaults: UserDefaults =
+    UserDefaults(suiteName: "io.advenue.sdk") ?? .standard
+
+  // Shares `keychainService` with the App Attest helpers below — same service,
+  // distinct accounts (storage keys vs "app-attest-key-id"), so neither can
+  // read or delete the other's entries.
+  private static func keychainBaseQuery(_ key: String) -> [String: Any] {
+    [
+      kSecClass as String: kSecClassGenericPassword,
+      kSecAttrService as String: keychainService,
+      kSecAttrAccount as String: key,
+    ]
+  }
+
+  private static func keychainGet(_ key: String) -> String? {
+    var query = keychainBaseQuery(key)
+    query[kSecReturnData as String] = true
+    query[kSecMatchLimit as String] = kSecMatchLimitOne
+    var result: AnyObject?
+    let status = SecItemCopyMatching(query as CFDictionary, &result)
+    guard status == errSecSuccess, let data = result as? Data else {
+      return nil
+    }
+    return String(data: data, encoding: .utf8)
+  }
+
+  private static func keychainSet(_ key: String, _ value: String) {
+    guard let data = value.data(using: .utf8) else { return }
+    let base = keychainBaseQuery(key)
+    let update: [String: Any] = [kSecValueData as String: data]
+    let status = SecItemUpdate(base as CFDictionary, update as CFDictionary)
+    if status == errSecItemNotFound {
+      var add = base
+      add[kSecValueData as String] = data
+      add[kSecAttrAccessible as String] = kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly
+      SecItemAdd(add as CFDictionary, nil)
+    }
+  }
+
+  private static func keychainRemove(_ key: String) {
+    SecItemDelete(keychainBaseQuery(key) as CFDictionary)
+  }
+
+  @available(iOS 14, *)
+  private static func attStatusString(_ status: ATTrackingManager.AuthorizationStatus) -> String {
+    switch status {
+    case .authorized: return "authorized"
+    case .denied: return "denied"
+    case .restricted: return "restricted"
+    default: return "notDetermined"
+    }
+  }
+
+  // MARK: - App Attest Keychain helpers
+
+  private static let keychainService = "io.advenue.sdk"
+  private static let keychainAccount = "app-attest-key-id"
+
+  /// Loads the persisted App Attest keyId from the Keychain. Returns nil when
+  /// no key has been generated yet; the caller must then call generateKey and
+  /// persist the result via saveKeyId(_:).
+  @available(iOS 14.0, *)
+  private static func loadKeyId() -> String? {
+    let query: [CFString: Any] = [
+      kSecClass: kSecClassGenericPassword,
+      kSecAttrService: keychainService,
+      kSecAttrAccount: keychainAccount,
+      kSecReturnData: true,
+      kSecMatchLimit: kSecMatchLimitOne,
+    ]
+    var item: CFTypeRef?
+    let status = SecItemCopyMatching(query as CFDictionary, &item)
+    guard status == errSecSuccess, let data = item as? Data else { return nil }
+    return String(data: data, encoding: .utf8)
+  }
+
+  /// Persists the App Attest keyId to the Keychain, replacing any prior value.
+  @available(iOS 14.0, *)
+  private static func saveKeyId(_ keyId: String) {
+    guard let data = keyId.data(using: .utf8) else { return }
+    // Try to update an existing item first; fall back to adding a new one.
+    let query: [CFString: Any] = [
+      kSecClass: kSecClassGenericPassword,
+      kSecAttrService: keychainService,
+      kSecAttrAccount: keychainAccount,
+    ]
+    let attributes: [CFString: Any] = [kSecValueData: data]
+    var status = SecItemUpdate(query as CFDictionary, attributes as CFDictionary)
+    if status == errSecItemNotFound {
+      var addQuery = query
+      addQuery[kSecValueData] = data
+      status = SecItemAdd(addQuery as CFDictionary, nil)
+    }
+    if status != errSecSuccess {
+      NSLog("[Advenue] Keychain write for App Attest keyId failed: %d", status)
+    }
+  }
+
+  /// Removes the persisted App Attest keyId so the next resolveKeyId generates a
+  /// fresh key. Called when Apple reports the cached key as invalid.
+  @available(iOS 14.0, *)
+  private static func deleteKeyId() {
+    let query: [CFString: Any] = [
+      kSecClass: kSecClassGenericPassword,
+      kSecAttrService: keychainService,
+      kSecAttrAccount: keychainAccount,
+    ]
+    let status = SecItemDelete(query as CFDictionary)
+    if status != errSecSuccess && status != errSecItemNotFound {
+      NSLog("[Advenue] Keychain delete for App Attest keyId failed: %d", status)
+    }
+  }
+
+  /// Resolves a DCAppAttest keyId: loads from Keychain if present, otherwise
+  /// generates a new one via DCAppAttestService.generateKey and persists it.
+  @available(iOS 14.0, *)
+  private static func resolveKeyId(
+    service: DCAppAttestService,
+    completion: @escaping (Result<String, Error>) -> Void
+  ) {
+    if let cached = loadKeyId() {
+      completion(.success(cached))
+      return
+    }
+    service.generateKey { keyId, error in
+      if let error = error {
+        completion(.failure(error))
+        return
+      }
+      guard let keyId = keyId else {
+        completion(.failure(NSError(
+          domain: "io.advenue.appattest",
+          code: -1,
+          userInfo: [NSLocalizedDescriptionKey: "generateKey returned nil keyId"]
+        )))
+        return
+      }
+      saveKeyId(keyId)
+      completion(.success(keyId))
+    }
+  }
+}

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@advenue/react-native",
-  "version": "0.4.0",
+  "version": "0.5.0",
+  "description": "Advenue MMP React Native SDK — attribution, install tracking, and deep links (bundled iOS/Android Expo native modules)",
   "type": "module",
   "license": "MIT",
   "main": "./dist/index.js",
@@ -16,6 +17,9 @@
     "dist",
     "src",
     "plugin",
+    "ios",
+    "android",
+    "expo-module.config.json",
     "!**/*.test.ts"
   ],
   "publishConfig": {
@@ -26,20 +30,16 @@
     "@advenue/sdk-core": "0.3.0"
   },
   "peerDependencies": {
-    "@advenue/sdk-android": "*",
-    "@advenue/sdk-ios": "*",
     "@expo/config-plugins": ">=8",
     "react": ">=18.2",
-    "react-native": ">=0.74"
+    "react-native": ">=0.74",
+    "expo-modules-core": "*"
   },
   "peerDependenciesMeta": {
     "@expo/config-plugins": {
       "optional": true
     },
-    "@advenue/sdk-android": {
-      "optional": true
-    },
-    "@advenue/sdk-ios": {
+    "expo-modules-core": {
       "optional": true
     }
   },
@@ -47,8 +47,6 @@
     "tsup": "^8.5.1",
     "typescript": "^5.7.2",
     "vitest": "^2.1.8",
-    "@advenue/sdk-android": "0.3.0",
-    "@advenue/sdk-ios": "0.3.0",
     "@advenue/shared": "0.1.0",
     "@advenue/signing": "0.0.0"
   },

package/src/deep-links.ts

@@ -28,10 +28,13 @@ export function parseDirectLink(url: string): DeepLink {
     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()) {
+    // forEach, not entries(): the iterable protocol types live in
+    // lib.dom.iterable / @types/node, neither of which is guaranteed in the
+    // dts build's lib set — forEach is in the base lib everywhere.
+    parsed.searchParams.forEach((v, k) => {
       params ??= {};
       params[k] = v;
-    }
+    });
   } catch {
     // Unparseable URL — surface the raw value so the app can still route.
     deepLinkValue = url;

package/src/index.ts

@@ -17,7 +17,6 @@ import {
   type TrackOptions,
   resolveDurableDeviceId,
 } from '@advenue/sdk-core';
-import type { TrackingAuthorizationStatus } from '@advenue/sdk-ios';
 import { parseMatchToken } from '@advenue/shared/match-token';
 import { sha256Hex } from '@advenue/signing';
 import { type DeepLinkHandle, setupDeepLinks } from './deep-links';
@@ -31,6 +30,7 @@ import {
   getPlatformOS,
 } from './native';
 import { createNativeSecureStore, createNativeStorage } from './native-storage';
+import type { TrackingAuthorizationStatus } from './native-types';
 import { type SecureStoreLike, createSecureStore } from './secure-store';
 
 export { createMMKVStorage } from './mmkv-storage';
@@ -40,7 +40,14 @@ export type { SecureStoreLike } from './secure-store';
 export { parseDirectLink } from './deep-links';
 export type { AdvenueConfig, Consent, DeepLink, TrackOptions } from '@advenue/sdk-core';
 export { getAndroidNative, getIosNative } from './native';
-export type { TrackingAuthorizationStatus } from '@advenue/sdk-ios';
+export type {
+  AdvenueAndroidNativeModule,
+  AdvenueDeviceInfo,
+  AdvenueIosNativeModule,
+  InstallReferrerResult,
+  MetaInstallReferrerResult,
+  TrackingAuthorizationStatus,
+} from './native-types';
 
 /**
  * Resolves the device advertising id (IDFA on iOS, GAID on Android), gates it
@@ -189,7 +196,7 @@ export interface RNAdvenueConfig extends Omit<AdvenueConfig, 'storage' | 'platfo
   /**
    * 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