insert-affiliate-react-native-sdk 1.10.0 → 1.11.2

package/src/DeepLinkIapProvider.tsx

@@ -1,4 +1,4 @@
-import React, { createContext, useEffect, useState, useRef } from 'react';
+import React, { createContext, useEffect, useState, useRef, useCallback } from 'react';
 import { Platform, Linking, Dimensions, PixelRatio } from 'react-native';
 import axios from 'axios';
 import AsyncStorage from '@react-native-async-storage/async-storage';
@@ -132,52 +132,74 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
   const [OfferCode, setOfferCode] = useState<string | null>(null);
   const [affiliateAttributionActiveTime, setAffiliateAttributionActiveTime] = useState<number | null>(null);
   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);
+
+  // 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 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 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);
+  const trackEventImplRef = useRef<(eventName: string) => Promise<void>>(null as any);
+  const setInsertAffiliateIdentifierImplRef = useRef<(referringLink: string) => Promise<void | string>>(null as any);
+  const handleInsertLinksImplRef = useRef<(url: string) => Promise<boolean>>(null as any);
 
   // MARK: Initialize the SDK
-  const initialize = async (companyCode: string | null, verboseLogging: boolean = false, insertLinksEnabled: boolean = false, insertLinksClipboardEnabled: boolean = false, affiliateAttributionActiveTime?: number): Promise<void> => {
-    setVerboseLogging(verboseLogging);
-    setInsertLinksEnabled(insertLinksEnabled);
-    setInsertLinksClipboardEnabled(insertLinksClipboardEnabled);
-    if (affiliateAttributionActiveTime !== undefined) {
-      setAffiliateAttributionActiveTime(affiliateAttributionActiveTime);
+  const initializeImpl = async (companyCodeParam: string | null, verboseLoggingParam: boolean = false, insertLinksEnabledParam: boolean = false, insertLinksClipboardEnabledParam: boolean = false, affiliateAttributionActiveTimeParam?: number): Promise<void> => {
+    // Prevent multiple concurrent initialization attempts
+    if (isInitialized || isInitializingRef.current) {
+      return;
     }
-    
-    if (verboseLogging) {
-      console.log('[Insert Affiliate] [VERBOSE] Starting SDK initialization...');
-      console.log('[Insert Affiliate] [VERBOSE] Company code provided:', companyCode ? 'Yes' : 'No');
-      console.log('[Insert Affiliate] [VERBOSE] Verbose logging enabled');
+    isInitializingRef.current = true;
+
+    setVerboseLogging(verboseLoggingParam);
+    verboseLoggingRef.current = verboseLoggingParam;
+    setInsertLinksEnabled(insertLinksEnabledParam);
+    setInsertLinksClipboardEnabled(insertLinksClipboardEnabledParam);
+    if (affiliateAttributionActiveTimeParam !== undefined) {
+      setAffiliateAttributionActiveTime(affiliateAttributionActiveTimeParam);
     }
 
-    if (isInitialized) {
-      console.error('[Insert Affiliate] SDK is already initialized.');
-      return;
+    if (verboseLoggingParam) {
+      console.log('[Insert Affiliate] [VERBOSE] Starting SDK initialization...');
+      console.log('[Insert Affiliate] [VERBOSE] Company code provided:', companyCodeParam ? 'Yes' : 'No');
+      console.log('[Insert Affiliate] [VERBOSE] Verbose logging enabled');
     }
 
-    if (companyCode && companyCode.trim() !== '') {
-      setCompanyCode(companyCode);
-      await saveValueInAsync(ASYNC_KEYS.COMPANY_CODE, companyCode);
+    if (companyCodeParam && companyCodeParam.trim() !== '') {
+      setCompanyCode(companyCodeParam);
+      companyCodeRef.current = companyCodeParam;
+      await saveValueInAsync(ASYNC_KEYS.COMPANY_CODE, companyCodeParam);
       setIsInitialized(true);
       console.log(
-        `[Insert Affiliate] SDK initialized with company code: ${companyCode}`
+        `[Insert Affiliate] SDK initialized with company code: ${companyCodeParam}`
       );
-      if (verboseLogging) {
+      if (verboseLoggingParam) {
         console.log('[Insert Affiliate] [VERBOSE] Company code saved to AsyncStorage');
         console.log('[Insert Affiliate] [VERBOSE] SDK marked as initialized');
       }
 
       // Report SDK initialization for onboarding verification (fire and forget)
-      reportSdkInitIfNeeded(companyCode, verboseLogging);
+      reportSdkInitIfNeeded(companyCodeParam, verboseLoggingParam);
     } else {
       console.warn(
         '[Insert Affiliate] SDK initialized without a company code.'
       );
       setIsInitialized(true);
-      if (verboseLogging) {
+      if (verboseLoggingParam) {
         console.log('[Insert Affiliate] [VERBOSE] No company code provided, SDK initialized in limited mode');
       }
     }
 
-    if (insertLinksEnabled && Platform.OS === 'ios') {
+    if (insertLinksEnabledParam && Platform.OS === 'ios') {
       try {
         const enhancedSystemInfo = await getEnhancedSystemInfo();
         await sendSystemInfoToBackend(enhancedSystemInfo);
@@ -211,6 +233,7 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
 
         if (companyCodeFromStorage) {
           setCompanyCode(companyCodeFromStorage);
+          companyCodeRef.current = companyCodeFromStorage;
           verboseLog('Company code restored from storage');
         }
 
@@ -351,13 +374,6 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
     console.log('[Insert Affiliate] SDK has been reset.');
   };
 
-  // MARK: Callback Management
-  // Sets a callback that will be triggered whenever storeInsertAffiliateIdentifier is called
-  // The callback receives the current affiliate identifier (returnInsertAffiliateIdentifier result)
-  const setInsertAffiliateIdentifierChangeCallbackHandler = (callback: InsertAffiliateIdentifierChangeCallback | null): void => {
-    insertAffiliateIdentifierChangeCallbackRef.current = callback;
-  };
-
   // MARK: Deep Link Handling
   // Helper function to parse URLs in React Native compatible way
   const parseURL = (url: string) => {
@@ -566,10 +582,10 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
   };
 
   // Handles Insert Links deep linking - equivalent to iOS handleInsertLinks
-  const handleInsertLinks = async (url: string): Promise<boolean> => {
+  const handleInsertLinksImpl = async (url: string): Promise<boolean> => {
     try {
       console.log(`[Insert Affiliate] Attempting to handle URL: ${url}`);
-      
+
       if (!url || typeof url !== 'string') {
         console.log('[Insert Affiliate] Invalid URL provided to handleInsertLinks');
         return false;
@@ -690,14 +706,48 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
     }
   };
 
+  // Parse shortcode from query parameter (new format: scheme://insert-affiliate?code=SHORTCODE)
+  const parseShortCodeFromQuery = (url: string): string | null => {
+    try {
+      const queryIndex = url.indexOf('?');
+      if (queryIndex !== -1) {
+        const queryString = url.substring(queryIndex + 1);
+        const params = queryString.split('&');
+        for (const param of params) {
+          const [key, value] = param.split('=');
+          if (key === 'code' && value) {
+            return decodeURIComponent(value);
+          }
+        }
+      }
+      return null;
+    } catch (error) {
+      verboseLog(`Error parsing short code from query: ${error}`);
+      return null;
+    }
+  };
+
   const parseShortCodeFromURLString = (url: string): string | null => {
     try {
-      // For custom schemes like ia-companycode://shortcode, everything after :// is the short code
+      // First try to extract from query parameter (new format: scheme://insert-affiliate?code=SHORTCODE)
+      const queryCode = parseShortCodeFromQuery(url);
+      if (queryCode) {
+        console.log(`[Insert Affiliate] Found short code in query parameter: ${queryCode}`);
+        return queryCode;
+      }
+
+      // Fall back to path format (legacy: scheme://SHORTCODE)
       const match = url.match(/^[^:]+:\/\/(.+)$/);
       if (match) {
-        const shortCode = match[1];
+        let shortCode = match[1];
         // Remove leading slash if present
-        return shortCode.startsWith('/') ? shortCode.substring(1) : shortCode;
+        shortCode = shortCode.startsWith('/') ? shortCode.substring(1) : shortCode;
+        // If the path is 'insert-affiliate' (from new format without code param), return null
+        if (shortCode === 'insert-affiliate' || shortCode.startsWith('insert-affiliate?')) {
+          return null;
+        }
+        console.log(`[Insert Affiliate] Found short code in URL path (legacy format): ${shortCode}`);
+        return shortCode;
       }
       return null;
     } catch (error) {
@@ -720,29 +770,30 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
     await AsyncStorage.clear();
   };
 
-  // Helper function to get company code from state or storage
+  // Helper function to get company code from ref or storage (uses ref to avoid stale closures)
   const getActiveCompanyCode = async (): Promise<string | null> => {
     verboseLog('Getting active company code...');
-    let activeCompanyCode = companyCode;
-    verboseLog(`Company code in React state: ${activeCompanyCode || 'empty'}`);
-    
+    let activeCompanyCode = companyCodeRef.current;
+    verboseLog(`Company code in ref: ${activeCompanyCode || 'empty'}`);
+
     if (!activeCompanyCode || (activeCompanyCode.trim() === '' && activeCompanyCode !== null)) {
-      verboseLog('Company code not in state, checking AsyncStorage...');
+      verboseLog('Company code not in ref, checking AsyncStorage...');
       activeCompanyCode = await getValueFromAsync(ASYNC_KEYS.COMPANY_CODE);
       verboseLog(`Company code in AsyncStorage: ${activeCompanyCode || 'empty'}`);
-      
+
       if (activeCompanyCode) {
-        // Update state for future use
+        // Update ref and state for future use
+        companyCodeRef.current = activeCompanyCode;
         setCompanyCode(activeCompanyCode);
-        verboseLog('Updated React state with company code from storage');
+        verboseLog('Updated ref and React state with company code from storage');
       }
     }
     return activeCompanyCode;
   };
 
-  // Helper function for verbose logging
+  // Helper function for verbose logging (uses ref to avoid stale closures)
   const verboseLog = (message: string) => {
-    if (verboseLogging) {
+    if (verboseLoggingRef.current) {
       console.log(`[Insert Affiliate] [VERBOSE] ${message}`);
     }
   };
@@ -1340,7 +1391,7 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
     }
   };
 
-  const getAffiliateDetails = async (affiliateCode: string): Promise<AffiliateDetails> => {
+  const getAffiliateDetailsImpl = async (affiliateCode: string): Promise<AffiliateDetails> => {
     try {
       const activeCompanyCode = await getActiveCompanyCode();
       if (!activeCompanyCode) {
@@ -1385,7 +1436,7 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
     }
   };
 
-  async function setShortCode(shortCode: string): Promise<boolean> {
+  const setShortCodeImpl = async (shortCode: string): Promise<boolean> => {
     console.log('[Insert Affiliate] Setting short code.');
     await generateThenSetUserID();
 
@@ -1405,7 +1456,7 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
       console.warn(`[Insert Affiliate] Short code ${capitalisedShortCode} does not exist. Not storing.`);
       return false;
     }
-  }
+  };
 
   async function getOrCreateUserAccountToken(): Promise<string> {
     let userAccountToken = await getValueFromAsync(ASYNC_KEYS.USER_ACCOUNT_TOKEN);
@@ -1418,9 +1469,9 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
     return userAccountToken;
   };
 
-  const returnUserAccountTokenAndStoreExpectedTransaction = async (): Promise<string | null> => {
+  const returnUserAccountTokenAndStoreExpectedTransactionImpl = async (): Promise<string | null> => {
     try {
-      const shortCode = await returnInsertAffiliateIdentifier();
+      const shortCode = await returnInsertAffiliateIdentifierImpl();
       if (!shortCode) {
         console.log('[Insert Affiliate] No affiliate stored - not saving expected transaction.');
         return null;
@@ -1433,14 +1484,14 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
         console.error('[Insert Affiliate] Failed to generate user account token.');
         return null;
       } else {
-        await storeExpectedStoreTransaction(userAccountToken);
+        await storeExpectedStoreTransactionImpl(userAccountToken);
         return userAccountToken;
       }
     } catch (error) {
       // Handle E_IAP_NOT_AVAILABLE error gracefully
-      if ((error as any)?.code === 'E_IAP_NOT_AVAILABLE' || 
+      if ((error as any)?.code === 'E_IAP_NOT_AVAILABLE' ||
           (error instanceof Error && error.message.includes('E_IAP_NOT_AVAILABLE'))) {
-        
+
         if (isDevelopmentEnvironment) {
           console.warn('[Insert Affiliate] IAP not available in development environment. Cannot store expected transaction.');
           verboseLog('E_IAP_NOT_AVAILABLE error in returnUserAccountTokenAndStoreExpectedTransaction - gracefully handling in development');
@@ -1454,50 +1505,50 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
   };
 
   // MARK: Return Insert Affiliate Identifier
-  const returnInsertAffiliateIdentifier = async (ignoreTimeout: boolean = false): Promise<string | null> => {
+  const returnInsertAffiliateIdentifierImpl = async (ignoreTimeout: boolean = false): Promise<string | null> => {
     try {
       verboseLog(`Getting insert affiliate identifier (ignoreTimeout: ${ignoreTimeout})...`);
-      
+
       // If timeout is enabled and we're not ignoring it, check validity first
       if (!ignoreTimeout && affiliateAttributionActiveTime) {
-        const isValid = await isAffiliateAttributionValid();
+        const isValid = await isAffiliateAttributionValidImpl();
         if (!isValid) {
           verboseLog('Attribution has expired, returning null');
           return null;
         }
       }
-      
+
       // Now get the actual identifier
       verboseLog(`React state - referrerLink: ${referrerLink || 'empty'}, userId: ${userId || 'empty'}`);
-      
+
       // Try React state first
       if (referrerLink && userId) {
         const identifier = `${referrerLink}-${userId}`;
         verboseLog(`Found identifier in React state: ${identifier}`);
         return identifier;
       }
-      
+
       verboseLog('React state empty, checking AsyncStorage...');
-      
+
       // Fallback to async storage if React state is empty
       const storedLink = await getValueFromAsync(ASYNC_KEYS.REFERRER_LINK);
       let storedUserId = await getValueFromAsync(ASYNC_KEYS.USER_ID);
-      
+
       verboseLog(`AsyncStorage - storedLink: ${storedLink || 'empty'}, storedUserId: ${storedUserId || 'empty'}`);
-      
+
       // If we have a stored link but no user ID, generate one now
       if (storedLink && !storedUserId) {
         verboseLog('Found stored link but no user ID, generating user ID now...');
         storedUserId = await generateThenSetUserID();
         verboseLog(`Generated user ID: ${storedUserId}`);
       }
-      
+
       if (storedLink && storedUserId) {
         const identifier = `${storedLink}-${storedUserId}`;
         verboseLog(`Found identifier in AsyncStorage: ${identifier}`);
         return identifier;
       }
-      
+
       verboseLog('No affiliate identifier found in state or storage');
       return null;
     } catch (error) {
@@ -1507,44 +1558,44 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
   };
 
   // MARK: Attribution Timeout Functions
-  
+
   // Check if the current affiliate attribution is still valid based on timeout
-  const isAffiliateAttributionValid = async (): Promise<boolean> => {
+  const isAffiliateAttributionValidImpl = async (): Promise<boolean> => {
     try {
       // If no timeout is set, attribution is always valid
       if (!affiliateAttributionActiveTime) {
         verboseLog('No attribution timeout set, attribution is valid');
         return true;
       }
-      
-      const storedDate = await getAffiliateStoredDate();
+
+      const storedDate = await getAffiliateStoredDateImpl();
       if (!storedDate) {
         verboseLog('No stored date found, attribution is invalid');
         return false;
       }
-      
+
       const now = new Date();
       const timeDifferenceSeconds = Math.floor((now.getTime() - storedDate.getTime()) / 1000);
       const isValid = timeDifferenceSeconds <= affiliateAttributionActiveTime;
-      
+
       verboseLog(`Attribution timeout check: stored=${storedDate.toISOString()}, now=${now.toISOString()}, diff=${timeDifferenceSeconds}s, timeout=${affiliateAttributionActiveTime}s, valid=${isValid}`);
-      
+
       return isValid;
     } catch (error) {
       verboseLog(`Error checking attribution validity: ${error}`);
       return false;
     }
   };
-  
+
   // Get the date when the affiliate identifier was stored
-  const getAffiliateStoredDate = async (): Promise<Date | null> => {
+  const getAffiliateStoredDateImpl = async (): Promise<Date | null> => {
     try {
       const storedDateString = await getValueFromAsync(ASYNC_KEYS.AFFILIATE_STORED_DATE);
       if (!storedDateString) {
         verboseLog('No affiliate stored date found');
         return null;
       }
-      
+
       const storedDate = new Date(storedDateString);
       verboseLog(`Retrieved affiliate stored date: ${storedDate.toISOString()}`);
       return storedDate;
@@ -1556,9 +1607,9 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
 
   // MARK: Insert Affiliate Identifier
 
-  async function setInsertAffiliateIdentifier(
+  const setInsertAffiliateIdentifierImpl = async (
     referringLink: string
-  ): Promise<void | string> {
+  ): Promise<void | string> => {
     console.log('[Insert Affiliate] Setting affiliate identifier.');
     verboseLog(`Input referringLink: ${referringLink}`);
 
@@ -1648,7 +1699,7 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
       verboseLog(`Error in setInsertAffiliateIdentifier: ${error}`);
     }
   };
-  
+
   async function storeInsertAffiliateIdentifier({ link, source }: { link: string; source: AffiliateAssociationSource }) {
     console.log(`[Insert Affiliate] Storing affiliate identifier: ${link} (source: ${source})`);
 
@@ -1677,19 +1728,19 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
 
     // Trigger callback with the current affiliate identifier
     if (insertAffiliateIdentifierChangeCallbackRef.current) {
-      const currentIdentifier = await returnInsertAffiliateIdentifier();
+      const currentIdentifier = await returnInsertAffiliateIdentifierImpl();
       verboseLog(`Triggering callback with identifier: ${currentIdentifier}`);
       insertAffiliateIdentifierChangeCallbackRef.current(currentIdentifier);
     }
 
     // Report this new affiliate association to the backend (fire and forget)
-    const fullIdentifier = await returnInsertAffiliateIdentifier();
+    const fullIdentifier = await returnInsertAffiliateIdentifierImpl();
     if (fullIdentifier) {
       reportAffiliateAssociationIfNeeded(fullIdentifier, source);
     }
   }
 
-  const validatePurchaseWithIapticAPI = async (
+  const validatePurchaseWithIapticAPIImpl = async (
     jsonIapPurchase: CustomPurchase,
     iapticAppId: string,
     iapticAppName: string,
@@ -1697,10 +1748,10 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
   ): Promise<boolean> => {
     try {
       // Check for E_IAP_NOT_AVAILABLE error in development environment
-      if ((jsonIapPurchase as any)?.error?.code === 'E_IAP_NOT_AVAILABLE' || 
+      if ((jsonIapPurchase as any)?.error?.code === 'E_IAP_NOT_AVAILABLE' ||
           (jsonIapPurchase as any)?.code === 'E_IAP_NOT_AVAILABLE' ||
           (typeof jsonIapPurchase === 'string' && (jsonIapPurchase as string).includes('E_IAP_NOT_AVAILABLE'))) {
-        
+
         if (isDevelopmentEnvironment) {
           console.warn('[Insert Affiliate] IAP not available in development environment. This is expected behavior.');
           verboseLog('E_IAP_NOT_AVAILABLE error detected in development - gracefully handling');
@@ -1741,7 +1792,7 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
         transaction,
       };
 
-      let insertAffiliateIdentifier = await returnInsertAffiliateIdentifier();
+      let insertAffiliateIdentifier = await returnInsertAffiliateIdentifierImpl();
 
       if (insertAffiliateIdentifier) {
         requestBody.additionalData = {
@@ -1769,9 +1820,9 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
       }
     } catch (error) {
       // Handle E_IAP_NOT_AVAILABLE error gracefully
-      if ((error as any)?.code === 'E_IAP_NOT_AVAILABLE' || 
+      if ((error as any)?.code === 'E_IAP_NOT_AVAILABLE' ||
           (error instanceof Error && error.message.includes('E_IAP_NOT_AVAILABLE'))) {
-        
+
         if (isDevelopmentEnvironment) {
           console.warn('[Insert Affiliate] IAP not available in development environment. SDK will continue without purchase validation.');
           verboseLog('E_IAP_NOT_AVAILABLE error caught in validatePurchaseWithIapticAPI - gracefully handling in development');
@@ -1795,9 +1846,9 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
     }
   };
 
-  const storeExpectedStoreTransaction = async (purchaseToken: string): Promise<void> => {
+  const storeExpectedStoreTransactionImpl = async (purchaseToken: string): Promise<void> => {
     verboseLog(`Storing expected store transaction with token: ${purchaseToken}`);
-    
+
     const activeCompanyCode = await getActiveCompanyCode();
     if (!activeCompanyCode) {
       console.error("[Insert Affiliate] Company code is not set. Please initialize the SDK with a valid company code.");
@@ -1805,7 +1856,7 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
       return;
     }
 
-    const shortCode = await returnInsertAffiliateIdentifier();
+    const shortCode = await returnInsertAffiliateIdentifierImpl();
     if (!shortCode) {
       console.error("[Insert Affiliate] No affiliate identifier found. Please set one before tracking events.");
       verboseLog("Cannot store transaction: no affiliate identifier available");
@@ -1851,10 +1902,10 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
   };
 
   // MARK: Track Event
-  const trackEvent = async (eventName: string): Promise<void> => {
+  const trackEventImpl = async (eventName: string): Promise<void> => {
     try {
       verboseLog(`Tracking event: ${eventName}`);
-      
+
       const activeCompanyCode = await getActiveCompanyCode();
       if (!activeCompanyCode) {
         console.error("[Insert Affiliate] Company code is not set. Please initialize the SDK with a valid company code.");
@@ -1884,7 +1935,7 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
       verboseLog(`Track event payload: ${JSON.stringify(payload)}`);
 
       verboseLog("Making API call to track event...");
-      
+
       const response = await axios.post(
         'https://api.insertaffiliate.com/v1/trackEvent',
         payload,
@@ -1999,6 +2050,101 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
     return removeSpecialCharacters(offerCode);
   };
 
+  // ============================================================================
+  // REF CALLBACK PATTERN: Update refs on every render for fresh closures
+  // ============================================================================
+  initializeImplRef.current = initializeImpl;
+  setShortCodeImplRef.current = setShortCodeImpl;
+  getAffiliateDetailsImplRef.current = getAffiliateDetailsImpl;
+  returnInsertAffiliateIdentifierImplRef.current = returnInsertAffiliateIdentifierImpl;
+  isAffiliateAttributionValidImplRef.current = isAffiliateAttributionValidImpl;
+  getAffiliateStoredDateImplRef.current = getAffiliateStoredDateImpl;
+  storeExpectedStoreTransactionImplRef.current = storeExpectedStoreTransactionImpl;
+  returnUserAccountTokenAndStoreExpectedTransactionImplRef.current = returnUserAccountTokenAndStoreExpectedTransactionImpl;
+  validatePurchaseWithIapticAPIImplRef.current = validatePurchaseWithIapticAPIImpl;
+  trackEventImplRef.current = trackEventImpl;
+  setInsertAffiliateIdentifierImplRef.current = setInsertAffiliateIdentifierImpl;
+  handleInsertLinksImplRef.current = handleInsertLinksImpl;
+
+  // ============================================================================
+  // STABLE WRAPPERS: useCallback with [] deps that delegate to refs
+  // These provide stable function references that always call current implementations
+  // ============================================================================
+  const initialize = useCallback(async (
+    code: string | null,
+    verboseLogging?: boolean,
+    insertLinksEnabled?: boolean,
+    insertLinksClipboardEnabled?: boolean,
+    affiliateAttributionActiveTime?: number
+  ): Promise<void> => {
+    return initializeImplRef.current(code, verboseLogging, insertLinksEnabled, insertLinksClipboardEnabled, affiliateAttributionActiveTime);
+  }, []);
+
+  const setShortCode = useCallback(async (shortCode: string): Promise<boolean> => {
+    return setShortCodeImplRef.current(shortCode);
+  }, []);
+
+  const getAffiliateDetails = useCallback(async (affiliateCode: string): Promise<AffiliateDetails> => {
+    return getAffiliateDetailsImplRef.current(affiliateCode);
+  }, []);
+
+  const returnInsertAffiliateIdentifier = useCallback(async (ignoreTimeout?: boolean): Promise<string | null> => {
+    return returnInsertAffiliateIdentifierImplRef.current(ignoreTimeout);
+  }, []);
+
+  const isAffiliateAttributionValid = useCallback(async (): Promise<boolean> => {
+    return isAffiliateAttributionValidImplRef.current();
+  }, []);
+
+  const getAffiliateStoredDate = useCallback(async (): Promise<Date | null> => {
+    return getAffiliateStoredDateImplRef.current();
+  }, []);
+
+  const storeExpectedStoreTransaction = useCallback(async (purchaseToken: string): Promise<void> => {
+    return storeExpectedStoreTransactionImplRef.current(purchaseToken);
+  }, []);
+
+  const returnUserAccountTokenAndStoreExpectedTransaction = useCallback(async (): Promise<string | null> => {
+    return returnUserAccountTokenAndStoreExpectedTransactionImplRef.current();
+  }, []);
+
+  const validatePurchaseWithIapticAPI = useCallback(async (
+    jsonIapPurchase: CustomPurchase,
+    iapticAppId: string,
+    iapticAppName: string,
+    iapticPublicKey: string
+  ): Promise<boolean> => {
+    return validatePurchaseWithIapticAPIImplRef.current(jsonIapPurchase, iapticAppId, iapticAppName, iapticPublicKey);
+  }, []);
+
+  const trackEvent = useCallback(async (eventName: string): Promise<void> => {
+    return trackEventImplRef.current(eventName);
+  }, []);
+
+  const setInsertAffiliateIdentifier = useCallback(async (referringLink: string): Promise<void | string> => {
+    return setInsertAffiliateIdentifierImplRef.current(referringLink);
+  }, []);
+
+  const setInsertAffiliateIdentifierChangeCallbackHandler = useCallback((callback: InsertAffiliateIdentifierChangeCallback | null): void => {
+    insertAffiliateIdentifierChangeCallbackRef.current = callback;
+
+    // If callback is being set, immediately call it with the current identifier value
+    // This ensures callbacks registered after initialization still receive the current state (including null if expired/not set)
+    if (callback) {
+      returnInsertAffiliateIdentifierImpl().then(identifier => {
+        // Verify callback is still the same (wasn't replaced during async operation)
+        if (insertAffiliateIdentifierChangeCallbackRef.current === callback) {
+          verboseLog(`Calling callback immediately with current identifier: ${identifier}`);
+          callback(identifier);
+        }
+      });
+    }
+  }, []);
+
+  const handleInsertLinks = useCallback(async (url: string): Promise<boolean> => {
+    return handleInsertLinksImplRef.current(url);
+  }, []);
+
   return (
     <DeepLinkIapContext.Provider
       value={{