insert-affiliate-react-native-sdk 1.3.5 → 1.4.2

package/dist/DeepLinkIapProvider.d.ts

@@ -1,4 +1,4 @@
-import React from "react";
+import React from 'react';
 type T_DEEPLINK_IAP_PROVIDER = {
     children: React.ReactNode;
 };
@@ -10,9 +10,11 @@ type T_DEEPLINK_IAP_CONTEXT = {
     userId: string;
     returnInsertAffiliateIdentifier: () => Promise<string | null>;
     validatePurchaseWithIapticAPI: (jsonIapPurchase: CustomPurchase, iapticAppId: string, iapticAppName: string, iapticPublicKey: string) => Promise<boolean>;
+    returnUserAccountTokenAndStoreExpectedTransaction: () => Promise<string | null>;
+    storeExpectedStoreTransaction: (purchaseToken: string) => Promise<void>;
     trackEvent: (eventName: string) => Promise<void>;
     setShortCode: (shortCode: string) => Promise<void>;
-    setInsertAffiliateIdentifier: (referringLink: string) => Promise<void>;
+    setInsertAffiliateIdentifier: (referringLink: string) => Promise<void | string>;
     initialize: (code: string | null) => Promise<void>;
     isInitialized: boolean;
 };

package/dist/DeepLinkIapProvider.js

@@ -41,42 +41,45 @@ const react_native_1 = require("react-native");
 const axios_1 = __importDefault(require("axios"));
 const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
 const ASYNC_KEYS = {
-    REFERRER_LINK: "@app_referrer_link",
-    USER_PURCHASE: "@app_user_purchase",
-    USER_ID: "@app_user_id",
-    COMPANY_CODE: "@app_company_code",
+    REFERRER_LINK: '@app_referrer_link',
+    USER_PURCHASE: '@app_user_purchase',
+    USER_ID: '@app_user_id',
+    COMPANY_CODE: '@app_company_code',
+    USER_ACCOUNT_TOKEN: '@app_user_account_token',
 };
 // STARTING CONTEXT IMPLEMENTATION
 exports.DeepLinkIapContext = (0, react_1.createContext)({
-    referrerLink: "",
-    userId: "",
-    returnInsertAffiliateIdentifier: () => __awaiter(void 0, void 0, void 0, function* () { return ""; }),
+    referrerLink: '',
+    userId: '',
+    returnInsertAffiliateIdentifier: () => __awaiter(void 0, void 0, void 0, function* () { return ''; }),
     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* () { }),
     trackEvent: (eventName) => __awaiter(void 0, void 0, void 0, function* () { }),
     setShortCode: (shortCode) => __awaiter(void 0, void 0, void 0, function* () { }),
     setInsertAffiliateIdentifier: (referringLink) => __awaiter(void 0, void 0, void 0, function* () { }),
     initialize: (code) => __awaiter(void 0, void 0, void 0, function* () { }),
-    isInitialized: false
+    isInitialized: false,
 });
 const DeepLinkIapProvider = ({ children, }) => {
-    const [referrerLink, setReferrerLink] = (0, react_1.useState)("");
-    const [userId, setUserId] = (0, react_1.useState)("");
+    const [referrerLink, setReferrerLink] = (0, react_1.useState)('');
+    const [userId, setUserId] = (0, react_1.useState)('');
     const [companyCode, setCompanyCode] = (0, react_1.useState)(null);
     const [isInitialized, setIsInitialized] = (0, react_1.useState)(false);
     // MARK: Initialize the SDK
     const initialize = (companyCode) => __awaiter(void 0, void 0, void 0, function* () {
         if (isInitialized) {
-            console.error("[Insert Affiliate] SDK is already initialized.");
+            console.error('[Insert Affiliate] SDK is already initialized.');
             return;
         }
-        if (companyCode && companyCode.trim() !== "") {
+        if (companyCode && companyCode.trim() !== '') {
             setCompanyCode(companyCode);
             yield saveValueInAsync(ASYNC_KEYS.COMPANY_CODE, companyCode);
             setIsInitialized(true);
             console.log(`[Insert Affiliate] SDK initialized with company code: ${companyCode}`);
         }
         else {
-            console.warn("[Insert Affiliate] SDK initialized without a company code.");
+            console.warn('[Insert Affiliate] SDK initialized without a company code.');
             setIsInitialized(true);
         }
     });
@@ -103,14 +106,18 @@ const DeepLinkIapProvider = ({ children, }) => {
             let userId = yield getValueFromAsync(ASYNC_KEYS.USER_ID);
             if (!userId) {
                 userId = generateUserID();
+                setUserId(userId);
                 yield saveValueInAsync(ASYNC_KEYS.USER_ID, userId);
+            }
+            else {
                 setUserId(userId);
             }
+            return userId;
         });
     }
     const generateUserID = () => {
-        const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-        let uniqueId = "";
+        const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        let uniqueId = '';
         for (let i = 0; i < 6; i++) {
             const randomIndex = Math.floor(Math.random() * characters.length);
             uniqueId += characters[randomIndex];
@@ -120,7 +127,7 @@ const DeepLinkIapProvider = ({ children, }) => {
     const reset = () => {
         setCompanyCode(null);
         setIsInitialized(false);
-        console.log("[Insert Affiliate] SDK has been reset.");
+        console.log('[Insert Affiliate] SDK has been reset.');
     };
     // Helper funciton Storage / Retrieval
     const saveValueInAsync = (key, value) => __awaiter(void 0, void 0, void 0, function* () {
@@ -136,10 +143,10 @@ const DeepLinkIapProvider = ({ children, }) => {
     // Helper function to log errors
     const errorLog = (message, type) => {
         switch (type) {
-            case "error":
+            case 'error':
                 console.error(`ENCOUNTER ERROR ~ ${message}`);
                 break;
-            case "warn":
+            case 'warn':
                 console.warn(`ENCOUNTER WARNING ~ ${message}`);
                 break;
             default:
@@ -155,8 +162,8 @@ const DeepLinkIapProvider = ({ children, }) => {
     };
     function setShortCode(shortCode) {
         return __awaiter(this, void 0, void 0, function* () {
-            console.log("[Insert Affiliate] Setting short code.");
-            generateThenSetUserID();
+            console.log('[Insert Affiliate] Setting short code.');
+            yield generateThenSetUserID();
             // Validate it is a short code
             const capitalisedShortCode = shortCode.toUpperCase();
             isShortCode(capitalisedShortCode);
@@ -164,6 +171,41 @@ const DeepLinkIapProvider = ({ children, }) => {
             yield storeInsertAffiliateIdentifier({ link: capitalisedShortCode });
         });
     }
+    function getOrCreateUserAccountToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let userAccountToken = yield getValueFromAsync(ASYNC_KEYS.USER_ACCOUNT_TOKEN);
+            if (!userAccountToken) {
+                userAccountToken = UUID();
+                yield saveValueInAsync(ASYNC_KEYS.USER_ACCOUNT_TOKEN, userAccountToken);
+            }
+            return userAccountToken;
+        });
+    }
+    ;
+    const returnUserAccountTokenAndStoreExpectedTransaction = () => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const shortCode = yield returnInsertAffiliateIdentifier();
+            if (!shortCode) {
+                console.log('[Insert Affiliate] No affiliate stored - not saving expected transaction.');
+                return null;
+            }
+            const userAccountToken = yield getOrCreateUserAccountToken();
+            console.log('[Insert Affiliate] User account token:', userAccountToken);
+            if (!userAccountToken) {
+                console.error('[Insert Affiliate] Failed to generate user account token.');
+                return null;
+            }
+            else {
+                yield storeExpectedStoreTransaction(userAccountToken);
+                return userAccountToken;
+            }
+        }
+        catch (error) {
+            console.error('[Insert Affiliate] Error in returnUserAccountTokenAndStoreExpectedTransaction:', error);
+            return null;
+        }
+        ;
+    });
     // MARK: Return Insert Affiliate Identifier
     const returnInsertAffiliateIdentifier = () => __awaiter(void 0, void 0, void 0, function* () {
         try {
@@ -177,60 +219,65 @@ const DeepLinkIapProvider = ({ children, }) => {
     // MARK: Insert Affiliate Identifier
     function setInsertAffiliateIdentifier(referringLink) {
         return __awaiter(this, void 0, void 0, function* () {
-            console.log("[Insert Affiliate] Setting affiliate identifier.");
+            console.log('[Insert Affiliate] Setting affiliate identifier.');
             try {
-                yield generateThenSetUserID();
-                console.log("[Insert Affiliate] Completed generateThenSetUserID within setInsertAffiliateIdentifier.");
+                const customerID = yield generateThenSetUserID();
+                console.log('[Insert Affiliate] Completed generateThenSetUserID within setInsertAffiliateIdentifier.');
                 if (!referringLink) {
-                    console.warn("[Insert Affiliate] Referring link is invalid.");
+                    console.warn('[Insert Affiliate] Referring link is invalid.');
+                    let heldReferrerLinkBeforeAsyncStateUpdate = referrerLink;
                     yield storeInsertAffiliateIdentifier({ link: referringLink });
-                    return;
+                    return `${heldReferrerLinkBeforeAsyncStateUpdate}-${customerID}`;
                 }
-                if (!companyCode || companyCode.trim() === "" && companyCode !== null) {
+                if (!companyCode || (companyCode.trim() === '' && companyCode !== null)) {
                     let companyCodeFromStorage = yield getValueFromAsync(ASYNC_KEYS.COMPANY_CODE);
                     if (companyCodeFromStorage !== null) {
                         setCompanyCode(companyCodeFromStorage);
                     }
                     else {
-                        console.error("[Insert Affiliate] Company code is not set. Please initialize the SDK with a valid company code.");
+                        console.error('[Insert Affiliate] Company code is not set. Please initialize the SDK with a valid company code.');
                         return;
                     }
                 }
                 // Check if referring link is already a short code, if so save it and stop here.
                 if (isShortCode(referringLink)) {
-                    console.log("[Insert Affiliate] Referring link is already a short code.");
+                    console.log('[Insert Affiliate] Referring link is already a short code.');
+                    let heldReferrerLinkBeforeAsyncStateUpdate = referrerLink;
                     yield storeInsertAffiliateIdentifier({ link: referringLink });
-                    return;
+                    return `${heldReferrerLinkBeforeAsyncStateUpdate}-${customerID}`;
                 }
                 // If the code is not already a short code, encode it raedy to send to our endpoint to return the short code. Save it before making the call in case something goes wrong
                 // Encode the referring link
                 const encodedAffiliateLink = encodeURIComponent(referringLink);
                 if (!encodedAffiliateLink) {
-                    console.error("[Insert Affiliate] Failed to encode affiliate link.");
+                    console.error('[Insert Affiliate] Failed to encode affiliate link.');
+                    let heldReferrerLinkBeforeAsyncStateUpdate = referrerLink;
                     yield storeInsertAffiliateIdentifier({ link: referringLink });
-                    return;
+                    return `${heldReferrerLinkBeforeAsyncStateUpdate}-${customerID}`;
                 }
                 // Create the request URL
                 const urlString = `https://api.insertaffiliate.com/V1/convert-deep-link-to-short-link?companyId=${companyCode}&deepLinkUrl=${encodedAffiliateLink}`;
-                console.log("[Insert Affiliate] urlString .", urlString);
+                console.log('[Insert Affiliate] urlString .', urlString);
                 const response = yield axios_1.default.get(urlString, {
                     headers: {
-                        "Content-Type": "application/json",
+                        'Content-Type': 'application/json',
                     },
                 });
                 // Call to the backend for the short code and save the resolse in valid
                 if (response.status === 200 && response.data.shortLink) {
                     const shortLink = response.data.shortLink;
-                    console.log("[Insert Affiliate] Short link received:", shortLink);
-                    yield storeInsertAffiliateIdentifier({ link: shortLink });
+                    console.log('[Insert Affiliate] Short link received:', shortLink);
+                    return `${shortLink}-${customerID}`;
                 }
                 else {
-                    console.warn("[Insert Affiliate] Unexpected response format.");
+                    console.warn('[Insert Affiliate] Unexpected response format.');
+                    let heldReferrerLinkBeforeAsyncStateUpdate = referrerLink;
                     yield storeInsertAffiliateIdentifier({ link: referringLink });
+                    return `${heldReferrerLinkBeforeAsyncStateUpdate}-${customerID}`;
                 }
             }
             catch (error) {
-                console.error("[Insert Affiliate] Error:", error);
+                console.error('[Insert Affiliate] Error:', error);
             }
         });
     }
@@ -238,29 +285,29 @@ const DeepLinkIapProvider = ({ children, }) => {
     function storeInsertAffiliateIdentifier(_a) {
         return __awaiter(this, arguments, void 0, function* ({ link }) {
             console.log(`[Insert Affiliate] Storing affiliate identifier: ${link}`);
-            yield saveValueInAsync(ASYNC_KEYS.REFERRER_LINK, link);
             setReferrerLink(link);
+            yield saveValueInAsync(ASYNC_KEYS.REFERRER_LINK, link);
         });
     }
     const validatePurchaseWithIapticAPI = (jsonIapPurchase, iapticAppId, iapticAppName, iapticPublicKey) => __awaiter(void 0, void 0, void 0, function* () {
         try {
             const baseRequestBody = {
                 id: iapticAppId,
-                type: "application",
+                type: 'application',
             };
             let transaction;
-            if (react_native_1.Platform.OS === "ios") {
+            if (react_native_1.Platform.OS === 'ios') {
                 transaction = {
                     id: iapticAppId,
-                    type: "ios-appstore",
+                    type: 'ios-appstore',
                     appStoreReceipt: jsonIapPurchase.transactionReceipt,
                 };
             }
             else {
-                const receiptJson = JSON.parse(atob(jsonIapPurchase.transactionReceipt || ""));
+                const receiptJson = JSON.parse(atob(jsonIapPurchase.transactionReceipt || ''));
                 transaction = {
                     id: receiptJson.orderId, // Extracted orderId
-                    type: "android-playstore",
+                    type: 'android-playstore',
                     purchaseToken: receiptJson.purchaseToken, // Extracted purchase token
                     receipt: jsonIapPurchase.transactionReceipt, // Full receipt (Base64)
                     signature: receiptJson.signature, // Receipt signature
@@ -276,19 +323,19 @@ const DeepLinkIapProvider = ({ children, }) => {
             // Send validation request to server
             const response = yield (0, axios_1.default)({
                 url: `https://validator.iaptic.com/v1/validate`,
-                method: "POST",
+                method: 'POST',
                 headers: {
                     Authorization: `Basic ${btoa(`${iapticAppName}:${iapticPublicKey}`)}`,
-                    "Content-Type": "application/json",
+                    'Content-Type': 'application/json',
                 },
                 data: requestBody,
             });
             if (response.status === 200) {
-                console.log("Validation successful:", response.data);
+                console.log('Validation successful:', response.data);
                 return true;
             }
             else {
-                console.error("Validation failed:", response.data);
+                console.error('Validation failed:', response.data);
                 return false;
             }
         }
@@ -302,29 +349,67 @@ const DeepLinkIapProvider = ({ children, }) => {
             return false;
         }
     });
-    // MARK: Track Event 
+    const storeExpectedStoreTransaction = (purchaseToken) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!companyCode || (companyCode.trim() === '' && companyCode !== null)) {
+            console.error("[Insert Affiliate] Company code is not set. Please initialize the SDK with a valid company code.");
+            return;
+        }
+        const shortCode = yield returnInsertAffiliateIdentifier();
+        if (!shortCode) {
+            console.error("[Insert Affiliate] No affiliate identifier found. Please set one before tracking events.");
+            return;
+        }
+        // Build JSON payload
+        const payload = {
+            UUID: purchaseToken,
+            companyCode,
+            shortCode,
+            storedDate: new Date().toISOString(), // ISO8601 format
+        };
+        console.log("[Insert Affiliate] Storing expected transaction: ", payload);
+        try {
+            const response = yield fetch("https://api.insertaffiliate.com/v1/api/app-store-webhook/create-expected-transaction", {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(payload),
+            });
+            if (response.ok) {
+                console.info("[Insert Affiliate] Expected transaction stored successfully.");
+            }
+            else {
+                const errorText = yield response.text();
+                console.error(`[Insert Affiliate] Failed to store expected transaction with status code: ${response.status}. Response: ${errorText}`);
+            }
+        }
+        catch (error) {
+            console.error(`[Insert Affiliate] Error storing expected transaction: ${error}`);
+        }
+    });
+    // MARK: Track Event
     const trackEvent = (eventName) => __awaiter(void 0, void 0, void 0, function* () {
         try {
             if (!referrerLink || !userId) {
-                console.warn("[Insert Affiliate] No affiliate identifier found. Please set one before tracking events.");
+                console.warn('[Insert Affiliate] No affiliate identifier found. Please set one before tracking events.');
                 return Promise.resolve();
             }
             const payload = {
                 eventName,
                 deepLinkParam: `${referrerLink}/${userId}`,
             };
-            const response = yield axios_1.default.post("https://api.insertaffiliate.com/v1/trackEvent", payload, {
-                headers: { "Content-Type": "application/json" },
+            const response = yield axios_1.default.post('https://api.insertaffiliate.com/v1/trackEvent', payload, {
+                headers: { 'Content-Type': 'application/json' },
             });
             if (response.status === 200) {
-                console.log("[Insert Affiliate] Event tracked successfully");
+                console.log('[Insert Affiliate] Event tracked successfully');
             }
             else {
                 console.error(`[Insert Affiliate] Failed to track event with status code: ${response.status}`);
             }
         }
         catch (error) {
-            console.error("[Insert Affiliate] Error tracking event:", error);
+            console.error('[Insert Affiliate] Error tracking event:', error);
             return Promise.reject(error);
         }
     });
@@ -333,11 +418,20 @@ const DeepLinkIapProvider = ({ children, }) => {
             userId,
             setShortCode,
             returnInsertAffiliateIdentifier,
+            storeExpectedStoreTransaction,
+            returnUserAccountTokenAndStoreExpectedTransaction,
             validatePurchaseWithIapticAPI,
             trackEvent,
             setInsertAffiliateIdentifier,
             initialize,
-            isInitialized
+            isInitialized,
         } }, children));
 };
 exports.default = DeepLinkIapProvider;
+function UUID() {
+    // Generate a random UUID (version 4)
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+        const r = (Math.random() * 16) | 0, v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}

package/dist/useDeepLinkIapProvider.d.ts

@@ -4,10 +4,12 @@ declare const useDeepLinkIapProvider: () => {
     validatePurchaseWithIapticAPI: (jsonIapPurchase: {
         [key: string]: any;
     }, iapticAppId: string, iapticAppName: string, iapticPublicKey: string) => Promise<boolean>;
+    storeExpectedStoreTransaction: (purchaseToken: string) => Promise<void>;
+    returnUserAccountTokenAndStoreExpectedTransaction: () => Promise<string | null>;
     returnInsertAffiliateIdentifier: () => Promise<string | null>;
     trackEvent: (eventName: string) => Promise<void>;
     setShortCode: (shortCode: string) => Promise<void>;
-    setInsertAffiliateIdentifier: (referringLink: string) => Promise<void>;
+    setInsertAffiliateIdentifier: (referringLink: string) => Promise<void | string>;
     initialize: (code: string | null) => Promise<void>;
     isInitialized: boolean;
 };

package/dist/useDeepLinkIapProvider.js

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

package/package.json

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

@@ -71,6 +71,8 @@ const App = () => {
 Insert Affiliate requires a Receipt Verification platform to validate in-app purchases. You must choose **one** of our supported partners:
 - [RevenueCat](https://www.revenuecat.com/)
 - [Iaptic](https://www.iaptic.com/account)
+- [App Store Direct Integration](#app-store-direct-integration)
+- [Google Play Store Direct Integration](#google-play-store-direct-integration)
 
 ### Option 1: RevenueCat Integration
 #### Step 1. Code Setup
@@ -156,7 +158,7 @@ const Child = () => {
     // ***...***
     // Fetch & Load your subscription/purchases and handling the IAP purchase here as per the Iaptic Documentation...
     // ***...***
-    
+
     // Initialize the Insert Affiliate SDK at the earliest possible moment
     useEffect(() => {
         if (!isInitialized) {
@@ -164,7 +166,6 @@ const Child = () => {
         }
     }, [initialize, isInitialized]);
 
-
     // Validate the purchase with Iaptic through Insert Affiliate's SDK for Affiliate Tracking
     useEffect(() => {
         if (currentPurchase) {
@@ -211,22 +212,118 @@ export default App;
 - Replace `{{ your_iaptic_public_key }}` with your **Iaptic Public Key**. You can find this [here](https://www.iaptic.com/settings).
 - Replace `{{ your_company_code }}` with the unique company code associated with your Insert Affiliate account. You can find this code in your dashboard under [Settings](http://app.insertaffiliate.com/settings).
 
+### Option 3: App Store Direct Integration
+
+Our direct App Store integration is currently in beta and currently supports subscriptions only. **Consumables and one-off purchases are not yet supported** due to App Store server-to-server notification limitations.
+
+We plan to release support for consumables and one-off purchases soon. In the meantime, you can use a receipt verification platform from the other integration options.
+
+#### Apple App Store Notification Setup
+To proceed, visit [our docs](https://docs.insertaffiliate.com/direct-store-purchase-integration#1-apple-app-store-server-notifications) and complete the required setup steps to set up App Store Server to Server Notifications.
+
+#### Implementing Purchases
+
+##### 1. Import Required Modules  
+
+Ensure you import the necessary dependencies, including `Platform` and `useDeepLinkIapProvider` from the SDK.  
+
+```javascript
+import { Platform } from 'react-native';
+import { DeepLinkIapProvider, useDeepLinkIapProvider } from 'insert-affiliate-react-native-sdk';
+import { requestSubscription } from 'react-native-iap';
+
+const { returnUserAccountTokenAndStoreExpectedTransaction } = useDeepLinkIapProvider();
+```
+
+
+##### 2. Handle the Purchase
+When a user initiates a subscription, retrieve the appAccountToken and pass it to the requestSubscription call:
+
+```javascript
+const handleBuySubscription = async (product: SubscriptionAndroid | Subscription) => {
+    try {
+        let appAccountToken = null;
+
+        // Step 1: Retrieve the appAccountToken for iOS
+        if (Platform.OS === 'ios') {
+            appAccountToken = await returnUserAccountTokenAndStoreExpectedTransaction();
+        }
+
+        // Step 2: Request the subscription and pass the token for tracking
+        await requestSubscription({
+            sku: product?.productId,
+            ...(appAccountToken ? { applicationUsername: appAccountToken } : {}),
+        });
+
+    } catch (error) {
+        console.error("Error processing subscription:", error);
+    }
+};
+
+```
+
+
+### Option 4: Google Play Store Direct Integration
+Our direct Google Play Store integration is currently in beta.
+
+#### Real Time Developer Notifications (RTDN) Setup
+
+Visit [our docs](https://docs.insertaffiliate.com/direct-google-play-store-purchase-integration) and complete the required set up steps for Google Play's Real Time Developer Notifications.
+
+#### Implementing Purchases
+
+##### 1. Import Required Modules  
+
+Ensure you import the necessary dependencies, including `Platform` and `useDeepLinkIapProvider` from the SDK.  
+
+```javascript
+import React, {useEffect, useState} from 'react';
+import { Platform } from 'react-native';
+import { DeepLinkIapProvider, useDeepLinkIapProvider } from 'insert-affiliate-react-native-sdk';
+import { currentPurchase, requestSubscription } from 'react-native-iap';
+
+const { storeExpectedStoreTransaction } = useDeepLinkIapProvider();
+
+useEffect(() => {
+    if (currentPurchase) {
+        if (Platform.OS === 'android' && currentPurchase.purchaseToken) {
+            // Step 1: Store the expected transaction for Google Play purchases
+            storeExpectedStoreTransaction(
+              currentPurchase.purchaseToken
+            );
+        }
+    }
+}, [currentPurchase, storeExpectedStoreTransaction]);
+```
+
+
+
 ## Deep Link Setup [Required]
 
-### Step 1: Add the Deep Linking Platform Dependency
+Insert Affiliate requires a Deep Linking platform to create links for your affiliates. Our platform works with **any** deep linking provider, and you only need to follow these steps:
+1. **Create a deep link** in your chosen third-party platform and pass it to our dashboard when an affiliate signs up. 
+2. **Handle deep link clicks** in your app by passing the clicked link:
+   ```javascript
+   await setInsertAffiliateIdentifier(referringLink)
+   ```
+3. **Integrate with a Receipt Verification platform** by using the result from `setInsertAffiliateIdentifier` to log in or set your application’s username. Examples below include [**Iaptic**](https://github.com/Insert-Affiliate/InsertAffiliateReactNativeSDK?tab=readme-ov-file#example-with-iaptic) and [**RevenueCat**](https://github.com/Insert-Affiliate/InsertAffiliateReactNativeSDK?tab=readme-ov-file#example-with-revenuecat)
 
-In this example, the deep linking functionality is implemented using [Branch.io](https://dashboard.branch.io/).
+### Deep Linking with Branch.io
+To set up deep linking with Branch.io, follow these steps:
 
-Any alternative deep linking platform can be used by passing the referring link to ```InsertAffiliateSwift.setInsertAffiliateIdentifier(referringLink: "{{ link }}")``` as in the below Branch.io example
+1. Create a deep link in Branch and pass it to our dashboard when an affiliate signs up.
+  - Example: [Create Affiliate](https://docs.insertaffiliate.com/create-affiliate).
+2. Modify Your Deep Link Handling in `App.tsx`
+    - After setting up your Branch integration, add the following code to initialise our SDK in your app:
 
-After setting up your Branch integration, add the following code to your ```App.tsx```
 
 #### Example with RevenueCat
 ```javascript
+import { DeepLinkIapProvider, useDeepLinkIapProvider } from 'insert-affiliate-react-native-sdk';
 import { useDeepLinkIapProvider } from 'insert-affiliate-react-native-sdk';
 
 //...
-    const {setInsertAffiliateIdentifier, returnInsertAffiliateIdentifier} = useDeepLinkIapProvider();
+    const {setInsertAffiliateIdentifier} = useDeepLinkIapProvider();
     
     useEffect(() => {
       if (!isInitialized) return;
@@ -244,9 +341,8 @@ import { useDeepLinkIapProvider } from 'insert-affiliate-react-native-sdk';
           const referringLink = params['~referring_link'];
           if (referringLink) {
             try {
-              await setInsertAffiliateIdentifier(referringLink);
+             let insertAffiliateIdentifier = await setInsertAffiliateIdentifier(referringLink);
 
-              let insertAffiliateIdentifier = await returnInsertAffiliateIdentifier();
               if (insertAffiliateIdentifier) {
                 const { customerInfo, created } = await Purchases.logIn(insertAffiliateIdentifier);
               }
@@ -266,10 +362,11 @@ import { useDeepLinkIapProvider } from 'insert-affiliate-react-native-sdk';
 //...
 ```
 
-#### Example with Iaptic
+#### Example with Iaptic / App Store Direct Integration / Google Play Direct Integration
 ```javascript
 import branch from 'react-native-branch';
 import { DeepLinkIapProvider, useDeepLinkIapProvider } from 'insert-affiliate-react-native-sdk';
+const {setInsertAffiliateIdentifier} = useDeepLinkIapProvider();
 
 branch.subscribe(async ({ error, params }) => {
     if (error) {

package/src/DeepLinkIapProvider.tsx

@@ -1,7 +1,7 @@
-import React, { createContext, useEffect, useState } from "react";
-import { Platform } from "react-native";
-import axios from "axios";
-import AsyncStorage from "@react-native-async-storage/async-storage";
+import React, { createContext, useEffect, useState } from 'react';
+import { Platform } from 'react-native';
+import axios from 'axios';
+import AsyncStorage from '@react-native-async-storage/async-storage';
 
 // TYPES USED IN THIS PROVIDER
 type T_DEEPLINK_IAP_PROVIDER = {
@@ -22,9 +22,15 @@ type T_DEEPLINK_IAP_CONTEXT = {
     iapticAppName: string,
     iapticPublicKey: string
   ) => Promise<boolean>;
+  returnUserAccountTokenAndStoreExpectedTransaction: () => Promise<string | null>;
+  storeExpectedStoreTransaction: (
+    purchaseToken: string
+  ) => Promise<void>;
   trackEvent: (eventName: string) => Promise<void>;
   setShortCode: (shortCode: string) => Promise<void>;
-  setInsertAffiliateIdentifier: (referringLink: string) => Promise<void>;
+  setInsertAffiliateIdentifier: (
+    referringLink: string
+  ) => Promise<void | string>;
   initialize: (code: string | null) => Promise<void>;
   isInitialized: boolean;
 };
@@ -46,52 +52,59 @@ type RequestBody = {
 };
 
 const ASYNC_KEYS = {
-  REFERRER_LINK: "@app_referrer_link",
-  USER_PURCHASE: "@app_user_purchase",
-  USER_ID: "@app_user_id",
-  COMPANY_CODE: "@app_company_code",
+  REFERRER_LINK: '@app_referrer_link',
+  USER_PURCHASE: '@app_user_purchase',
+  USER_ID: '@app_user_id',
+  COMPANY_CODE: '@app_company_code',
+  USER_ACCOUNT_TOKEN: '@app_user_account_token',
 };
 
 // STARTING CONTEXT IMPLEMENTATION
 export const DeepLinkIapContext = createContext<T_DEEPLINK_IAP_CONTEXT>({
-  referrerLink: "",
-  userId: "",
-  returnInsertAffiliateIdentifier: async () => "",
+  referrerLink: '',
+  userId: '',
+  returnInsertAffiliateIdentifier: async () => '',
   validatePurchaseWithIapticAPI: async (
     jsonIapPurchase: CustomPurchase,
     iapticAppId: string,
     iapticAppName: string,
     iapticPublicKey: string
   ) => false,
+  returnUserAccountTokenAndStoreExpectedTransaction: async () => '',
+  storeExpectedStoreTransaction: async (purchaseToken: string) => {},
   trackEvent: async (eventName: string) => {},
   setShortCode: async (shortCode: string) => {},
   setInsertAffiliateIdentifier: async (referringLink: string) => {},
   initialize: async (code: string | null) => {},
-  isInitialized: false
+  isInitialized: false,
 });
 
 const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
   children,
 }) => {
-  const [referrerLink, setReferrerLink] = useState<string>("");
-  const [userId, setUserId] = useState<string>("");
+  const [referrerLink, setReferrerLink] = useState<string>('');
+  const [userId, setUserId] = useState<string>('');
   const [companyCode, setCompanyCode] = useState<string | null>(null);
   const [isInitialized, setIsInitialized] = useState<boolean>(false);
 
   // MARK: Initialize the SDK
   const initialize = async (companyCode: string | null): Promise<void> => {
     if (isInitialized) {
-      console.error("[Insert Affiliate] SDK is already initialized.");
+      console.error('[Insert Affiliate] SDK is already initialized.');
       return;
     }
-  
-    if (companyCode && companyCode.trim() !== "") {
+
+    if (companyCode && companyCode.trim() !== '') {
       setCompanyCode(companyCode);
       await saveValueInAsync(ASYNC_KEYS.COMPANY_CODE, companyCode);
       setIsInitialized(true);
-      console.log(`[Insert Affiliate] SDK initialized with company code: ${companyCode}`);
+      console.log(
+        `[Insert Affiliate] SDK initialized with company code: ${companyCode}`
+      );
     } else {
-      console.warn("[Insert Affiliate] SDK initialized without a company code.");
+      console.warn(
+        '[Insert Affiliate] SDK initialized without a company code.'
+      );
       setIsInitialized(true);
     }
   };
@@ -120,15 +133,19 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
     let userId = await getValueFromAsync(ASYNC_KEYS.USER_ID);
     if (!userId) {
       userId = generateUserID();
+      setUserId(userId);
       await saveValueInAsync(ASYNC_KEYS.USER_ID, userId);
+    } else {
       setUserId(userId);
     }
+
+    return userId;
   }
 
   const generateUserID = () => {
     const characters =
-      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-    let uniqueId = "";
+      'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let uniqueId = '';
     for (let i = 0; i < 6; i++) {
       const randomIndex = Math.floor(Math.random() * characters.length);
       uniqueId += characters[randomIndex];
@@ -139,7 +156,7 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
   const reset = (): void => {
     setCompanyCode(null);
     setIsInitialized(false);
-    console.log("[Insert Affiliate] SDK has been reset.");
+    console.log('[Insert Affiliate] SDK has been reset.');
   };
 
   // Helper funciton Storage / Retrieval
@@ -157,12 +174,12 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
   };
 
   // Helper function to log errors
-  const errorLog = (message: string, type?: "error" | "warn" | "log") => {
+  const errorLog = (message: string, type?: 'error' | 'warn' | 'log') => {
     switch (type) {
-      case "error":
+      case 'error':
         console.error(`ENCOUNTER ERROR ~ ${message}`);
         break;
-      case "warn":
+      case 'warn':
         console.warn(`ENCOUNTER WARNING ~ ${message}`);
         break;
       default:
@@ -171,7 +188,6 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
     }
   };
 
-
   // MARK: Short Codes
   const isShortCode = (referringLink: string): boolean => {
     // Short codes are less than 10 characters
@@ -180,8 +196,8 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
   };
 
   async function setShortCode(shortCode: string): Promise<void> {
-    console.log("[Insert Affiliate] Setting short code.");
-    generateThenSetUserID();
+    console.log('[Insert Affiliate] Setting short code.');
+    await generateThenSetUserID();
 
     // Validate it is a short code
     const capitalisedShortCode = shortCode.toUpperCase();
@@ -191,6 +207,41 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
     await storeInsertAffiliateIdentifier({ link: capitalisedShortCode });
   }
 
+  async function getOrCreateUserAccountToken(): Promise<string> {
+    let userAccountToken = await getValueFromAsync(ASYNC_KEYS.USER_ACCOUNT_TOKEN);
+
+    if (!userAccountToken) {
+      userAccountToken = UUID();
+      await saveValueInAsync(ASYNC_KEYS.USER_ACCOUNT_TOKEN, userAccountToken);
+    }
+
+    return userAccountToken;
+  };
+
+  const returnUserAccountTokenAndStoreExpectedTransaction = async (): Promise<string | null> => {
+    try {
+      const shortCode = await returnInsertAffiliateIdentifier();
+      if (!shortCode) {
+        console.log('[Insert Affiliate] No affiliate stored - not saving expected transaction.');
+        return null;
+      }
+
+      const userAccountToken = await getOrCreateUserAccountToken();
+      console.log('[Insert Affiliate] User account token:', userAccountToken);
+
+      if (!userAccountToken) {
+        console.error('[Insert Affiliate] Failed to generate user account token.');
+        return null;
+      } else {
+        await storeExpectedStoreTransaction(userAccountToken);
+        return userAccountToken;
+      }
+    } catch (error) {
+      console.error('[Insert Affiliate] Error in returnUserAccountTokenAndStoreExpectedTransaction:', error);
+      return null;
+    };
+  };
+
   // MARK: Return Insert Affiliate Identifier
   const returnInsertAffiliateIdentifier = async (): Promise<string | null> => {
     try {
@@ -199,80 +250,93 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
       errorLog(`ERROR ~ returnInsertAffiliateIdentifier: ${error}`);
       return null;
     }
-  }
-  
+  };
 
   // MARK: Insert Affiliate Identifier
 
-  async function setInsertAffiliateIdentifier(referringLink: string): Promise<void> {
-    console.log("[Insert Affiliate] Setting affiliate identifier.");
+  async function setInsertAffiliateIdentifier(
+    referringLink: string
+  ): Promise<void | string> {
+    console.log('[Insert Affiliate] Setting affiliate identifier.');
 
     try {
-      await generateThenSetUserID();
-      console.log("[Insert Affiliate] Completed generateThenSetUserID within setInsertAffiliateIdentifier.");
+      const customerID = await generateThenSetUserID();
+      console.log(
+        '[Insert Affiliate] Completed generateThenSetUserID within setInsertAffiliateIdentifier.'
+      );
 
       if (!referringLink) {
-        console.warn("[Insert Affiliate] Referring link is invalid.");
+        console.warn('[Insert Affiliate] Referring link is invalid.');
+        let heldReferrerLinkBeforeAsyncStateUpdate = referrerLink;
         await storeInsertAffiliateIdentifier({ link: referringLink });
-        return;
+        return `${heldReferrerLinkBeforeAsyncStateUpdate}-${customerID}`;
       }
-      
-      if (!companyCode || companyCode.trim() === "" && companyCode !== null) {
-        let companyCodeFromStorage = await getValueFromAsync(ASYNC_KEYS.COMPANY_CODE);
+
+      if (!companyCode || (companyCode.trim() === '' && companyCode !== null)) {
+        let companyCodeFromStorage = await getValueFromAsync(
+          ASYNC_KEYS.COMPANY_CODE
+        );
 
         if (companyCodeFromStorage !== null) {
           setCompanyCode(companyCodeFromStorage);
         } else {
           console.error(
-            "[Insert Affiliate] Company code is not set. Please initialize the SDK with a valid company code."
+            '[Insert Affiliate] Company code is not set. Please initialize the SDK with a valid company code.'
           );
           return;
         }
       }
-  
+
       // Check if referring link is already a short code, if so save it and stop here.
       if (isShortCode(referringLink)) {
-        console.log("[Insert Affiliate] Referring link is already a short code.");
+        console.log(
+          '[Insert Affiliate] Referring link is already a short code.'
+        );
+        let heldReferrerLinkBeforeAsyncStateUpdate = referrerLink;
         await storeInsertAffiliateIdentifier({ link: referringLink });
-        return;
+        return `${heldReferrerLinkBeforeAsyncStateUpdate}-${customerID}`;
       }
-  
+
       // If the code is not already a short code, encode it raedy to send to our endpoint to return the short code. Save it before making the call in case something goes wrong
       // Encode the referring link
       const encodedAffiliateLink = encodeURIComponent(referringLink);
       if (!encodedAffiliateLink) {
-        console.error("[Insert Affiliate] Failed to encode affiliate link.");
+        console.error('[Insert Affiliate] Failed to encode affiliate link.');
+
+        let heldReferrerLinkBeforeAsyncStateUpdate = referrerLink;
         await storeInsertAffiliateIdentifier({ link: referringLink });
-        return;
+        return `${heldReferrerLinkBeforeAsyncStateUpdate}-${customerID}`;
       }
-  
+
       // Create the request URL
       const urlString = `https://api.insertaffiliate.com/V1/convert-deep-link-to-short-link?companyId=${companyCode}&deepLinkUrl=${encodedAffiliateLink}`;
-      console.log("[Insert Affiliate] urlString .", urlString);
+      console.log('[Insert Affiliate] urlString .', urlString);
       const response = await axios.get(urlString, {
         headers: {
-          "Content-Type": "application/json",
+          'Content-Type': 'application/json',
         },
       });
-  
+
       // Call to the backend for the short code and save the resolse in valid
       if (response.status === 200 && response.data.shortLink) {
         const shortLink = response.data.shortLink;
-        console.log("[Insert Affiliate] Short link received:", shortLink);
-        await storeInsertAffiliateIdentifier({ link: shortLink });
+        console.log('[Insert Affiliate] Short link received:', shortLink);
+        return `${shortLink}-${customerID}`;
       } else {
-        console.warn("[Insert Affiliate] Unexpected response format.");
+        console.warn('[Insert Affiliate] Unexpected response format.');
+        let heldReferrerLinkBeforeAsyncStateUpdate = referrerLink;
         await storeInsertAffiliateIdentifier({ link: referringLink });
+        return `${heldReferrerLinkBeforeAsyncStateUpdate}-${customerID}`;
       }
     } catch (error) {
-      console.error("[Insert Affiliate] Error:", error);
+      console.error('[Insert Affiliate] Error:', error);
     }
   };
   
   async function storeInsertAffiliateIdentifier({ link }: { link: string }) {
     console.log(`[Insert Affiliate] Storing affiliate identifier: ${link}`);
-    await saveValueInAsync(ASYNC_KEYS.REFERRER_LINK, link);
     setReferrerLink(link);
+    await saveValueInAsync(ASYNC_KEYS.REFERRER_LINK, link);
   }
 
   const validatePurchaseWithIapticAPI = async (
@@ -284,22 +348,24 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
     try {
       const baseRequestBody: RequestBody = {
         id: iapticAppId,
-        type: "application",
+        type: 'application',
       };
-  
+
       let transaction;
 
-      if (Platform.OS === "ios") {
+      if (Platform.OS === 'ios') {
         transaction = {
           id: iapticAppId,
-          type: "ios-appstore",
+          type: 'ios-appstore',
           appStoreReceipt: jsonIapPurchase.transactionReceipt,
         };
       } else {
-        const receiptJson = JSON.parse(atob(jsonIapPurchase.transactionReceipt || ""));
+        const receiptJson = JSON.parse(
+          atob(jsonIapPurchase.transactionReceipt || '')
+        );
         transaction = {
           id: receiptJson.orderId, // Extracted orderId
-          type: "android-playstore",
+          type: 'android-playstore',
           purchaseToken: receiptJson.purchaseToken, // Extracted purchase token
           receipt: jsonIapPurchase.transactionReceipt, // Full receipt (Base64)
           signature: receiptJson.signature, // Receipt signature
@@ -318,43 +384,88 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
           applicationUsername: `${insertAffiliateIdentifier}`,
         };
       }
-  
+
       // Send validation request to server
       const response = await axios({
         url: `https://validator.iaptic.com/v1/validate`,
-        method: "POST",
+        method: 'POST',
         headers: {
           Authorization: `Basic ${btoa(`${iapticAppName}:${iapticPublicKey}`)}`,
-          "Content-Type": "application/json",
+          'Content-Type': 'application/json',
         },
         data: requestBody,
       });
-  
+
       if (response.status === 200) {
-        console.log("Validation successful:", response.data);
+        console.log('Validation successful:', response.data);
         return true;
       } else {
-        console.error("Validation failed:", response.data);
+        console.error('Validation failed:', response.data);
         return false;
       }
     } catch (error) {
       if (error instanceof Error) {
         console.error(`validatePurchaseWithIapticAPI Error: ${error.message}`);
       } else {
-        console.error(`validatePurchaseWithIapticAPI Unknown Error: ${JSON.stringify(error)}`);
+        console.error(
+          `validatePurchaseWithIapticAPI Unknown Error: ${JSON.stringify(
+            error
+          )}`
+        );
       }
 
       return false;
     }
   };
-  
 
-  // MARK: Track Event 
+  const storeExpectedStoreTransaction = async (purchaseToken: string): Promise<void> => {
+    if (!companyCode || (companyCode.trim() === '' && companyCode !== null)) {
+      console.error("[Insert Affiliate] Company code is not set. Please initialize the SDK with a valid company code.");
+      return;
+    }
+
+    const shortCode = await returnInsertAffiliateIdentifier();
+    if (!shortCode) {
+      console.error("[Insert Affiliate] No affiliate identifier found. Please set one before tracking events.");
+      return;
+    }
+
+    // Build JSON payload
+    const payload = {
+      UUID: purchaseToken,
+      companyCode,
+      shortCode,
+      storedDate: new Date().toISOString(), // ISO8601 format
+    };
+
+    console.log("[Insert Affiliate] Storing expected transaction: ", payload);
+
+    try {
+      const response = await fetch("https://api.insertaffiliate.com/v1/api/app-store-webhook/create-expected-transaction", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(payload),
+      });
+
+      if (response.ok) {
+        console.info("[Insert Affiliate] Expected transaction stored successfully.");
+      } else {
+        const errorText = await response.text();
+        console.error(`[Insert Affiliate] Failed to store expected transaction with status code: ${response.status}. Response: ${errorText}`);
+      }
+    } catch (error) {
+      console.error(`[Insert Affiliate] Error storing expected transaction: ${error}`);
+    }
+  };
+
+  // MARK: Track Event
   const trackEvent = async (eventName: string): Promise<void> => {
     try {
       if (!referrerLink || !userId) {
         console.warn(
-          "[Insert Affiliate] No affiliate identifier found. Please set one before tracking events."
+          '[Insert Affiliate] No affiliate identifier found. Please set one before tracking events.'
         );
         return Promise.resolve();
       }
@@ -365,22 +476,22 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
       };
 
       const response = await axios.post(
-        "https://api.insertaffiliate.com/v1/trackEvent",
+        'https://api.insertaffiliate.com/v1/trackEvent',
         payload,
         {
-          headers: { "Content-Type": "application/json" },
+          headers: { 'Content-Type': 'application/json' },
         }
       );
 
       if (response.status === 200) {
-        console.log("[Insert Affiliate] Event tracked successfully");
+        console.log('[Insert Affiliate] Event tracked successfully');
       } else {
         console.error(
           `[Insert Affiliate] Failed to track event with status code: ${response.status}`
         );
       }
     } catch (error) {
-      console.error("[Insert Affiliate] Error tracking event:", error);
+      console.error('[Insert Affiliate] Error tracking event:', error);
       return Promise.reject(error);
     }
   };
@@ -392,11 +503,13 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
         userId,
         setShortCode,
         returnInsertAffiliateIdentifier,
+        storeExpectedStoreTransaction,
+        returnUserAccountTokenAndStoreExpectedTransaction,
         validatePurchaseWithIapticAPI,
         trackEvent,
         setInsertAffiliateIdentifier,
         initialize,
-        isInitialized
+        isInitialized,
       }}
     >
       {children}
@@ -405,3 +518,12 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
 };
 
 export default DeepLinkIapProvider;
+  function UUID(): string {
+    // Generate a random UUID (version 4)
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+      const r = (Math.random() * 16) | 0,
+        v = c === 'x' ? r : (r & 0x3) | 0x8;
+      return v.toString(16);
+    });
+  }
+

package/src/useDeepLinkIapProvider.tsx

@@ -6,6 +6,8 @@ const useDeepLinkIapProvider = () => {
     referrerLink,
     userId,
     validatePurchaseWithIapticAPI,
+    storeExpectedStoreTransaction,
+    returnUserAccountTokenAndStoreExpectedTransaction,
     returnInsertAffiliateIdentifier,
     trackEvent,
     setShortCode,
@@ -18,6 +20,8 @@ const useDeepLinkIapProvider = () => {
     referrerLink,
     userId,
     validatePurchaseWithIapticAPI,
+    storeExpectedStoreTransaction,
+    returnUserAccountTokenAndStoreExpectedTransaction,
     returnInsertAffiliateIdentifier,
     trackEvent,
     setShortCode,