insert-affiliate-react-native-sdk 1.6.5 → 1.7.0

package/dist/DeepLinkIapProvider.d.ts

@@ -10,7 +10,9 @@ type T_DEEPLINK_IAP_CONTEXT = {
     referrerLink: string;
     userId: string;
     OfferCode: string | null;
-    returnInsertAffiliateIdentifier: () => Promise<string | null>;
+    returnInsertAffiliateIdentifier: (ignoreTimeout?: boolean) => Promise<string | null>;
+    isAffiliateAttributionValid: () => Promise<boolean>;
+    getAffiliateStoredDate: () => Promise<Date | null>;
     validatePurchaseWithIapticAPI: (jsonIapPurchase: CustomPurchase, iapticAppId: string, iapticAppName: string, iapticPublicKey: string) => Promise<boolean>;
     returnUserAccountTokenAndStoreExpectedTransaction: () => Promise<string | null>;
     storeExpectedStoreTransaction: (purchaseToken: string) => Promise<void>;
@@ -19,7 +21,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) => Promise<void>;
+    initialize: (code: string | null, verboseLogging?: boolean, insertLinksEnabled?: boolean, insertLinksClipboardEnabled?: boolean, affiliateAttributionActiveTime?: number) => Promise<void>;
     isInitialized: boolean;
 };
 export declare const DeepLinkIapContext: React.Context<T_DEEPLINK_IAP_CONTEXT>;

package/dist/DeepLinkIapProvider.js

@@ -51,13 +51,16 @@ const ASYNC_KEYS = {
     COMPANY_CODE: '@app_company_code',
     USER_ACCOUNT_TOKEN: '@app_user_account_token',
     IOS_OFFER_CODE: '@app_ios_offer_code',
+    AFFILIATE_STORED_DATE: '@app_affiliate_stored_date',
 };
 // STARTING CONTEXT IMPLEMENTATION
 exports.DeepLinkIapContext = (0, react_1.createContext)({
     referrerLink: '',
     userId: '',
     OfferCode: null,
-    returnInsertAffiliateIdentifier: () => __awaiter(void 0, void 0, void 0, function* () { return ''; }),
+    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; }),
     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* () { }),
@@ -66,7 +69,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) => __awaiter(void 0, void 0, void 0, function* () { }),
+    initialize: (code, verboseLogging, insertLinksEnabled, insertLinksClipboardEnabled, affiliateAttributionActiveTime) => __awaiter(void 0, void 0, void 0, function* () { }),
     isInitialized: false,
 });
 const DeepLinkIapProvider = ({ children, }) => {
@@ -78,12 +81,16 @@ const DeepLinkIapProvider = ({ children, }) => {
     const [insertLinksEnabled, setInsertLinksEnabled] = (0, react_1.useState)(false);
     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 insertAffiliateIdentifierChangeCallbackRef = (0, react_1.useRef)(null);
     // MARK: Initialize the SDK
-    const initialize = (companyCode_1, ...args_1) => __awaiter(void 0, [companyCode_1, ...args_1], void 0, function* (companyCode, verboseLogging = false, insertLinksEnabled = false, insertLinksClipboardEnabled = false) {
+    const initialize = (companyCode_1, ...args_1) => __awaiter(void 0, [companyCode_1, ...args_1], void 0, function* (companyCode, verboseLogging = false, insertLinksEnabled = false, insertLinksClipboardEnabled = false, affiliateAttributionActiveTime) {
         setVerboseLogging(verboseLogging);
         setInsertLinksEnabled(insertLinksEnabled);
         setInsertLinksClipboardEnabled(insertLinksClipboardEnabled);
+        if (affiliateAttributionActiveTime !== undefined) {
+            setAffiliateAttributionActiveTime(affiliateAttributionActiveTime);
+        }
         if (verboseLogging) {
             console.log('[Insert Affiliate] [VERBOSE] Starting SDK initialization...');
             console.log('[Insert Affiliate] [VERBOSE] Company code provided:', companyCode ? 'Yes' : 'No');
@@ -1057,10 +1064,18 @@ const DeepLinkIapProvider = ({ children, }) => {
         ;
     });
     // MARK: Return Insert Affiliate Identifier
-    // Instead of just reading React state
-    const returnInsertAffiliateIdentifier = () => __awaiter(void 0, void 0, void 0, function* () {
+    const returnInsertAffiliateIdentifier = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (ignoreTimeout = false) {
         try {
-            verboseLog('Getting insert affiliate identifier...');
+            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 = yield isAffiliateAttributionValid();
+                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) {
@@ -1092,6 +1107,48 @@ const DeepLinkIapProvider = ({ children, }) => {
             return null;
         }
     });
+    // MARK: Attribution Timeout Functions
+    // Check if the current affiliate attribution is still valid based on timeout
+    const isAffiliateAttributionValid = () => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            // If no timeout is set, attribution is always valid
+            if (!affiliateAttributionActiveTime) {
+                verboseLog('No attribution timeout set, attribution is valid');
+                return true;
+            }
+            const storedDate = yield getAffiliateStoredDate();
+            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 = () => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const storedDateString = yield 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;
+        }
+        catch (error) {
+            verboseLog(`Error getting affiliate stored date: ${error}`);
+            return null;
+        }
+    });
     // MARK: Insert Affiliate Identifier
     function setInsertAffiliateIdentifier(referringLink) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -1174,10 +1231,20 @@ const DeepLinkIapProvider = ({ children, }) => {
     function storeInsertAffiliateIdentifier(_a) {
         return __awaiter(this, arguments, void 0, function* ({ link }) {
             console.log(`[Insert Affiliate] Storing affiliate identifier: ${link}`);
+            // 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;
+            }
             verboseLog(`Updating React state with referrer link: ${link}`);
             setReferrerLink(link);
             verboseLog(`Saving referrer link to AsyncStorage...`);
             yield saveValueInAsync(ASYNC_KEYS.REFERRER_LINK, link);
+            // Store the current date/time when the affiliate identifier is stored
+            const currentDate = new Date().toISOString();
+            verboseLog(`Saving affiliate stored date: ${currentDate}`);
+            yield saveValueInAsync(ASYNC_KEYS.AFFILIATE_STORED_DATE, currentDate);
             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...');
@@ -1426,6 +1493,8 @@ const DeepLinkIapProvider = ({ children, }) => {
             OfferCode,
             setShortCode,
             returnInsertAffiliateIdentifier,
+            isAffiliateAttributionValid,
+            getAffiliateStoredDate,
             storeExpectedStoreTransaction,
             returnUserAccountTokenAndStoreExpectedTransaction,
             validatePurchaseWithIapticAPI,

package/dist/useDeepLinkIapProvider.d.ts

@@ -6,13 +6,15 @@ declare const useDeepLinkIapProvider: () => {
     }, iapticAppId: string, iapticAppName: string, iapticPublicKey: string) => Promise<boolean>;
     storeExpectedStoreTransaction: (purchaseToken: string) => Promise<void>;
     returnUserAccountTokenAndStoreExpectedTransaction: () => Promise<string | null>;
-    returnInsertAffiliateIdentifier: () => Promise<string | null>;
+    returnInsertAffiliateIdentifier: (ignoreTimeout?: boolean) => Promise<string | null>;
+    isAffiliateAttributionValid: () => Promise<boolean>;
+    getAffiliateStoredDate: () => Promise<Date | null>;
     trackEvent: (eventName: string) => Promise<void>;
     setShortCode: (shortCode: string) => Promise<void>;
     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) => Promise<void>;
+    initialize: (code: string | null, verboseLogging?: boolean, insertLinksEnabled?: boolean, insertLinksClipboardEnabled?: boolean, affiliateAttributionActiveTime?: number) => 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, trackEvent, setShortCode, setInsertAffiliateIdentifier, setInsertAffiliateIdentifierChangeCallback, handleInsertLinks, initialize, isInitialized, OfferCode, } = (0, react_1.useContext)(DeepLinkIapProvider_1.DeepLinkIapContext);
+    const { referrerLink, userId, validatePurchaseWithIapticAPI, storeExpectedStoreTransaction, returnUserAccountTokenAndStoreExpectedTransaction, returnInsertAffiliateIdentifier, isAffiliateAttributionValid, getAffiliateStoredDate, trackEvent, setShortCode, setInsertAffiliateIdentifier, setInsertAffiliateIdentifierChangeCallback, handleInsertLinks, initialize, isInitialized, OfferCode, } = (0, react_1.useContext)(DeepLinkIapProvider_1.DeepLinkIapContext);
     return {
         referrerLink,
         userId,
@@ -11,6 +11,8 @@ const useDeepLinkIapProvider = () => {
         storeExpectedStoreTransaction,
         returnUserAccountTokenAndStoreExpectedTransaction,
         returnInsertAffiliateIdentifier,
+        isAffiliateAttributionValid,
+        getAffiliateStoredDate,
         trackEvent,
         setShortCode,
         setInsertAffiliateIdentifier,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "insert-affiliate-react-native-sdk",
-  "version": "1.6.5",
+  "version": "1.7.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

@@ -172,7 +172,8 @@ const Child = () => {
         "{{ your-company-code }}", 
         false, // Enable for debugging
         true,  // Enables Insert Links
-        true   // Enable Insert Links Clipboard access to avoid permission prompt
+        true,  // Enable Insert Links Clipboard access to avoid permission prompt
+        604800 // Optional: Attribution timeout in seconds (7 days)
       );
     }
   }, [initialize, isInitialized]);
@@ -1227,3 +1228,84 @@ Short codes must meet the following criteria:
     onPress={() => setShortCode('JOIN_123')}
   />
 ```
+
+### Attribution Timeout
+
+You can configure how long an affiliate link attribution remains active after being clicked. This allows you to control the attribution window for commissions.
+
+#### Basic Usage
+
+When initializing the SDK, you can specify the attribution timeout in seconds:
+
+```javascript
+const Child = () => {
+  const { initialize, isInitialized } = useDeepLinkIapProvider();
+
+  useEffect(() => {
+    if (!isInitialized) {
+      // Set attribution timeout to 7 days (7 * 24 * 60 * 60 = 604800 seconds)
+      initialize(
+        "{{ your-company-code }}", 
+        false, // verbose logging
+        false, // insert links enabled
+        false, // insert links clipboard enabled  
+        604800 // attribution timeout in seconds
+      );
+    }
+  }, [initialize, isInitialized]);
+}
+```
+
+**When to use `affiliateAttributionActiveTime`:**
+- Set to a number in seconds to define how long affiliate attributions remain active
+- Set to `null` or omit to disable attribution timeout (attribution never expires)
+- Common values: 86400 (1 day), 604800 (7 days), 2592000 (30 days)
+
+#### Common Timeout Values
+
+```javascript
+// 1 day
+initialize("your-company-code", false, false, false, 86400);
+
+// 7 days (default for many platforms)
+initialize("your-company-code", false, false, false, 604800);
+
+// 30 days
+initialize("your-company-code", false, false, false, 2592000);
+
+// No timeout (attribution never expires)
+initialize("your-company-code", false, false, false); // or pass null/undefined
+```
+
+#### Advanced Usage
+
+The SDK provides methods to work with attribution timeouts:
+
+```javascript
+const {
+  returnInsertAffiliateIdentifier,
+  isAffiliateAttributionValid,
+  getAffiliateStoredDate
+} = useDeepLinkIapProvider();
+
+// Get affiliate identifier (respects timeout)
+const identifier = await returnInsertAffiliateIdentifier();
+
+// Get affiliate identifier ignoring timeout
+const rawIdentifier = await returnInsertAffiliateIdentifier(true);
+
+// Check if attribution is still valid
+const isValid = await isAffiliateAttributionValid();
+
+// Get the date when affiliate was first stored
+const storedDate = await getAffiliateStoredDate();
+```
+
+#### How It Works
+
+1. **Attribution Storage**: When an affiliate link is clicked and processed, the SDK stores both the affiliate identifier and the current timestamp
+2. **Timeout Check**: When `returnInsertAffiliateIdentifier()` is called, the SDK checks if the stored attribution is still within the timeout window
+3. **Expired Attribution**: If the attribution has expired, the method returns `null` instead of the affiliate identifier
+4. **Bypass Option**: You can bypass the timeout check by passing `true` to `returnInsertAffiliateIdentifier(true)`
+
+This ensures that affiliates are only credited for purchases made within the specified attribution window, providing fair and accurate commission tracking.

package/src/DeepLinkIapProvider.tsx

@@ -22,7 +22,9 @@ type T_DEEPLINK_IAP_CONTEXT = {
   referrerLink: string;
   userId: string;
   OfferCode: string | null;
-  returnInsertAffiliateIdentifier: () => Promise<string | null>;
+  returnInsertAffiliateIdentifier: (ignoreTimeout?: boolean) => Promise<string | null>;
+  isAffiliateAttributionValid: () => Promise<boolean>;
+  getAffiliateStoredDate: () => Promise<Date | null>;
   validatePurchaseWithIapticAPI: (
     jsonIapPurchase: CustomPurchase,
     iapticAppId: string,
@@ -40,7 +42,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) => Promise<void>;
+  initialize: (code: string | null, verboseLogging?: boolean, insertLinksEnabled?: boolean, insertLinksClipboardEnabled?: boolean, affiliateAttributionActiveTime?: number) => Promise<void>;
   isInitialized: boolean;
 };
 
@@ -67,6 +69,7 @@ const ASYNC_KEYS = {
   COMPANY_CODE: '@app_company_code',
   USER_ACCOUNT_TOKEN: '@app_user_account_token',
   IOS_OFFER_CODE: '@app_ios_offer_code',
+  AFFILIATE_STORED_DATE: '@app_affiliate_stored_date',
 };
 
 // STARTING CONTEXT IMPLEMENTATION
@@ -74,7 +77,9 @@ export const DeepLinkIapContext = createContext<T_DEEPLINK_IAP_CONTEXT>({
   referrerLink: '',
   userId: '',
   OfferCode: null,
-  returnInsertAffiliateIdentifier: async () => '',
+  returnInsertAffiliateIdentifier: async (ignoreTimeout?: boolean) => '',
+  isAffiliateAttributionValid: async () => false,
+  getAffiliateStoredDate: async () => null,
   validatePurchaseWithIapticAPI: async (
     jsonIapPurchase: CustomPurchase,
     iapticAppId: string,
@@ -88,7 +93,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) => {},
+  initialize: async (code: string | null, verboseLogging?: boolean, insertLinksEnabled?: boolean, insertLinksClipboardEnabled?: boolean, affiliateAttributionActiveTime?: number) => {},
   isInitialized: false,
 });
 
@@ -103,13 +108,17 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
   const [insertLinksEnabled, setInsertLinksEnabled] = useState<boolean>(false);
   const [insertLinksClipboardEnabled, setInsertLinksClipboardEnabled] = useState<boolean>(false);
   const [OfferCode, setOfferCode] = useState<string | null>(null);
+  const [affiliateAttributionActiveTime, setAffiliateAttributionActiveTime] = useState<number | null>(null);
   const insertAffiliateIdentifierChangeCallbackRef = useRef<InsertAffiliateIdentifierChangeCallback | null>(null);
 
   // MARK: Initialize the SDK
-  const initialize = async (companyCode: string | null, verboseLogging: boolean = false, insertLinksEnabled: boolean = false, insertLinksClipboardEnabled: boolean = false): Promise<void> => {
+  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);
+    }
     
     if (verboseLogging) {
       console.log('[Insert Affiliate] [VERBOSE] Starting SDK initialization...');
@@ -1210,10 +1219,20 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
   };
 
   // MARK: Return Insert Affiliate Identifier
-  // Instead of just reading React state
-  const returnInsertAffiliateIdentifier = async (): Promise<string | null> => {
+  const returnInsertAffiliateIdentifier = async (ignoreTimeout: boolean = false): Promise<string | null> => {
     try {
-      verboseLog('Getting insert affiliate identifier...');
+      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();
+        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
@@ -1252,6 +1271,54 @@ 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> => {
+    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();
+      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> => {
+    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;
+    } catch (error) {
+      verboseLog(`Error getting affiliate stored date: ${error}`);
+      return null;
+    }
+  };
+
   // MARK: Insert Affiliate Identifier
 
   async function setInsertAffiliateIdentifier(
@@ -1349,10 +1416,24 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
   
   async function storeInsertAffiliateIdentifier({ link }: { link: string }) {
     console.log(`[Insert Affiliate] Storing affiliate identifier: ${link}`);
+    
+    // Check if we're trying to store the same link (prevent duplicate storage)
+    const existingLink = await getValueFromAsync(ASYNC_KEYS.REFERRER_LINK);
+    if (existingLink === link) {
+      verboseLog(`Link ${link} is already stored, skipping duplicate storage`);
+      return;
+    }
+    
     verboseLog(`Updating React state with referrer link: ${link}`);
     setReferrerLink(link);
     verboseLog(`Saving referrer link to AsyncStorage...`);
     await saveValueInAsync(ASYNC_KEYS.REFERRER_LINK, link);
+    
+    // Store the current date/time when the affiliate identifier is stored
+    const currentDate = new Date().toISOString();
+    verboseLog(`Saving affiliate stored date: ${currentDate}`);
+    await saveValueInAsync(ASYNC_KEYS.AFFILIATE_STORED_DATE, currentDate);
+    
     verboseLog(`Referrer link saved to AsyncStorage successfully`);
     
     // Automatically fetch and store offer code for any affiliate identifier
@@ -1658,6 +1739,8 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
         OfferCode,
         setShortCode,
         returnInsertAffiliateIdentifier,
+        isAffiliateAttributionValid,
+        getAffiliateStoredDate,
         storeExpectedStoreTransaction,
         returnUserAccountTokenAndStoreExpectedTransaction,
         validatePurchaseWithIapticAPI,

package/src/useDeepLinkIapProvider.tsx

@@ -9,6 +9,8 @@ const useDeepLinkIapProvider = () => {
     storeExpectedStoreTransaction,
     returnUserAccountTokenAndStoreExpectedTransaction,
     returnInsertAffiliateIdentifier,
+    isAffiliateAttributionValid,
+    getAffiliateStoredDate,
     trackEvent,
     setShortCode,
     setInsertAffiliateIdentifier,
@@ -26,6 +28,8 @@ const useDeepLinkIapProvider = () => {
     storeExpectedStoreTransaction,
     returnUserAccountTokenAndStoreExpectedTransaction,
     returnInsertAffiliateIdentifier,
+    isAffiliateAttributionValid,
+    getAffiliateStoredDate,
     trackEvent,
     setShortCode,
     setInsertAffiliateIdentifier,