@kontextso/sdk-react-native 3.4.0-rc.0 → 3.4.0-rc.2

package/RNKontext.podspec

@@ -15,6 +15,7 @@ Pod::Spec.new do |s|
 
   s.source_files = "ios/**/*.{h,m,mm,cpp,swift}"
   s.private_header_files = "ios/**/*.h"
+  s.resources = ["ios/PrivacyInfo.xcprivacy"]
 
 
   install_modules_dependencies(s)

package/android/src/newarch/java/so/kontext/react/RNKontextModule.kt

@@ -54,6 +54,23 @@ class RNKontextModule(reactContext: ReactApplicationContext) :
     promise?.resolve(false)
   }
 
+  // ---------- iOS-only: SKAdNetwork ----------
+  override fun initSkAdNetworkImpression(params: String, promise: Promise?) {
+    promise?.resolve(false)
+  }
+
+  override fun startSkAdNetworkImpression(promise: Promise?) {
+    promise?.resolve(false)
+  }
+
+  override fun endSkAdNetworkImpression(promise: Promise?) {
+    promise?.resolve(false)
+  }
+
+  override fun disposeSkAdNetwork(promise: Promise?) {
+    promise?.resolve(false)
+  }
+
   companion object {
     const val NAME = "RNKontext"
   }

package/android/src/oldarch/java/so/kontext/react/RNKontextModule.kt

@@ -66,6 +66,27 @@ class RNKontextModule(reactContext: ReactApplicationContext) :
     impl.getTcfData(promise)
   }
 
+  // ---------- iOS-only: SKAdNetwork ----------
+  @ReactMethod
+  fun initSkAdNetworkImpression(params: String, promise: Promise?) {
+    promise?.resolve(false)
+  }
+
+  @ReactMethod
+  fun startSkAdNetworkImpression(promise: Promise?) {
+    promise?.resolve(false)
+  }
+
+  @ReactMethod
+  fun endSkAdNetworkImpression(promise: Promise?) {
+    promise?.resolve(false)
+  }
+
+  @ReactMethod
+  fun disposeSkAdNetwork(promise: Promise?) {
+    promise?.resolve(false)
+  }
+
   companion object {
     const val NAME = "RNKontext"
   }

package/dist/index.js

@@ -11,7 +11,7 @@ var __export = (target, all) => {
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
+    for (const key of __getOwnPropNames(from))
       if (!__hasOwnProp.call(to, key) && key !== except)
         __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }

package/ios/KontextSDK.swift

@@ -100,6 +100,72 @@ public class KontextSDK: NSObject {
         }
     }
 
+   // MARK: - SKAdNetwork
+
+    @objc
+    public static func initSkAdNetworkImpression(
+        _ paramsJson: String,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        guard
+            let data = paramsJson.data(using: .utf8),
+            let params = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else {
+            reject("SKAN_INVALID_PARAMS", "Failed to parse SKAdNetwork params JSON", nil)
+            return
+        }
+        SKAdNetworkManager.shared.initImpression(params: params) { success, error in
+            if let error = error {
+                reject("SKAN_INIT_IMPRESSION_FAILED", error.localizedDescription, error)
+            } else {
+                resolve(success)
+            }
+        }
+    }
+
+    @objc
+    public static func startSkAdNetworkImpression(
+        _ resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        SKAdNetworkManager.shared.startImpression { success, error in
+            if let error = error {
+                reject("SKAN_START_IMPRESSION_FAILED", error.localizedDescription, error)
+            } else {
+                resolve(success)
+            }
+        }
+    }
+
+    @objc
+    public static func endSkAdNetworkImpression(
+        _ resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        SKAdNetworkManager.shared.endImpression { success, error in
+            if let error = error {
+                reject("SKAN_END_IMPRESSION_FAILED", error.localizedDescription, error)
+            } else {
+                resolve(success)
+            }
+        }
+    }
+
+    @objc
+    public static func disposeSkAdNetwork(
+        _ resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        SKAdNetworkManager.shared.dispose { success, error in
+            if let error = error {
+                reject("SKAN_DISPOSE_FAILED", error.localizedDescription, error)
+            } else {
+                resolve(success)
+            }
+        }
+    }
+
     // MARK: - TCF (minimal: GDPR applies + TC string)
 
     /// Returns minimal TCF data needed for RTB:

package/ios/RNKontext.mm

@@ -76,6 +76,27 @@ RCT_EXPORT_MODULE()
     resolve([KontextSDK getVendorId]);
 }
 
+- (void)initSkAdNetworkImpression:(NSString *)params
+                          resolve:(RCTPromiseResolveBlock)resolve
+                           reject:(RCTPromiseRejectBlock)reject {
+    [KontextSDK initSkAdNetworkImpression:params resolver:resolve rejecter:reject];
+}
+
+- (void)startSkAdNetworkImpression:(RCTPromiseResolveBlock)resolve
+                            reject:(RCTPromiseRejectBlock)reject {
+    [KontextSDK startSkAdNetworkImpression:resolve rejecter:reject];
+}
+
+- (void)endSkAdNetworkImpression:(RCTPromiseResolveBlock)resolve
+                          reject:(RCTPromiseRejectBlock)reject {
+    [KontextSDK endSkAdNetworkImpression:resolve rejecter:reject];
+}
+
+- (void)disposeSkAdNetwork:(RCTPromiseResolveBlock)resolve
+                    reject:(RCTPromiseRejectBlock)reject {
+    [KontextSDK disposeSkAdNetwork:resolve rejecter:reject];
+}
+
 #else
 
 RCT_EXPORT_METHOD(isSoundOn : (RCTPromiseResolveBlock)resolve
@@ -143,6 +164,27 @@ RCT_EXPORT_METHOD(getVendorId:(RCTPromiseResolveBlock)resolve
     resolve([KontextSDK getVendorId]);
 }
 
+RCT_EXPORT_METHOD(initSkAdNetworkImpression:(NSString *)params
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    [KontextSDK initSkAdNetworkImpression:params resolver:resolve rejecter:reject];
+}
+
+RCT_EXPORT_METHOD(startSkAdNetworkImpression:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    [KontextSDK startSkAdNetworkImpression:resolve rejecter:reject];
+}
+
+RCT_EXPORT_METHOD(endSkAdNetworkImpression:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    [KontextSDK endSkAdNetworkImpression:resolve rejecter:reject];
+}
+
+RCT_EXPORT_METHOD(disposeSkAdNetwork:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    [KontextSDK disposeSkAdNetwork:resolve rejecter:reject];
+}
+
 #endif
 
 @end

package/ios/SkAdNetworkManager.swift

@@ -0,0 +1,257 @@
+import Foundation
+import StoreKit
+
+final class SKAdNetworkManager {
+    static let shared = SKAdNetworkManager()
+    private init() {}
+
+    private var skImpressionBox: Any?
+    private var isStarted: Bool = false
+
+    @available(iOS 14.5, *)
+    private var skImpression: SKAdImpression? {
+        get { skImpressionBox as? SKAdImpression }
+        set { skImpressionBox = newValue }
+    }
+
+    /// Required keys:
+    ///  - version: String
+    ///  - network: String              (adNetworkIdentifier)
+    ///  - itunesItem: String/Int       (advertisedAppStoreItemIdentifier)
+    ///  - sourceApp: String/Int        (sourceAppStoreItemIdentifier, 0 if no App Store ID)
+    /// Optional keys:
+    ///  - sourceIdentifier: String/Int (SKAdNetwork 4.0, iOS 16.1+)
+    ///  - campaign: String/Int         (adCampaignIdentifier)
+    ///  - fidelities: Array            (iOS 16.1+; each entry may contain nonce, timestamp, signature)
+    ///  - nonce: String                (adImpressionIdentifier; required if no fidelities)
+    ///  - timestamp: String/Int        (required if no fidelities)
+    ///  - signature: String            (required if no fidelities)
+    func initImpression(params: [String: Any], completion: @escaping (Bool, NSError?) -> Void) {
+        guard #available(iOS 14.5, *) else {
+            completeOnMain(completion, false, nil)
+            return
+        }
+
+        func num(_ any: Any?) -> NSNumber? {
+            if let n = any as? NSNumber { return n }
+            if let i = any as? Int      { return NSNumber(value: i) }
+            if let d = any as? Double {
+                guard d == d.rounded() else { return nil }
+                return NSNumber(value: Int(d))
+            }
+            if let s = any as? String, let i = Int(s) { return NSNumber(value: i) }
+            return nil
+        }
+
+        // Required
+        let version    = params["version"] as? String
+        let networkId  = params["network"] as? String
+        let itunesItem = num(params["itunesItem"])
+        let sourceApp  = num(params["sourceApp"]) ?? NSNumber(value: 0)
+
+        // Optional
+        let campaign         = num(params["campaign"])
+        let sourceIdentifier = num(params["sourceIdentifier"])
+        let nonce            = params["nonce"] as? String
+        let timestamp        = num(params["timestamp"])
+        let signature        = params["signature"] as? String
+        let fidelities       = params["fidelities"] as? [[String: Any]]
+
+        let hasFidelities: Bool = {
+            if #available(iOS 16.1, *) {
+                return !(fidelities?.isEmpty ?? true)
+            }
+            return false
+        }()
+
+        func isBlank(_ s: String?) -> Bool {
+            return s?.trimmingCharacters(in: .whitespaces).isEmpty ?? true
+        }
+
+        var missing: [String] = []
+        if isBlank(version)   { missing.append("version") }
+        if isBlank(networkId) { missing.append("network") }
+        if itunesItem == nil  { missing.append("itunesItem") }
+        if !hasFidelities {
+            if isBlank(nonce)     { missing.append("nonce") }
+            if timestamp == nil   { missing.append("timestamp") }
+            if isBlank(signature) { missing.append("signature") }
+        }
+
+        guard missing.isEmpty else {
+            var message = "Missing required arguments: \(missing.joined(separator: ", "))"
+            if fidelities != nil && !hasFidelities {
+                message += " Note: fidelities array was provided but is only supported on iOS 16.1+. "
+                         + "Top-level nonce/timestamp/signature are required on this OS version."
+            }
+            let error = NSError(
+                domain: "SKAdNetwork",
+                code: 1,
+                userInfo: [NSLocalizedDescriptionKey: message]
+            )
+            completeOnMain(completion, false, error)
+            return
+        }
+
+        let previousImpression = isStarted ? skImpression : nil
+        isStarted = false
+
+        if #available(iOS 16.0, *) {
+            let imp = SKAdImpression(
+                sourceAppStoreItemIdentifier: sourceApp,
+                advertisedAppStoreItemIdentifier: itunesItem!,
+                adNetworkIdentifier: networkId!,
+                adCampaignIdentifier: campaign ?? NSNumber(value: 0),
+                adImpressionIdentifier: nonce ?? "",
+                timestamp: timestamp ?? NSNumber(value: 0),
+                signature: signature ?? "",
+                version: version!
+            )
+
+            if #available(iOS 16.1, *) {
+                if let sourceIdentifier = sourceIdentifier {
+                    imp.sourceIdentifier = sourceIdentifier
+                }
+                if hasFidelities, let fidelities = fidelities {
+                    parseFidelities(fidelities, into: imp)
+                }
+            }
+
+            skImpression = imp
+        } else {
+            // iOS 14.5–15.x: memberwise initializer not available, use property-based init
+            let imp = SKAdImpression()
+            imp.sourceAppStoreItemIdentifier     = sourceApp
+            imp.advertisedAppStoreItemIdentifier = itunesItem!
+            imp.adNetworkIdentifier              = networkId!
+            imp.adCampaignIdentifier             = campaign ?? NSNumber(value: 0)
+            imp.adImpressionIdentifier           = nonce ?? ""
+            imp.timestamp                        = timestamp ?? NSNumber(value: 0)
+            imp.signature                        = signature ?? ""
+            imp.version                          = version!
+            skImpression = imp
+        }
+
+        // End the previous impression only after the new one is safely stored.
+        // Failure here is best-effort — we log it but don't block the caller.
+        if let old = previousImpression {
+            SKAdNetwork.endImpression(old) { error in
+                if let error = error {
+                    print("[SKAdNetwork] Warning: failed to end previous impression: \(error)")
+                }
+            }
+        }
+
+        completeOnMain(completion, true, nil)
+    }
+
+    func startImpression(completion: @escaping (Bool, NSError?) -> Void) {
+        guard #available(iOS 14.5, *) else {
+            completeOnMain(completion, false, nil)
+            return
+        }
+        guard let impression = skImpression else {
+            let error = NSError(
+                domain: "SKAdNetwork",
+                code: 2,
+                userInfo: [NSLocalizedDescriptionKey: "SKAdImpression not initialized. Call initImpression first."]
+            )
+            completeOnMain(completion, false, error)
+            return
+        }
+        guard !isStarted else {
+            // Already started — ignore duplicate call
+            completeOnMain(completion, true, nil)
+            return
+        }
+
+        isStarted = true
+        SKAdNetwork.startImpression(impression) { [weak self] error in
+            if let error = error {
+                self?.isStarted = false
+                let nsError = NSError(
+                    domain: "SKAdNetwork",
+                    code: 3,
+                    userInfo: [NSLocalizedDescriptionKey: "Failed to start SKAdImpression: \(error)"]
+                )
+                self?.completeOnMain(completion, false, nsError)
+            } else {
+                self?.completeOnMain(completion, true, nil)
+            }
+        }
+    }
+
+    func endImpression(completion: @escaping (Bool, NSError?) -> Void) {
+        guard #available(iOS 14.5, *) else {
+            completeOnMain(completion, false, nil)
+            return
+        }
+        guard let impression = skImpression else {
+            let error = NSError(
+                domain: "SKAdNetwork",
+                code: 2,
+                userInfo: [NSLocalizedDescriptionKey: "SKAdImpression not initialized. Call initImpression first."]
+            )
+            completeOnMain(completion, false, error)
+            return
+        }
+        guard isStarted else {
+            // Not started — ignore unmatched endImpression
+            completeOnMain(completion, true, nil)
+            return
+        }
+
+        isStarted = false
+        SKAdNetwork.endImpression(impression) { [weak self] error in
+            if let error = error {
+                self?.isStarted = true // roll back — end failed
+                let nsError = NSError(
+                    domain: "SKAdNetwork",
+                    code: 4,
+                    userInfo: [NSLocalizedDescriptionKey: "Failed to end SKAdImpression: \(error)"]
+                )
+                self?.completeOnMain(completion, false, nsError)
+            } else {
+                self?.completeOnMain(completion, true, nil)
+            }
+        }
+    }
+
+    func dispose(completion: @escaping (Bool, NSError?) -> Void) {
+        if #available(iOS 14.5, *), isStarted, let impression = skImpression {
+            isStarted = false
+            SKAdNetwork.endImpression(impression) { _ in }
+        } else {
+            isStarted = false
+        }
+
+        skImpressionBox = nil
+        completeOnMain(completion, true, nil)
+    }
+
+    // MARK: - Private
+
+    @available(iOS 16.1, *)
+    private func parseFidelities(_ fidelities: [[String: Any]], into imp: SKAdImpression) {
+        for f in fidelities {
+            if imp.adImpressionIdentifier.isEmpty, let nonce = f["nonce"] as? String {
+                imp.adImpressionIdentifier = nonce
+            }
+            if imp.timestamp == NSNumber(value: 0) {
+                if let n = f["timestamp"] as? NSNumber { imp.timestamp = n }
+                else if let s = f["timestamp"] as? String, let i = Int(s) { imp.timestamp = NSNumber(value: i) }
+            }
+            if imp.signature.isEmpty, let sig = f["signature"] as? String {
+                imp.signature = sig
+            }
+        }
+    }
+
+    private func completeOnMain(_ completion: @escaping (Bool, NSError?) -> Void, _ success: Bool, _ error: NSError?) {
+        if Thread.isMainThread {
+            completion(success, error)
+        } else {
+            DispatchQueue.main.async { completion(success, error) }
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kontextso/sdk-react-native",
-  "version": "3.4.0-rc.0",
+  "version": "3.4.0-rc.2",
   "description": "Kontext SDK for React Native",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -20,7 +20,7 @@
     "format": "biome format --write ."
   },
   "devDependencies": {
-    "@kontextso/sdk-common": "^1.0.4",
+    "@kontextso/sdk-common": "^1.0.7",
     "@kontextso/typescript-config": "*",
     "@react-native-community/netinfo": "11.3.1",
     "@testing-library/dom": "^10.4.0",
@@ -47,14 +47,14 @@
     "vitest": "^2.1.2"
   },
   "peerDependencies": {
-    "@react-native-community/netinfo": "^11.0",
+    "@react-native-community/netinfo": ">=11.0",
     "react": ">=18.0.0",
     "react-native": ">=0.73.0",
     "react-native-device-info": ">=10.0.0 <15.0.0",
     "react-native-webview": "^13.10.0"
   },
   "dependencies": {
-    "@kontextso/sdk-react": "^3.0.8-rc.0"
+    "@kontextso/sdk-react": "^3.0.9"
   },
   "files": [
     "dist/*",

package/src/NativeRNKontext.ts

@@ -22,6 +22,12 @@ export interface Spec extends TurboModule {
   // IFA
   getAdvertisingId(): Promise<string | null>
   getVendorId(): Promise<string | null>
+
+  // SKAdNetwork
+  initSkAdNetworkImpression(params: string): Promise<boolean>
+  startSkAdNetworkImpression(): Promise<boolean>
+  endSkAdNetworkImpression(): Promise<boolean>
+  disposeSkAdNetwork(): Promise<boolean>
 }
 
 export default TurboModuleRegistry.getEnforcing<Spec>('RNKontext')

package/src/formats/Format.tsx

@@ -18,6 +18,12 @@ import { useContext, useEffect, useRef, useState } from 'react'
 import { Keyboard, Linking, Modal, useWindowDimensions, View } from 'react-native'
 import type { WebView, WebViewMessageEvent } from 'react-native-webview'
 import FrameWebView from '../frame-webview'
+import {
+  disposeSkAdNetwork,
+  endSkAdNetworkImpression,
+  initSkAdNetworkImpression,
+  startSkAdNetworkImpression,
+} from '../services/SkAdNetwork'
 import { dismissSKOverlay, presentSKOverlay, type SKOverlayPosition } from '../services/SkOverlay'
 import { dismissSKStoreProduct, presentSKStoreProduct } from '../services/SkStoreProduct'
 
@@ -55,6 +61,11 @@ enum MessageStatus {
   MessageReceived = 'message-received',
 }
 
+enum AttributionType {
+  None = 'none',
+  Skan = 'skan',
+}
+
 const Format = ({ code, messageId, wrapper, onEvent, ...otherParams }: FormatProps) => {
   const context = useContext(AdsContext)
 
@@ -76,6 +87,8 @@ const Format = ({ code, messageId, wrapper, onEvent, ...otherParams }: FormatPro
   const [containerStyles, setContainerStyles] = useState<any>({})
   const [iframeStyles, setIframeStyles] = useState<any>({})
 
+  const attributionTypeRef = useRef<AttributionType>(AttributionType.None)
+
   const containerRef = useRef<View>(null)
   const webViewRef = useRef<WebView>(null)
   const modalWebViewRef = useRef<WebView>(null)
@@ -211,6 +224,45 @@ const Format = ({ code, messageId, wrapper, onEvent, ...otherParams }: FormatPro
     }
   }
 
+  const handleAttributionInit = async () => {
+    if (!bid?.skan) {
+      return
+    }
+    try {
+      const success = await initSkAdNetworkImpression(bid.skan)
+      if (success) {
+        attributionTypeRef.current = AttributionType.Skan
+      }
+    } catch (e) {
+      debug('error-attribution-init', { error: e })
+      console.error('error initializing skadnetwork impression', e)
+    }
+  }
+
+  const handleAttributionBeginView = async () => {
+    try {
+      if (attributionTypeRef.current === AttributionType.Skan) {
+        await startSkAdNetworkImpression()
+      }
+    } catch (e) {
+      debug('error-attribution-begin-view', { error: e })
+      console.error('error starting skadnetwork impression', e)
+    }
+  }
+
+  const cleanupAttribution = async () => {
+    try {
+      if (attributionTypeRef.current === AttributionType.Skan) {
+        await endSkAdNetworkImpression()
+        await disposeSkAdNetwork()
+      }
+    } catch (e) {
+      console.error('error cleaning up skadnetwork', e)
+    } finally {
+      attributionTypeRef.current = AttributionType.None
+    }
+  }
+
   const openUrl = async (message: IframeMessage<'click-iframe'>) => {
     if (!message.data.url) {
       return
@@ -261,6 +313,9 @@ const Format = ({ code, messageId, wrapper, onEvent, ...otherParams }: FormatPro
                 otherParams,
                 messageId,
               })
+              if (bid?.skan) {
+                handleAttributionInit()
+              }
               break
 
             case 'error-iframe':
@@ -283,6 +338,7 @@ const Format = ({ code, messageId, wrapper, onEvent, ...otherParams }: FormatPro
               if (bid?.bidId && message.data.cachedContent) {
                 context?.cachedContentRef?.current?.set(bid.bidId, message.data.cachedContent)
               }
+              handleAttributionBeginView()
               break
 
             case 'show-iframe':
@@ -461,6 +517,12 @@ const Format = ({ code, messageId, wrapper, onEvent, ...otherParams }: FormatPro
 
   const paramsString = convertParamsToString(otherParams)
 
+  useEffect(() => {
+    return () => {
+      cleanupAttribution()
+    }
+  }, [])
+
   useEffect(() => {
     if (!iframeLoaded || !context?.adServerUrl || !bid || !webViewRef.current) {
       return

package/src/services/SkAdNetwork.ts

@@ -0,0 +1,75 @@
+import { Platform } from 'react-native'
+import NativeRNKontext from '../NativeRNKontext'
+
+export interface SkAdNetworkFidelity {
+  fidelity: number
+  signature: string
+  nonce: string
+  timestamp: string | number
+}
+
+export interface SkAdNetworkImpressionParams {
+  // Required
+  version: string
+  network: string
+  itunesItem: string | number
+  sourceApp: string | number
+  // Optional
+  sourceIdentifier?: string | number
+  campaign?: string | number
+  fidelities?: SkAdNetworkFidelity[]
+  nonce?: string
+  timestamp?: string | number
+  signature?: string
+}
+
+let impressionReady = false
+
+export async function initSkAdNetworkImpression(params: SkAdNetworkImpressionParams): Promise<boolean> {
+  if (Platform.OS !== 'ios') return false
+
+  try {
+    const result = await NativeRNKontext.initSkAdNetworkImpression(JSON.stringify(params))
+    impressionReady = result
+    return result
+  } catch (e) {
+    impressionReady = false
+    console.error('[SKAdNetwork] Error initializing impression:', e)
+    return false
+  }
+}
+
+export async function startSkAdNetworkImpression(): Promise<boolean> {
+  if (Platform.OS !== 'ios' || !impressionReady) return false
+
+  try {
+    return await NativeRNKontext.startSkAdNetworkImpression()
+  } catch (e) {
+    console.error('[SKAdNetwork] Error starting impression:', e)
+    return false
+  }
+}
+
+export async function endSkAdNetworkImpression(): Promise<boolean> {
+  if (Platform.OS !== 'ios' || !impressionReady) return false
+
+  try {
+    return await NativeRNKontext.endSkAdNetworkImpression()
+  } catch (e) {
+    console.error('[SKAdNetwork] Error ending impression:', e)
+    return false
+  }
+}
+
+export async function disposeSkAdNetwork(): Promise<boolean> {
+  impressionReady = false
+
+  if (Platform.OS !== 'ios') return false
+
+  try {
+    return await NativeRNKontext.disposeSkAdNetwork()
+  } catch (e) {
+    console.error('[SKAdNetwork] Error disposing:', e)
+    return false
+  }
+}