insert-affiliate-react-native-sdk 1.11.1 → 1.12.0

package/.claude/settings.local.json

@@ -10,7 +10,10 @@
       "Bash(adb shell:*)",
       "Bash(adb shell am start:*)",
       "Bash(git checkout:*)",
-      "Bash(git pull:*)"
+      "Bash(git pull:*)",
+      "Bash(ssh root@46.101.83.25 \"pm2 logs --lines 200\")",
+      "Bash(ssh:*)",
+      "Bash(gh api:*)"
     ],
     "deny": []
   }

package/dist/DeepLinkIapProvider.d.ts

@@ -2,7 +2,7 @@ import React from 'react';
 type T_DEEPLINK_IAP_PROVIDER = {
     children: React.ReactNode;
 };
-export type InsertAffiliateIdentifierChangeCallback = (identifier: string | null) => void;
+export type InsertAffiliateIdentifierChangeCallback = (identifier: string | null, offerCode: string | null) => void;
 export type AffiliateDetails = {
     affiliateName: string;
     affiliateShortCode: string;
@@ -18,6 +18,7 @@ type T_DEEPLINK_IAP_CONTEXT = {
     returnInsertAffiliateIdentifier: (ignoreTimeout?: boolean) => Promise<string | null>;
     isAffiliateAttributionValid: () => Promise<boolean>;
     getAffiliateStoredDate: () => Promise<Date | null>;
+    getAffiliateExpiryTimestamp: () => Promise<number | null>;
     validatePurchaseWithIapticAPI: (jsonIapPurchase: CustomPurchase, iapticAppId: string, iapticAppName: string, iapticPublicKey: string) => Promise<boolean>;
     returnUserAccountTokenAndStoreExpectedTransaction: () => Promise<string | null>;
     storeExpectedStoreTransaction: (purchaseToken: string) => Promise<void>;
@@ -27,7 +28,7 @@ type T_DEEPLINK_IAP_CONTEXT = {
     setInsertAffiliateIdentifier: (referringLink: string) => Promise<void | string>;
     setInsertAffiliateIdentifierChangeCallback: (callback: InsertAffiliateIdentifierChangeCallback | null) => void;
     handleInsertLinks: (url: string) => Promise<boolean>;
-    initialize: (code: string | null, verboseLogging?: boolean, insertLinksEnabled?: boolean, insertLinksClipboardEnabled?: boolean, affiliateAttributionActiveTime?: number) => Promise<void>;
+    initialize: (code: string | null, verboseLogging?: boolean, insertLinksEnabled?: boolean, insertLinksClipboardEnabled?: boolean, affiliateAttributionActiveTime?: number, preventAffiliateTransfer?: boolean) => Promise<void>;
     isInitialized: boolean;
 };
 export declare const DeepLinkIapContext: React.Context<T_DEEPLINK_IAP_CONTEXT>;

package/dist/DeepLinkIapProvider.js

@@ -52,7 +52,7 @@ const ASYNC_KEYS = {
     USER_ID: '@app_user_id',
     COMPANY_CODE: '@app_company_code',
     USER_ACCOUNT_TOKEN: '@app_user_account_token',
-    IOS_OFFER_CODE: '@app_ios_offer_code',
+    OFFER_CODE: '@app_offer_code',
     AFFILIATE_STORED_DATE: '@app_affiliate_stored_date',
     SDK_INIT_REPORTED: '@app_sdk_init_reported',
     REPORTED_AFFILIATE_ASSOCIATIONS: '@app_reported_affiliate_associations',
@@ -65,6 +65,7 @@ exports.DeepLinkIapContext = (0, react_1.createContext)({
     returnInsertAffiliateIdentifier: (ignoreTimeout) => __awaiter(void 0, void 0, void 0, function* () { return ''; }),
     isAffiliateAttributionValid: () => __awaiter(void 0, void 0, void 0, function* () { return false; }),
     getAffiliateStoredDate: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
+    getAffiliateExpiryTimestamp: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
     validatePurchaseWithIapticAPI: (jsonIapPurchase, iapticAppId, iapticAppName, iapticPublicKey) => __awaiter(void 0, void 0, void 0, function* () { return false; }),
     returnUserAccountTokenAndStoreExpectedTransaction: () => __awaiter(void 0, void 0, void 0, function* () { return ''; }),
     storeExpectedStoreTransaction: (purchaseToken) => __awaiter(void 0, void 0, void 0, function* () { }),
@@ -74,7 +75,7 @@ exports.DeepLinkIapContext = (0, react_1.createContext)({
     setInsertAffiliateIdentifier: (referringLink) => __awaiter(void 0, void 0, void 0, function* () { }),
     setInsertAffiliateIdentifierChangeCallback: (callback) => { },
     handleInsertLinks: (url) => __awaiter(void 0, void 0, void 0, function* () { return false; }),
-    initialize: (code, verboseLogging, insertLinksEnabled, insertLinksClipboardEnabled, affiliateAttributionActiveTime) => __awaiter(void 0, void 0, void 0, function* () { }),
+    initialize: (code, verboseLogging, insertLinksEnabled, insertLinksClipboardEnabled, affiliateAttributionActiveTime, preventAffiliateTransfer) => __awaiter(void 0, void 0, void 0, function* () { }),
     isInitialized: false,
 });
 const DeepLinkIapProvider = ({ children, }) => {
@@ -87,11 +88,13 @@ const DeepLinkIapProvider = ({ children, }) => {
     const [insertLinksClipboardEnabled, setInsertLinksClipboardEnabled] = (0, react_1.useState)(false);
     const [OfferCode, setOfferCode] = (0, react_1.useState)(null);
     const [affiliateAttributionActiveTime, setAffiliateAttributionActiveTime] = (0, react_1.useState)(null);
+    const [preventAffiliateTransfer, setPreventAffiliateTransfer] = (0, react_1.useState)(false);
     const insertAffiliateIdentifierChangeCallbackRef = (0, react_1.useRef)(null);
     const isInitializingRef = (0, react_1.useRef)(false);
     // Refs for values that need to be current inside callbacks (to avoid stale closures)
     const companyCodeRef = (0, react_1.useRef)(null);
     const verboseLoggingRef = (0, react_1.useRef)(false);
+    const preventAffiliateTransferRef = (0, react_1.useRef)(false);
     // Refs for implementation functions (ref callback pattern for stable + fresh)
     const initializeImplRef = (0, react_1.useRef)(null);
     const setShortCodeImplRef = (0, react_1.useRef)(null);
@@ -99,6 +102,7 @@ const DeepLinkIapProvider = ({ children, }) => {
     const returnInsertAffiliateIdentifierImplRef = (0, react_1.useRef)(null);
     const isAffiliateAttributionValidImplRef = (0, react_1.useRef)(null);
     const getAffiliateStoredDateImplRef = (0, react_1.useRef)(null);
+    const getAffiliateExpiryTimestampImplRef = (0, react_1.useRef)(null);
     const storeExpectedStoreTransactionImplRef = (0, react_1.useRef)(null);
     const returnUserAccountTokenAndStoreExpectedTransactionImplRef = (0, react_1.useRef)(null);
     const validatePurchaseWithIapticAPIImplRef = (0, react_1.useRef)(null);
@@ -106,7 +110,7 @@ const DeepLinkIapProvider = ({ children, }) => {
     const setInsertAffiliateIdentifierImplRef = (0, react_1.useRef)(null);
     const handleInsertLinksImplRef = (0, react_1.useRef)(null);
     // MARK: Initialize the SDK
-    const initializeImpl = (companyCodeParam_1, ...args_1) => __awaiter(void 0, [companyCodeParam_1, ...args_1], void 0, function* (companyCodeParam, verboseLoggingParam = false, insertLinksEnabledParam = false, insertLinksClipboardEnabledParam = false, affiliateAttributionActiveTimeParam) {
+    const initializeImpl = (companyCodeParam_1, ...args_1) => __awaiter(void 0, [companyCodeParam_1, ...args_1], void 0, function* (companyCodeParam, verboseLoggingParam = false, insertLinksEnabledParam = false, insertLinksClipboardEnabledParam = false, affiliateAttributionActiveTimeParam, preventAffiliateTransferParam = false) {
         // Prevent multiple concurrent initialization attempts
         if (isInitialized || isInitializingRef.current) {
             return;
@@ -119,6 +123,8 @@ const DeepLinkIapProvider = ({ children, }) => {
         if (affiliateAttributionActiveTimeParam !== undefined) {
             setAffiliateAttributionActiveTime(affiliateAttributionActiveTimeParam);
         }
+        setPreventAffiliateTransfer(preventAffiliateTransferParam);
+        preventAffiliateTransferRef.current = preventAffiliateTransferParam;
         if (verboseLoggingParam) {
             console.log('[Insert Affiliate] [VERBOSE] Starting SDK initialization...');
             console.log('[Insert Affiliate] [VERBOSE] Company code provided:', companyCodeParam ? 'Yes' : 'No');
@@ -163,11 +169,21 @@ const DeepLinkIapProvider = ({ children, }) => {
                 const uId = yield getValueFromAsync(ASYNC_KEYS.USER_ID);
                 const refLink = yield getValueFromAsync(ASYNC_KEYS.REFERRER_LINK);
                 const companyCodeFromStorage = yield getValueFromAsync(ASYNC_KEYS.COMPANY_CODE);
-                const storedOfferCode = yield getValueFromAsync(ASYNC_KEYS.IOS_OFFER_CODE);
+                // Migration: check new key first, fall back to legacy iOS key
+                let storedOfferCode = yield getValueFromAsync(ASYNC_KEYS.OFFER_CODE);
+                if (!storedOfferCode) {
+                    const legacyOfferCode = yield getValueFromAsync('@app_ios_offer_code');
+                    if (legacyOfferCode) {
+                        storedOfferCode = legacyOfferCode;
+                        // Migrate to new key
+                        yield saveValueInAsync(ASYNC_KEYS.OFFER_CODE, legacyOfferCode);
+                        verboseLog('Migrated offer code from legacy iOS key to new key');
+                    }
+                }
                 verboseLog(`User ID found: ${uId ? 'Yes' : 'No'}`);
                 verboseLog(`Referrer link found: ${refLink ? 'Yes' : 'No'}`);
                 verboseLog(`Company code found: ${companyCodeFromStorage ? 'Yes' : 'No'}`);
-                verboseLog(`iOS Offer Code found: ${storedOfferCode ? 'Yes' : 'No'}`);
+                verboseLog(`Offer Code found: ${storedOfferCode ? 'Yes' : 'No'}`);
                 if (uId && refLink) {
                     setUserId(uId);
                     setReferrerLink(refLink);
@@ -180,7 +196,7 @@ const DeepLinkIapProvider = ({ children, }) => {
                 }
                 if (storedOfferCode) {
                     setOfferCode(storedOfferCode);
-                    verboseLog('iOS Offer Code restored from storage');
+                    verboseLog('Offer Code restored from storage');
                 }
             }
             catch (error) {
@@ -1393,6 +1409,29 @@ const DeepLinkIapProvider = ({ children, }) => {
             return null;
         }
     });
+    // Get the timestamp when attribution expires (stored date + timeout duration in ms)
+    // Returns null if no timeout is configured or no stored date exists
+    const getAffiliateExpiryTimestampImpl = () => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            if (!affiliateAttributionActiveTime) {
+                verboseLog('No attribution timeout configured, no expiry timestamp');
+                return null;
+            }
+            const storedDate = yield getAffiliateStoredDateImpl();
+            if (!storedDate) {
+                verboseLog('No stored date found, cannot calculate expiry timestamp');
+                return null;
+            }
+            // Convert timeout from seconds to milliseconds and add to stored date
+            const expiryTimestamp = storedDate.getTime() + (affiliateAttributionActiveTime * 1000);
+            verboseLog(`Attribution expiry timestamp: ${expiryTimestamp} (${new Date(expiryTimestamp).toISOString()})`);
+            return expiryTimestamp;
+        }
+        catch (error) {
+            verboseLog(`Error getting affiliate expiry timestamp: ${error}`);
+            return null;
+        }
+    });
     // MARK: Insert Affiliate Identifier
     const setInsertAffiliateIdentifierImpl = (referringLink) => __awaiter(void 0, void 0, void 0, function* () {
         console.log('[Insert Affiliate] Setting affiliate identifier.');
@@ -1471,13 +1510,19 @@ const DeepLinkIapProvider = ({ children, }) => {
     });
     function storeInsertAffiliateIdentifier(_a) {
         return __awaiter(this, arguments, void 0, function* ({ link, source }) {
-            console.log(`[Insert Affiliate] Storing affiliate identifier: ${link} (source: ${source})`);
+            verboseLog(`Storing affiliate identifier: ${link} (source: ${source})`);
             // Check if we're trying to store the same link (prevent duplicate storage)
             const existingLink = yield getValueFromAsync(ASYNC_KEYS.REFERRER_LINK);
             if (existingLink === link) {
                 verboseLog(`Link ${link} is already stored, skipping duplicate storage`);
                 return;
             }
+            // Prevent transfer of affiliate if enabled - keep original affiliate
+            verboseLog(`preventAffiliateTransfer check: enabled=${preventAffiliateTransferRef.current}, existingLink=${existingLink}, newLink=${link}`);
+            if (preventAffiliateTransferRef.current && existingLink && existingLink !== link) {
+                verboseLog(`Transfer blocked: existing affiliate "${existingLink}" protected from being replaced by "${link}"`);
+                return;
+            }
             verboseLog(`Updating React state with referrer link: ${link}`);
             setReferrerLink(link);
             verboseLog(`Saving referrer link to AsyncStorage...`);
@@ -1489,12 +1534,12 @@ const DeepLinkIapProvider = ({ children, }) => {
             verboseLog(`Referrer link saved to AsyncStorage successfully`);
             // Automatically fetch and store offer code for any affiliate identifier
             verboseLog('Attempting to fetch offer code for stored affiliate identifier...');
-            yield retrieveAndStoreOfferCode(link);
-            // Trigger callback with the current affiliate identifier
+            const offerCode = yield retrieveAndStoreOfferCode(link);
+            // Trigger callback with the current affiliate identifier and offer code
             if (insertAffiliateIdentifierChangeCallbackRef.current) {
                 const currentIdentifier = yield returnInsertAffiliateIdentifierImpl();
-                verboseLog(`Triggering callback with identifier: ${currentIdentifier}`);
-                insertAffiliateIdentifierChangeCallbackRef.current(currentIdentifier);
+                verboseLog(`Triggering callback with identifier: ${currentIdentifier}, offerCode: ${offerCode}`);
+                insertAffiliateIdentifierChangeCallbackRef.current(currentIdentifier, offerCode);
             }
             // Report this new affiliate association to the backend (fire and forget)
             const fullIdentifier = yield returnInsertAffiliateIdentifierImpl();
@@ -1734,21 +1779,24 @@ const DeepLinkIapProvider = ({ children, }) => {
             const offerCode = yield fetchOfferCode(affiliateLink);
             if (offerCode && offerCode.length > 0) {
                 // Store in both AsyncStorage and state
-                yield saveValueInAsync(ASYNC_KEYS.IOS_OFFER_CODE, offerCode);
+                yield saveValueInAsync(ASYNC_KEYS.OFFER_CODE, offerCode);
                 setOfferCode(offerCode);
                 verboseLog(`Successfully stored offer code: ${offerCode}`);
                 console.log('[Insert Affiliate] Offer code retrieved and stored successfully');
+                return offerCode;
             }
             else {
                 verboseLog('No valid offer code found to store');
                 // Clear stored offer code if none found
-                yield saveValueInAsync(ASYNC_KEYS.IOS_OFFER_CODE, '');
+                yield saveValueInAsync(ASYNC_KEYS.OFFER_CODE, '');
                 setOfferCode(null);
+                return null;
             }
         }
         catch (error) {
             console.error('[Insert Affiliate] Error retrieving and storing offer code:', error);
             verboseLog(`Error in retrieveAndStoreOfferCode: ${error}`);
+            return null;
         }
     });
     const removeSpecialCharacters = (offerCode) => {
@@ -1768,6 +1816,7 @@ const DeepLinkIapProvider = ({ children, }) => {
     returnInsertAffiliateIdentifierImplRef.current = returnInsertAffiliateIdentifierImpl;
     isAffiliateAttributionValidImplRef.current = isAffiliateAttributionValidImpl;
     getAffiliateStoredDateImplRef.current = getAffiliateStoredDateImpl;
+    getAffiliateExpiryTimestampImplRef.current = getAffiliateExpiryTimestampImpl;
     storeExpectedStoreTransactionImplRef.current = storeExpectedStoreTransactionImpl;
     returnUserAccountTokenAndStoreExpectedTransactionImplRef.current = returnUserAccountTokenAndStoreExpectedTransactionImpl;
     validatePurchaseWithIapticAPIImplRef.current = validatePurchaseWithIapticAPIImpl;
@@ -1778,8 +1827,8 @@ const DeepLinkIapProvider = ({ children, }) => {
     // STABLE WRAPPERS: useCallback with [] deps that delegate to refs
     // These provide stable function references that always call current implementations
     // ============================================================================
-    const initialize = (0, react_1.useCallback)((code, verboseLogging, insertLinksEnabled, insertLinksClipboardEnabled, affiliateAttributionActiveTime) => __awaiter(void 0, void 0, void 0, function* () {
-        return initializeImplRef.current(code, verboseLogging, insertLinksEnabled, insertLinksClipboardEnabled, affiliateAttributionActiveTime);
+    const initialize = (0, react_1.useCallback)((code, verboseLogging, insertLinksEnabled, insertLinksClipboardEnabled, affiliateAttributionActiveTime, preventAffiliateTransfer) => __awaiter(void 0, void 0, void 0, function* () {
+        return initializeImplRef.current(code, verboseLogging, insertLinksEnabled, insertLinksClipboardEnabled, affiliateAttributionActiveTime, preventAffiliateTransfer);
     }), []);
     const setShortCode = (0, react_1.useCallback)((shortCode) => __awaiter(void 0, void 0, void 0, function* () {
         return setShortCodeImplRef.current(shortCode);
@@ -1796,6 +1845,9 @@ const DeepLinkIapProvider = ({ children, }) => {
     const getAffiliateStoredDate = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
         return getAffiliateStoredDateImplRef.current();
     }), []);
+    const getAffiliateExpiryTimestamp = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
+        return getAffiliateExpiryTimestampImplRef.current();
+    }), []);
     const storeExpectedStoreTransaction = (0, react_1.useCallback)((purchaseToken) => __awaiter(void 0, void 0, void 0, function* () {
         return storeExpectedStoreTransactionImplRef.current(purchaseToken);
     }), []);
@@ -1813,6 +1865,21 @@ const DeepLinkIapProvider = ({ children, }) => {
     }), []);
     const setInsertAffiliateIdentifierChangeCallbackHandler = (0, react_1.useCallback)((callback) => {
         insertAffiliateIdentifierChangeCallbackRef.current = callback;
+        // If callback is being set, immediately call it with the current identifier and offer code values
+        // This ensures callbacks registered after initialization still receive the current state (including null if expired/not set)
+        if (callback) {
+            Promise.all([
+                returnInsertAffiliateIdentifierImpl(),
+                getValueFromAsync(ASYNC_KEYS.OFFER_CODE)
+            ]).then(([identifier, storedOfferCode]) => {
+                // Verify callback is still the same (wasn't replaced during async operation)
+                if (insertAffiliateIdentifierChangeCallbackRef.current === callback) {
+                    const offerCode = storedOfferCode && storedOfferCode.length > 0 ? storedOfferCode : null;
+                    verboseLog(`Calling callback immediately with current identifier: ${identifier}, offerCode: ${offerCode}`);
+                    callback(identifier, offerCode);
+                }
+            });
+        }
     }, []);
     const handleInsertLinks = (0, react_1.useCallback)((url) => __awaiter(void 0, void 0, void 0, function* () {
         return handleInsertLinksImplRef.current(url);
@@ -1826,6 +1893,7 @@ const DeepLinkIapProvider = ({ children, }) => {
             returnInsertAffiliateIdentifier,
             isAffiliateAttributionValid,
             getAffiliateStoredDate,
+            getAffiliateExpiryTimestamp,
             storeExpectedStoreTransaction,
             returnUserAccountTokenAndStoreExpectedTransaction,
             validatePurchaseWithIapticAPI,

package/dist/useDeepLinkIapProvider.d.ts

@@ -9,13 +9,14 @@ declare const useDeepLinkIapProvider: () => {
     returnInsertAffiliateIdentifier: (ignoreTimeout?: boolean) => Promise<string | null>;
     isAffiliateAttributionValid: () => Promise<boolean>;
     getAffiliateStoredDate: () => Promise<Date | null>;
+    getAffiliateExpiryTimestamp: () => Promise<number | null>;
     trackEvent: (eventName: string) => Promise<void>;
     setShortCode: (shortCode: string) => Promise<boolean>;
     getAffiliateDetails: (affiliateCode: string) => Promise<import("./DeepLinkIapProvider").AffiliateDetails>;
     setInsertAffiliateIdentifier: (referringLink: string) => Promise<void | string>;
     setInsertAffiliateIdentifierChangeCallback: (callback: import("./DeepLinkIapProvider").InsertAffiliateIdentifierChangeCallback | null) => void;
     handleInsertLinks: (url: string) => Promise<boolean>;
-    initialize: (code: string | null, verboseLogging?: boolean, insertLinksEnabled?: boolean, insertLinksClipboardEnabled?: boolean, affiliateAttributionActiveTime?: number) => Promise<void>;
+    initialize: (code: string | null, verboseLogging?: boolean, insertLinksEnabled?: boolean, insertLinksClipboardEnabled?: boolean, affiliateAttributionActiveTime?: number, preventAffiliateTransfer?: boolean) => Promise<void>;
     isInitialized: boolean;
     OfferCode: string | null;
 };

package/dist/useDeepLinkIapProvider.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const react_1 = require("react");
 const DeepLinkIapProvider_1 = require("./DeepLinkIapProvider");
 const useDeepLinkIapProvider = () => {
-    const { referrerLink, userId, validatePurchaseWithIapticAPI, storeExpectedStoreTransaction, returnUserAccountTokenAndStoreExpectedTransaction, returnInsertAffiliateIdentifier, isAffiliateAttributionValid, getAffiliateStoredDate, trackEvent, setShortCode, getAffiliateDetails, setInsertAffiliateIdentifier, setInsertAffiliateIdentifierChangeCallback, handleInsertLinks, initialize, isInitialized, OfferCode, } = (0, react_1.useContext)(DeepLinkIapProvider_1.DeepLinkIapContext);
+    const { referrerLink, userId, validatePurchaseWithIapticAPI, storeExpectedStoreTransaction, returnUserAccountTokenAndStoreExpectedTransaction, returnInsertAffiliateIdentifier, isAffiliateAttributionValid, getAffiliateStoredDate, getAffiliateExpiryTimestamp, trackEvent, setShortCode, getAffiliateDetails, setInsertAffiliateIdentifier, setInsertAffiliateIdentifierChangeCallback, handleInsertLinks, initialize, isInitialized, OfferCode, } = (0, react_1.useContext)(DeepLinkIapProvider_1.DeepLinkIapContext);
     return {
         referrerLink,
         userId,
@@ -13,6 +13,7 @@ const useDeepLinkIapProvider = () => {
         returnInsertAffiliateIdentifier,
         isAffiliateAttributionValid,
         getAffiliateStoredDate,
+        getAffiliateExpiryTimestamp,
         trackEvent,
         setShortCode,
         getAffiliateDetails,

package/docs/deep-linking-appsflyer.md

@@ -64,6 +64,7 @@ const DeepLinkHandler = () => {
 
             if (insertAffiliateIdentifier) {
               await Purchases.setAttributes({ "insert_affiliate": insertAffiliateIdentifier });
+              await Purchases.syncAttributesAndOfferingsIfNeeded();
             }
           } catch (err) {
             console.error('Error setting affiliate identifier:', err);

package/docs/deep-linking-branch.md

@@ -50,6 +50,7 @@ const DeepLinkHandler = () => {
 
             if (insertAffiliateIdentifier) {
               await Purchases.setAttributes({ "insert_affiliate": insertAffiliateIdentifier });
+              await Purchases.syncAttributesAndOfferingsIfNeeded();
             }
           } catch (err) {
             console.error('Error setting affiliate identifier:', err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "insert-affiliate-react-native-sdk",
-  "version": "1.11.1",
+  "version": "1.12.0",
   "description": "A package for connecting with the Insert Affiliate Platform to add app based affiliate marketing.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/readme.md

@@ -46,10 +46,13 @@ npm install @react-native-async-storage/async-storage @react-native-clipboard/cl
 
 **Step 3:** Install iOS pods (iOS only)
 
+For **bare React Native** projects:
 ```bash
 cd ios && pod install && cd ..
 ```
 
+For **Expo managed workflow**: Skip this step - pods are installed automatically when you run `npx expo prebuild` or `npx expo run:ios`.
+
 ### Your First Integration
 
 **In `index.js`** - Wrap your app with the provider:
@@ -139,7 +142,8 @@ initialize(
   true,    // verboseLogging - Enable for debugging (disable in production)
   true,    // insertLinksEnabled - Enable Insert Links (Insert Affiliate's built-in deep linking)
   true,    // insertLinksClipboardEnabled - Enable clipboard attribution (triggers permission prompt)
-  604800   // affiliateAttributionActiveTime - 7 days attribution timeout in seconds
+  604800,  // affiliateAttributionActiveTime - 7 days attribution timeout in seconds
+  true     // preventAffiliateTransfer - Protect original affiliate from being replaced
 );
 ```
 
@@ -150,6 +154,9 @@ initialize(
   - Improves attribution accuracy when deep linking fails
   - iOS will show a permission prompt: "[Your App] would like to paste from [App Name]"
 - `affiliateAttributionActiveTime`: How long affiliate attribution lasts in seconds (omit for no timeout)
+- `preventAffiliateTransfer`: When `true`, prevents a new affiliate link from overwriting an existing affiliate attribution (defaults to `false`)
+  - Use this to ensure the first affiliate who acquired the user always gets credit
+  - New affiliate links will be silently ignored if the user already has an affiliate
 
 </details>
 
@@ -176,11 +183,18 @@ Complete the [RevenueCat SDK installation](https://www.revenuecat.com/docs/getti
 
 ```javascript
 import React, { useEffect } from 'react';
+import { AppState } from 'react-native';
 import Purchases from 'react-native-purchases';
 import { useDeepLinkIapProvider } from 'insert-affiliate-react-native-sdk';
 
 const App = () => {
-  const { initialize, isInitialized, setInsertAffiliateIdentifierChangeCallback } = useDeepLinkIapProvider();
+  const {
+    initialize,
+    isInitialized,
+    setInsertAffiliateIdentifierChangeCallback,
+    isAffiliateAttributionValid,
+    getAffiliateExpiryTimestamp
+  } = useDeepLinkIapProvider();
 
   useEffect(() => {
     if (!isInitialized) {
@@ -188,21 +202,72 @@ const App = () => {
     }
   }, [initialize, isInitialized]);
 
-  // Set RevenueCat attribute when affiliate identifier changes
+  // Set RevenueCat attributes when affiliate identifier changes
+  // Note: Use preventAffiliateTransfer in initialize() to block affiliate changes in the SDK
   useEffect(() => {
-    setInsertAffiliateIdentifierChangeCallback(async (identifier) => {
+    setInsertAffiliateIdentifierChangeCallback(async (identifier, offerCode) => {
       if (identifier) {
-        await Purchases.setAttributes({ "insert_affiliate": identifier });
+        // OPTIONAL: Prevent attribution for existing subscribers
+        // Uncomment to ensure affiliates only earn from users they actually brought:
+        // const customerInfo = await Purchases.getCustomerInfo();
+        // const hasActiveEntitlement = Object.keys(customerInfo.entitlements.active).length > 0;
+        // if (hasActiveEntitlement) return; // User already subscribed, don't attribute
+
+        // Sync affiliate to RevenueCat
+        await Purchases.setAttributes({
+          "insert_affiliate": identifier,
+          "affiliateOfferCode": offerCode || "",  // For RevenueCat Targeting
+          "insert_timedout": ""  // Clear timeout flag on new attribution
+        });
+        await Purchases.syncAttributesAndOfferingsIfNeeded();
       }
     });
 
     return () => setInsertAffiliateIdentifierChangeCallback(null);
   }, [setInsertAffiliateIdentifierChangeCallback]);
 
+  // Handle expired attribution - clear offer code and set timeout timestamp
+  // NOTE: insert_affiliate is preserved for renewal webhook attribution
+  // insert_timedout stores the TIMESTAMP when attribution expired (storedDate + timeout)
+  // Webhook compares this against purchase dates to determine if purchases should be attributed:
+  // - Purchases made BEFORE timeout → attributed (initial + all renewals)
+  // - Purchases made AFTER timeout → not attributed (initial + all renewals)
+  useEffect(() => {
+    if (!isInitialized) return;
+
+    const clearExpiredAffiliation = async () => {
+      const isValid = await isAffiliateAttributionValid();
+      if (!isValid) {
+        const expiryTimestamp = await getAffiliateExpiryTimestamp();
+        if (!expiryTimestamp) return; // No timeout configured
+
+        await Purchases.setAttributes({
+          "affiliateOfferCode": "",
+          "insert_timedout": expiryTimestamp.toString()
+        });
+        await Purchases.syncAttributesAndOfferingsIfNeeded();
+      }
+    };
+
+    // Check on app initialization
+    clearExpiredAffiliation();
+
+    // Check when app returns to foreground
+    const subscription = AppState.addEventListener('change', (state) => {
+      if (state === 'active') {
+        clearExpiredAffiliation();
+      }
+    });
+
+    return () => subscription?.remove();
+  }, [isInitialized, isAffiliateAttributionValid, getAffiliateExpiryTimestamp]);
+
   return <YourAppContent />;
 };
 ```
 
+> **RevenueCat Targeting:** Use the `affiliateOfferCode` attribute in your [RevenueCat Targeting rules](https://www.revenuecat.com/docs/tools/targeting) to show different offerings to affiliates (e.g., extended free trials). Set a rule like `affiliateOfferCode is any of ["oneWeekFree", "twoWeeksFree"]` to target users with specific offer codes.
+
 **Step 2: Webhook Setup**
 
 1. In RevenueCat, [create a new webhook](https://www.revenuecat.com/docs/integrations/webhooks)
@@ -226,9 +291,12 @@ const App = () => {
 
 ```bash
 npm install react-native-adapty
-cd ios && pod install && cd ..
 ```
 
+For **bare React Native**: Run `cd ios && pod install && cd ..`
+
+For **Expo managed workflow**: Pods install automatically with `npx expo prebuild` or `npx expo run:ios`.
+
 Complete the [Adapty SDK installation](https://adapty.io/docs/sdk-installation-reactnative) for any additional platform-specific setup.
 
 **Step 2: Code Setup**
@@ -509,9 +577,13 @@ const App = () => {
   const { setInsertAffiliateIdentifierChangeCallback } = useDeepLinkIapProvider();
 
   useEffect(() => {
-    setInsertAffiliateIdentifierChangeCallback(async (identifier) => {
+    setInsertAffiliateIdentifierChangeCallback(async (identifier, offerCode) => {
       if (identifier) {
-        await Purchases.setAttributes({ "insert_affiliate": identifier });
+        await Purchases.setAttributes({
+          "insert_affiliate": identifier,
+          "affiliateOfferCode": offerCode || ""  // For RevenueCat Targeting
+        });
+        await Purchases.syncAttributesAndOfferingsIfNeeded();
       }
     });
 
@@ -522,6 +594,8 @@ const App = () => {
 };
 ```
 
+> **Note:** For full RevenueCat integration with attribution timeout cleanup, see the [complete example in Option 1](#option-1-revenuecat-recommended) above.
+
 **With Adapty:**
 
 ```javascript
@@ -671,6 +745,33 @@ Update your `ios/YourApp/AppDelegate.mm`:
 }
 ```
 
+**Step 4: Expo Router Setup (If Using Expo Router)**
+
+If you're using Expo Router, deep links will cause a "This screen does not exist" error because both the Insert Affiliate SDK and Expo Router try to handle the incoming URL. The SDK correctly processes the affiliate attribution, but Expo Router simultaneously attempts to navigate to the URL path (e.g., `/insert-affiliate`), which doesn't exist as a route.
+
+To fix this, create `app/+native-intent.tsx` to intercept Insert Affiliate URLs before Expo Router processes them:
+
+```tsx
+// app/+native-intent.tsx
+// Tell Expo Router to skip navigation for Insert Affiliate URLs
+// The SDK handles these via native Linking - we just prevent router errors
+
+export function redirectSystemPath({ path }: { path: string }): string | null {
+  // Skip navigation for Insert Affiliate deep links
+  if (path.includes('insert-affiliate') || path.includes('insertAffiliate')) {
+    return null; // SDK handles it via Linking API
+  }
+  return path; // Let Expo Router handle all other URLs normally
+}
+```
+
+This ensures:
+- The Insert Affiliate SDK still receives and processes the URL via the native Linking API
+- Expo Router ignores the URL and doesn't attempt navigation
+- No "screen not found" errors
+
+See the [Expo Router +native-intent docs](https://docs.expo.dev/router/reference/native-intent/) for more details.
+
 **Testing Deep Links:**
 
 ```bash
@@ -928,6 +1029,10 @@ const rawIdentifier = await returnInsertAffiliateIdentifier(true);
   - iOS: Add URL scheme to Info.plist and configure associated domains
   - Android: Add intent filters to AndroidManifest.xml
 
+**Problem:** "This screen does not exist" error with Expo Router
+- **Cause:** Both Insert Affiliate SDK and Expo Router are trying to handle the same URL
+- **Solution:** Create `app/+native-intent.tsx` to intercept Insert Affiliate URLs before Expo Router processes them. See [Expo Router Setup](#option-1-insert-links-simplest) in the Insert Links section.
+
 **Problem:** "No affiliate identifier found"
 - **Cause:** User hasn't clicked an affiliate link yet
 - **Solution:** Test with simulator/emulator:

package/src/DeepLinkIapProvider.tsx

@@ -15,7 +15,7 @@ type T_DEEPLINK_IAP_PROVIDER = {
   children: React.ReactNode;
 };
 
-export type InsertAffiliateIdentifierChangeCallback = (identifier: string | null) => void;
+export type InsertAffiliateIdentifierChangeCallback = (identifier: string | null, offerCode: string | null) => void;
 
 export type AffiliateDetails = {
   affiliateName: string;
@@ -34,6 +34,7 @@ type T_DEEPLINK_IAP_CONTEXT = {
   returnInsertAffiliateIdentifier: (ignoreTimeout?: boolean) => Promise<string | null>;
   isAffiliateAttributionValid: () => Promise<boolean>;
   getAffiliateStoredDate: () => Promise<Date | null>;
+  getAffiliateExpiryTimestamp: () => Promise<number | null>;
   validatePurchaseWithIapticAPI: (
     jsonIapPurchase: CustomPurchase,
     iapticAppId: string,
@@ -52,7 +53,7 @@ type T_DEEPLINK_IAP_CONTEXT = {
   ) => Promise<void | string>;
   setInsertAffiliateIdentifierChangeCallback: (callback: InsertAffiliateIdentifierChangeCallback | null) => void;
   handleInsertLinks: (url: string) => Promise<boolean>;
-  initialize: (code: string | null, verboseLogging?: boolean, insertLinksEnabled?: boolean, insertLinksClipboardEnabled?: boolean, affiliateAttributionActiveTime?: number) => Promise<void>;
+  initialize: (code: string | null, verboseLogging?: boolean, insertLinksEnabled?: boolean, insertLinksClipboardEnabled?: boolean, affiliateAttributionActiveTime?: number, preventAffiliateTransfer?: boolean) => Promise<void>;
   isInitialized: boolean;
 };
 
@@ -78,7 +79,7 @@ const ASYNC_KEYS = {
   USER_ID: '@app_user_id',
   COMPANY_CODE: '@app_company_code',
   USER_ACCOUNT_TOKEN: '@app_user_account_token',
-  IOS_OFFER_CODE: '@app_ios_offer_code',
+  OFFER_CODE: '@app_offer_code',
   AFFILIATE_STORED_DATE: '@app_affiliate_stored_date',
   SDK_INIT_REPORTED: '@app_sdk_init_reported',
   REPORTED_AFFILIATE_ASSOCIATIONS: '@app_reported_affiliate_associations',
@@ -101,6 +102,7 @@ export const DeepLinkIapContext = createContext<T_DEEPLINK_IAP_CONTEXT>({
   returnInsertAffiliateIdentifier: async (ignoreTimeout?: boolean) => '',
   isAffiliateAttributionValid: async () => false,
   getAffiliateStoredDate: async () => null,
+  getAffiliateExpiryTimestamp: async () => null,
   validatePurchaseWithIapticAPI: async (
     jsonIapPurchase: CustomPurchase,
     iapticAppId: string,
@@ -115,7 +117,7 @@ export const DeepLinkIapContext = createContext<T_DEEPLINK_IAP_CONTEXT>({
   setInsertAffiliateIdentifier: async (referringLink: string) => {},
   setInsertAffiliateIdentifierChangeCallback: (callback: InsertAffiliateIdentifierChangeCallback | null) => {},
   handleInsertLinks: async (url: string) => false,
-  initialize: async (code: string | null, verboseLogging?: boolean, insertLinksEnabled?: boolean, insertLinksClipboardEnabled?: boolean, affiliateAttributionActiveTime?: number) => {},
+  initialize: async (code: string | null, verboseLogging?: boolean, insertLinksEnabled?: boolean, insertLinksClipboardEnabled?: boolean, affiliateAttributionActiveTime?: number, preventAffiliateTransfer?: boolean) => {},
   isInitialized: false,
 });
 
@@ -131,20 +133,23 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
   const [insertLinksClipboardEnabled, setInsertLinksClipboardEnabled] = useState<boolean>(false);
   const [OfferCode, setOfferCode] = useState<string | null>(null);
   const [affiliateAttributionActiveTime, setAffiliateAttributionActiveTime] = useState<number | null>(null);
+  const [preventAffiliateTransfer, setPreventAffiliateTransfer] = useState<boolean>(false);
   const insertAffiliateIdentifierChangeCallbackRef = useRef<InsertAffiliateIdentifierChangeCallback | null>(null);
   const isInitializingRef = useRef<boolean>(false);
 
   // Refs for values that need to be current inside callbacks (to avoid stale closures)
   const companyCodeRef = useRef<string | null>(null);
   const verboseLoggingRef = useRef<boolean>(false);
+  const preventAffiliateTransferRef = useRef<boolean>(false);
 
   // Refs for implementation functions (ref callback pattern for stable + fresh)
-  const initializeImplRef = useRef<(code: string | null, verboseLogging?: boolean, insertLinksEnabled?: boolean, insertLinksClipboardEnabled?: boolean, affiliateAttributionActiveTime?: number) => Promise<void>>(null as any);
+  const initializeImplRef = useRef<(code: string | null, verboseLogging?: boolean, insertLinksEnabled?: boolean, insertLinksClipboardEnabled?: boolean, affiliateAttributionActiveTime?: number, preventAffiliateTransfer?: boolean) => Promise<void>>(null as any);
   const setShortCodeImplRef = useRef<(shortCode: string) => Promise<boolean>>(null as any);
   const getAffiliateDetailsImplRef = useRef<(affiliateCode: string) => Promise<AffiliateDetails>>(null as any);
   const returnInsertAffiliateIdentifierImplRef = useRef<(ignoreTimeout?: boolean) => Promise<string | null>>(null as any);
   const isAffiliateAttributionValidImplRef = useRef<() => Promise<boolean>>(null as any);
   const getAffiliateStoredDateImplRef = useRef<() => Promise<Date | null>>(null as any);
+  const getAffiliateExpiryTimestampImplRef = useRef<() => Promise<number | null>>(null as any);
   const storeExpectedStoreTransactionImplRef = useRef<(purchaseToken: string) => Promise<void>>(null as any);
   const returnUserAccountTokenAndStoreExpectedTransactionImplRef = useRef<() => Promise<string | null>>(null as any);
   const validatePurchaseWithIapticAPIImplRef = useRef<(jsonIapPurchase: CustomPurchase, iapticAppId: string, iapticAppName: string, iapticPublicKey: string) => Promise<boolean>>(null as any);
@@ -153,7 +158,7 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
   const handleInsertLinksImplRef = useRef<(url: string) => Promise<boolean>>(null as any);
 
   // MARK: Initialize the SDK
-  const initializeImpl = async (companyCodeParam: string | null, verboseLoggingParam: boolean = false, insertLinksEnabledParam: boolean = false, insertLinksClipboardEnabledParam: boolean = false, affiliateAttributionActiveTimeParam?: number): Promise<void> => {
+  const initializeImpl = async (companyCodeParam: string | null, verboseLoggingParam: boolean = false, insertLinksEnabledParam: boolean = false, insertLinksClipboardEnabledParam: boolean = false, affiliateAttributionActiveTimeParam?: number, preventAffiliateTransferParam: boolean = false): Promise<void> => {
     // Prevent multiple concurrent initialization attempts
     if (isInitialized || isInitializingRef.current) {
       return;
@@ -167,6 +172,8 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
     if (affiliateAttributionActiveTimeParam !== undefined) {
       setAffiliateAttributionActiveTime(affiliateAttributionActiveTimeParam);
     }
+    setPreventAffiliateTransfer(preventAffiliateTransferParam);
+    preventAffiliateTransferRef.current = preventAffiliateTransferParam;
 
     if (verboseLoggingParam) {
       console.log('[Insert Affiliate] [VERBOSE] Starting SDK initialization...');
@@ -218,12 +225,23 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
         const uId = await getValueFromAsync(ASYNC_KEYS.USER_ID);
         const refLink = await getValueFromAsync(ASYNC_KEYS.REFERRER_LINK);
         const companyCodeFromStorage = await getValueFromAsync(ASYNC_KEYS.COMPANY_CODE);
-        const storedOfferCode = await getValueFromAsync(ASYNC_KEYS.IOS_OFFER_CODE);
+
+        // Migration: check new key first, fall back to legacy iOS key
+        let storedOfferCode = await getValueFromAsync(ASYNC_KEYS.OFFER_CODE);
+        if (!storedOfferCode) {
+          const legacyOfferCode = await getValueFromAsync('@app_ios_offer_code');
+          if (legacyOfferCode) {
+            storedOfferCode = legacyOfferCode;
+            // Migrate to new key
+            await saveValueInAsync(ASYNC_KEYS.OFFER_CODE, legacyOfferCode);
+            verboseLog('Migrated offer code from legacy iOS key to new key');
+          }
+        }
 
         verboseLog(`User ID found: ${uId ? 'Yes' : 'No'}`);
         verboseLog(`Referrer link found: ${refLink ? 'Yes' : 'No'}`);
         verboseLog(`Company code found: ${companyCodeFromStorage ? 'Yes' : 'No'}`);
-        verboseLog(`iOS Offer Code found: ${storedOfferCode ? 'Yes' : 'No'}`);
+        verboseLog(`Offer Code found: ${storedOfferCode ? 'Yes' : 'No'}`);
 
         if (uId && refLink) {
           setUserId(uId);
@@ -239,7 +257,7 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
 
         if (storedOfferCode) {
           setOfferCode(storedOfferCode);
-          verboseLog('iOS Offer Code restored from storage');
+          verboseLog('Offer Code restored from storage');
         }
       } catch (error) {
         errorLog(`ERROR ~ fetchAsyncEssentials: ${error}`);
@@ -1605,6 +1623,31 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
     }
   };
 
+  // Get the timestamp when attribution expires (stored date + timeout duration in ms)
+  // Returns null if no timeout is configured or no stored date exists
+  const getAffiliateExpiryTimestampImpl = async (): Promise<number | null> => {
+    try {
+      if (!affiliateAttributionActiveTime) {
+        verboseLog('No attribution timeout configured, no expiry timestamp');
+        return null;
+      }
+
+      const storedDate = await getAffiliateStoredDateImpl();
+      if (!storedDate) {
+        verboseLog('No stored date found, cannot calculate expiry timestamp');
+        return null;
+      }
+
+      // Convert timeout from seconds to milliseconds and add to stored date
+      const expiryTimestamp = storedDate.getTime() + (affiliateAttributionActiveTime * 1000);
+      verboseLog(`Attribution expiry timestamp: ${expiryTimestamp} (${new Date(expiryTimestamp).toISOString()})`);
+      return expiryTimestamp;
+    } catch (error) {
+      verboseLog(`Error getting affiliate expiry timestamp: ${error}`);
+      return null;
+    }
+  };
+
   // MARK: Insert Affiliate Identifier
 
   const setInsertAffiliateIdentifierImpl = async (
@@ -1701,7 +1744,7 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
   };
 
   async function storeInsertAffiliateIdentifier({ link, source }: { link: string; source: AffiliateAssociationSource }) {
-    console.log(`[Insert Affiliate] Storing affiliate identifier: ${link} (source: ${source})`);
+    verboseLog(`Storing affiliate identifier: ${link} (source: ${source})`);
 
     // Check if we're trying to store the same link (prevent duplicate storage)
     const existingLink = await getValueFromAsync(ASYNC_KEYS.REFERRER_LINK);
@@ -1710,6 +1753,13 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
       return;
     }
 
+    // Prevent transfer of affiliate if enabled - keep original affiliate
+    verboseLog(`preventAffiliateTransfer check: enabled=${preventAffiliateTransferRef.current}, existingLink=${existingLink}, newLink=${link}`);
+    if (preventAffiliateTransferRef.current && existingLink && existingLink !== link) {
+      verboseLog(`Transfer blocked: existing affiliate "${existingLink}" protected from being replaced by "${link}"`);
+      return;
+    }
+
     verboseLog(`Updating React state with referrer link: ${link}`);
     setReferrerLink(link);
     verboseLog(`Saving referrer link to AsyncStorage...`);
@@ -1724,13 +1774,13 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
 
     // Automatically fetch and store offer code for any affiliate identifier
     verboseLog('Attempting to fetch offer code for stored affiliate identifier...');
-    await retrieveAndStoreOfferCode(link);
+    const offerCode = await retrieveAndStoreOfferCode(link);
 
-    // Trigger callback with the current affiliate identifier
+    // Trigger callback with the current affiliate identifier and offer code
     if (insertAffiliateIdentifierChangeCallbackRef.current) {
       const currentIdentifier = await returnInsertAffiliateIdentifierImpl();
-      verboseLog(`Triggering callback with identifier: ${currentIdentifier}`);
-      insertAffiliateIdentifierChangeCallbackRef.current(currentIdentifier);
+      verboseLog(`Triggering callback with identifier: ${currentIdentifier}, offerCode: ${offerCode}`);
+      insertAffiliateIdentifierChangeCallbackRef.current(currentIdentifier, offerCode);
     }
 
     // Report this new affiliate association to the backend (fire and forget)
@@ -2016,27 +2066,30 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
     }
   };
 
-  const retrieveAndStoreOfferCode = async (affiliateLink: string): Promise<void> => {
+  const retrieveAndStoreOfferCode = async (affiliateLink: string): Promise<string | null> => {
     try {
       verboseLog(`Attempting to retrieve and store offer code for: ${affiliateLink}`);
-      
+
       const offerCode = await fetchOfferCode(affiliateLink);
-      
+
       if (offerCode && offerCode.length > 0) {
         // Store in both AsyncStorage and state
-        await saveValueInAsync(ASYNC_KEYS.IOS_OFFER_CODE, offerCode);
+        await saveValueInAsync(ASYNC_KEYS.OFFER_CODE, offerCode);
         setOfferCode(offerCode);
         verboseLog(`Successfully stored offer code: ${offerCode}`);
         console.log('[Insert Affiliate] Offer code retrieved and stored successfully');
+        return offerCode;
       } else {
         verboseLog('No valid offer code found to store');
         // Clear stored offer code if none found
-        await saveValueInAsync(ASYNC_KEYS.IOS_OFFER_CODE, '');
+        await saveValueInAsync(ASYNC_KEYS.OFFER_CODE, '');
         setOfferCode(null);
+        return null;
       }
     } catch (error) {
       console.error('[Insert Affiliate] Error retrieving and storing offer code:', error);
       verboseLog(`Error in retrieveAndStoreOfferCode: ${error}`);
+      return null;
     }
   };
 
@@ -2059,6 +2112,7 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
   returnInsertAffiliateIdentifierImplRef.current = returnInsertAffiliateIdentifierImpl;
   isAffiliateAttributionValidImplRef.current = isAffiliateAttributionValidImpl;
   getAffiliateStoredDateImplRef.current = getAffiliateStoredDateImpl;
+  getAffiliateExpiryTimestampImplRef.current = getAffiliateExpiryTimestampImpl;
   storeExpectedStoreTransactionImplRef.current = storeExpectedStoreTransactionImpl;
   returnUserAccountTokenAndStoreExpectedTransactionImplRef.current = returnUserAccountTokenAndStoreExpectedTransactionImpl;
   validatePurchaseWithIapticAPIImplRef.current = validatePurchaseWithIapticAPIImpl;
@@ -2075,9 +2129,10 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
     verboseLogging?: boolean,
     insertLinksEnabled?: boolean,
     insertLinksClipboardEnabled?: boolean,
-    affiliateAttributionActiveTime?: number
+    affiliateAttributionActiveTime?: number,
+    preventAffiliateTransfer?: boolean
   ): Promise<void> => {
-    return initializeImplRef.current(code, verboseLogging, insertLinksEnabled, insertLinksClipboardEnabled, affiliateAttributionActiveTime);
+    return initializeImplRef.current(code, verboseLogging, insertLinksEnabled, insertLinksClipboardEnabled, affiliateAttributionActiveTime, preventAffiliateTransfer);
   }, []);
 
   const setShortCode = useCallback(async (shortCode: string): Promise<boolean> => {
@@ -2100,6 +2155,10 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
     return getAffiliateStoredDateImplRef.current();
   }, []);
 
+  const getAffiliateExpiryTimestamp = useCallback(async (): Promise<number | null> => {
+    return getAffiliateExpiryTimestampImplRef.current();
+  }, []);
+
   const storeExpectedStoreTransaction = useCallback(async (purchaseToken: string): Promise<void> => {
     return storeExpectedStoreTransactionImplRef.current(purchaseToken);
   }, []);
@@ -2127,6 +2186,22 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
 
   const setInsertAffiliateIdentifierChangeCallbackHandler = useCallback((callback: InsertAffiliateIdentifierChangeCallback | null): void => {
     insertAffiliateIdentifierChangeCallbackRef.current = callback;
+
+    // If callback is being set, immediately call it with the current identifier and offer code values
+    // This ensures callbacks registered after initialization still receive the current state (including null if expired/not set)
+    if (callback) {
+      Promise.all([
+        returnInsertAffiliateIdentifierImpl(),
+        getValueFromAsync(ASYNC_KEYS.OFFER_CODE)
+      ]).then(([identifier, storedOfferCode]) => {
+        // Verify callback is still the same (wasn't replaced during async operation)
+        if (insertAffiliateIdentifierChangeCallbackRef.current === callback) {
+          const offerCode = storedOfferCode && storedOfferCode.length > 0 ? storedOfferCode : null;
+          verboseLog(`Calling callback immediately with current identifier: ${identifier}, offerCode: ${offerCode}`);
+          callback(identifier, offerCode);
+        }
+      });
+    }
   }, []);
 
   const handleInsertLinks = useCallback(async (url: string): Promise<boolean> => {
@@ -2144,6 +2219,7 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
         returnInsertAffiliateIdentifier,
         isAffiliateAttributionValid,
         getAffiliateStoredDate,
+        getAffiliateExpiryTimestamp,
         storeExpectedStoreTransaction,
         returnUserAccountTokenAndStoreExpectedTransaction,
         validatePurchaseWithIapticAPI,

package/src/useDeepLinkIapProvider.tsx

@@ -11,6 +11,7 @@ const useDeepLinkIapProvider = () => {
     returnInsertAffiliateIdentifier,
     isAffiliateAttributionValid,
     getAffiliateStoredDate,
+    getAffiliateExpiryTimestamp,
     trackEvent,
     setShortCode,
     getAffiliateDetails,
@@ -31,6 +32,7 @@ const useDeepLinkIapProvider = () => {
     returnInsertAffiliateIdentifier,
     isAffiliateAttributionValid,
     getAffiliateStoredDate,
+    getAffiliateExpiryTimestamp,
     trackEvent,
     setShortCode,
     getAffiliateDetails,