insert-affiliate-js-sdk 1.0.0

package/README.md

@@ -0,0 +1,208 @@
+# Insert Affiliate JavaScript SDK
+
+## Overview
+
+The **Insert Affiliate JavaScript SDK** brings affiliate tracking to web and hybrid applications, providing seamless integration with the [Insert Affiliate platform](https://insertaffiliate.com). It is fully compatible with Capacitor, making it a great choice for modern cross-platform apps that require affiliate attribution and purchase tracking support.
+
+This SDK is ideal for developers who want to integrate affiliate marketing into their app's monetisation strategy and track purchases via partners like RevenueCat.
+
+### Features
+
+- **Unique Device ID**: Creates a unique ID to anonymously associate purchases with users for tracking purposes.
+- **Affiliate Identifier Management**: Set and retrieve the affiliate identifier based on user-specific links or short codes.
+- **Short Code Support (Beta)**: Allow users to enter affiliate short codes for tracking.
+
+### Supported Platforms
+- ✅ Capacitor (iOS / Android) – Fully tested
+- ✅ Web Browsers – Tested in modern desktop and mobile browsers
+- ⚠️ Other JavaScript Environments – May work, but not officially tested
+
+## Getting Started
+To get started with the Insert Affiliate JavaScript SDK:
+
+1. [Install the SDK via NPM](#installation)
+2. [Initialise the SDK in your Main Javascript/Typescript File](#basic-usage)
+3. [Set up in-app purchases (Required)](#in-app-purchase-setup-required)
+4. [Set up deep linking (Required)](#deep-link-setup-required)
+5. [Use additional features like short codes and event tracking.](#additional-features)
+
+
+## Installation
+
+Install the Insert Affiliate JavaScript SDK and required plugins:
+
+```bash
+npm install insert-affiliate-js-sdk
+```
+
+Then run
+```bash
+npx cap sync
+```
+
+## Basic Usage
+### Import the SDKs
+
+In your ```main.ts``` or ```main.js``` file:
+
+```javascript
+import { InsertAffiliate } from 'insert-affiliate-js-sdk';
+await InsertAffiliate.initialize("your_company_code");
+
+```
+- 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).
+
+## In-App Purchase Setup [Required]
+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/)
+
+### Option 1: RevenueCat Integration
+
+#### Code Setup
+1. **Install RevenueCat SDK** - First, complete the set up of the relevant [RevenueCat SDK](https://www.revenuecat.com/docs/getting-started/installation) to set up in-app purchases and subscriptions.
+
+2. **Modify Initialisation Code** - Update the file where you initialise your deep linking (e.g., Branch.io) and RevenueCat to include a call to ```InsertAffiliate.returnInsertAffiliateIdentifier()```. This ensures that the Insert Affiliate identifier is passed to RevenueCat every time the app starts or a deep link is clicked.
+
+3. **Implementation Example**
+
+```javascript
+import { InsertAffiliate } from 'insert-affiliate-js-sdk';
+import { Purchases } from '@revenuecat/purchases-capacitor';
+
+window.addEventListener('DOMContentLoaded', async () => {
+    await Purchases.configure({ apiKey: 'your_revcat_api_key' });
+    
+    const affiliateIdentifier = await InsertAffiliate.returnInsertAffiliateIdentifier();
+    
+    if (affiliateIdentifier) {
+        await Purchases.setAttributes({ insert_affiliate: affiliateIdentifier });
+    }
+});
+```
+
+#### Webhook Setup
+
+Next, you must setup a webhook to allow us to communicate directly with RevenueCat to track affiliate purchases.
+
+1. Go to RevenueCat and [create a new webhook](https://www.revenuecat.com/docs/integrations/webhooks)
+
+2. Configure the webhook with these settings:
+   - Webhook URL: `https://api.insertaffiliate.com/v1/api/revenuecat-webhook`
+   - Authorization header: Use the value from your Insert Affiliate dashboard (you'll get this in step 4)
+   - Set "Event Type" to "All events"
+
+3. In your [Insert Affiliate dashboard settings](https://app.insertaffiliate.com/settings):
+   - Navigate to the verification settings
+   - Set the in-app purchase verification method to `RevenueCat`
+
+4. Back in your Insert Affiliate dashboard:
+   - Locate the `RevenueCat Webhook Authentication Header` value
+   - Copy this value
+   - Paste it as the Authorization header value in your RevenueCat webhook configuration
+
+
+## Deep Link Setup [Required]
+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
+   InsertAffiliate.setInsertAffiliateIdentifier(data["~referring_link"]);
+   ```
+
+### Deep Linking with Branch.io
+To set up deep linking with Branch.io, follow these steps:
+
+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
+    - After setting up your Branch integration, add the following code to initialise the Insert Affiliate SDK in your iOS app:
+
+
+```javascript
+import { BranchDeepLinks, BranchInitEvent } from 'capacitor-branch-deep-links';
+import { InsertAffiliate } from 'insert-affiliate-js-sdk';
+
+let branchInitialised = false;
+
+async function setUpBranchListener() {
+    if (branchInitialised) return;
+    branchInitialised = true;
+    
+    try {
+        await BranchDeepLinks.addListener('init', async (event: BranchInitEvent) => {
+            const clicked = event?.referringParams?.['+clicked_branch_link'];
+            const referringLink = event?.referringParams?.['~referring_link'];
+            
+            if (clicked && referringLink) {
+                await InsertAffiliate.setInsertAffiliateIdentifier(referringLink);
+            }
+        });
+        
+        BranchDeepLinks.addListener('initError', (error: any) => {
+            console.error('Branch init error:', error);
+        });
+    } catch (err) {
+        console.error('Error setting up Branch listener:', err);
+    }
+}
+
+```
+
+## Additional Features
+
+### 1. Event Tracking (Beta)
+
+Insert Affiliate now includes a beta feature for event tracking. Use event tracking to log key user actions such as signups, purchases, or referrals. This is useful for:
+- Understanding user behaviour.
+- Measuring the effectiveness of marketing campaigns.
+- Incentivising affiliates for designated actions being taken by the end users, rather than just in app purchases (i.e. pay an affilaite for each signup).
+
+At this stage, we cannot guarantee that this feature is fully resistant to tampering or manipulation.
+
+#### Using `trackEvent`
+
+To track an event, use the `trackEvent` function. Make sure to set an affiliate identifier first; otherwise, event tracking won’t work. Here’s an example:
+
+```javascript
+import { InsertAffiliate } from 'insert-affiliate-js-sdk';
+
+async function trackSignupEvent() {
+    try {
+        await InsertAffiliate.trackEvent('your_event_name_here');
+    } catch (error) {
+        console.error('❌ Failed to track event:', error);
+    }
+}
+```
+
+### 2. Short Codes (Beta)
+
+### What are Short Codes?
+
+Short codes are unique, 10-character alphanumeric identifiers that affiliates can use to promote products or subscriptions. These codes are ideal for influencers or partners, making them easier to share than long URLs.
+
+**Example Use Case**: An influencer promotes a subscription with the short code "JOIN123456" within their TikTok video's description. When users enter this code within your app during sign-up or before purchase, the app tracks the subscription back to the influencer for commission payouts.
+
+For more information, visit the [Insert Affiliate Short Codes Documentation](https://docs.insertaffiliate.com/short-codes).
+
+### Setting a Short Code
+
+Use the `setShortCode` method to associate a short code with an affiliate. This is ideal for scenarios where users enter the code via an input field, pop-up, or similar UI element.
+
+Short codes must meet the following criteria:
+- Exactly **10 characters long**.
+- Contain only **letters and numbers** (alphanumeric characters).
+- Replace {{ user_entered_short_code }} with the short code the user enters through your chosen input method, i.e. an input field / pop up element
+
+
+#### Example Integration
+Below is an example SwiftUI implementation where users can enter a short code, which will be validated and associated with the affiliate's account:
+
+```javascript
+import { InsertAffiliate } from 'insert-affiliate-js-sdk';
+
+// Example: user entered this in a form
+const userEnteredCode = 'B3SC6VRRKQ';
+
+InsertAffiliate.setShortCode(userEnteredCode);
+```

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+interface IapticIOSReceipt {
+    transactionReceipt: string;
+}
+declare class InsertAffiliate {
+    private static isInitialized;
+    private static companyCode;
+    static initialize(code: string | null): Promise<void>;
+    static returnInsertAffiliateIdentifier(): Promise<string | null>;
+    static setInsertAffiliateIdentifier(referringLink: string): Promise<string | null>;
+    static setShortCode(shortCode: string): Promise<void>;
+    static trackEvent(eventName: string): Promise<void>;
+    static returnUserAccountTokenAndStoreExpectedTransaction(): Promise<string | null>;
+    static storeExpectedStoreTransaction(userAccountToken: string): Promise<void>;
+    static validatePurchaseWithIapticAPI(jsonIapPurchase: IapticIOSReceipt | {
+        transactionReceipt: string;
+    }, iapticAppId: string, iapticAppName: string, iapticPublicKey: string): Promise<boolean>;
+    static fetchAndConditionallyOpenUrl(affiliateLink: string, offerCodeUrlId: string): Promise<void>;
+    private static getOrCreateUserID;
+    private static fetchShortLink;
+}
+
+export { InsertAffiliate };

package/dist/index.js

@@ -0,0 +1,256 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  InsertAffiliate: () => InsertAffiliate
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/utils/asyncStorage.ts
+var saveValue = async (key, value) => {
+  localStorage.setItem(key, value);
+};
+var getValue = async (key) => {
+  return localStorage.getItem(key);
+};
+
+// src/utils/helpers.ts
+var generateShortDeviceID = () => {
+  const hashed = Math.abs(generateUUID().hashCode()) % 16777215;
+  return hashed.toString(16).padStart(6, "0").toUpperCase();
+};
+var generateUUID = () => {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.floor(Math.random() * 16);
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+};
+if (!String.prototype.hasOwnProperty("hashCode")) {
+  String.prototype.hashCode = function() {
+    let hash = 0;
+    for (let i = 0; i < this.length; i++) {
+      const chr = this.charCodeAt(i);
+      hash = (hash << 5) - hash + chr;
+      hash |= 0;
+    }
+    return hash;
+  };
+}
+
+// src/sdk/InsertAffiliate.ts
+var InsertAffiliate = class {
+  static async initialize(code) {
+    if (this.isInitialized) {
+      console.warn("[Insert Affiliate] SDK already initialized.");
+      return;
+    }
+    this.companyCode = code;
+    await saveValue("companyCode", code || "");
+    this.isInitialized = true;
+    console.log(`[Insert Affiliate] SDK initialized ${code ? `with company code: ${code}` : "without a company code."}`);
+  }
+  static async returnInsertAffiliateIdentifier() {
+    const userId = await this.getOrCreateUserID();
+    const referrerLink = await getValue("referrerLink");
+    if (!referrerLink) return null;
+    return `${referrerLink}-${userId}`;
+  }
+  static async setInsertAffiliateIdentifier(referringLink) {
+    const userId = await this.getOrCreateUserID();
+    const shortCode = /^[a-zA-Z0-9]{10}$/.test(referringLink) ? referringLink : await this.fetchShortLink(referringLink);
+    if (!shortCode) return null;
+    await saveValue("referrerLink", shortCode);
+    return `${shortCode}-${userId}`;
+  }
+  static async setShortCode(shortCode) {
+    const valid = /^[a-zA-Z0-9]{10}$/.test(shortCode);
+    if (!valid) {
+      console.warn("[Insert Affiliate] Invalid short code.");
+      return;
+    }
+    await this.setInsertAffiliateIdentifier(shortCode);
+  }
+  static async trackEvent(eventName) {
+    const id = await this.returnInsertAffiliateIdentifier();
+    if (!id) {
+      console.warn("[Insert Affiliate] No affiliate identifier found.");
+      return;
+    }
+    try {
+      await fetch("https://api.insertaffiliate.com/v1/trackEvent", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ eventName, deepLinkParam: id })
+      });
+      console.log("[Insert Affiliate] Event tracked:", eventName);
+    } catch (err) {
+      console.error("[Insert Affiliate] Failed to track event:", err);
+    }
+  }
+  static async returnUserAccountTokenAndStoreExpectedTransaction() {
+    const shortCode = await this.returnInsertAffiliateIdentifier();
+    if (!shortCode) return null;
+    let token = await getValue("userAccountToken");
+    if (!token) {
+      token = generateUUID();
+      await saveValue("userAccountToken", token);
+    }
+    await this.storeExpectedStoreTransaction(token);
+    return token;
+  }
+  static async storeExpectedStoreTransaction(userAccountToken) {
+    const companyCode = this.companyCode || await getValue("companyCode");
+    const shortCode = await this.returnInsertAffiliateIdentifier();
+    if (!companyCode || !shortCode) {
+      console.error("[Insert Affiliate] Missing company code or identifier.");
+      return;
+    }
+    const payload = {
+      UUID: userAccountToken,
+      companyCode,
+      shortCode,
+      storedDate: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    try {
+      const res = 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 (res.status === 200) {
+        console.log("[Insert Affiliate] Stored expected transaction");
+      } else {
+        console.warn("[Insert Affiliate] Failed storing transaction:", res.status);
+      }
+    } catch (error) {
+      console.error("[Insert Affiliate] Error storing transaction:", error);
+    }
+  }
+  static async validatePurchaseWithIapticAPI(jsonIapPurchase, iapticAppId, iapticAppName, iapticPublicKey) {
+    try {
+      const isIOS = typeof window !== "undefined" && /iPad|iPhone|iPod/.test(navigator.userAgent);
+      const baseRequest = {
+        id: iapticAppId,
+        type: "application"
+      };
+      let transaction;
+      if (isIOS) {
+        transaction = {
+          id: iapticAppId,
+          type: "ios-appstore",
+          appStoreReceipt: jsonIapPurchase.transactionReceipt
+        };
+      } else {
+        const receiptJson = JSON.parse(atob(jsonIapPurchase.transactionReceipt));
+        transaction = {
+          id: receiptJson.orderId,
+          type: "android-playstore",
+          purchaseToken: receiptJson.purchaseToken,
+          receipt: jsonIapPurchase.transactionReceipt,
+          signature: receiptJson.signature
+        };
+      }
+      const insertAffiliateIdentifier = await this.returnInsertAffiliateIdentifier();
+      const payload = __spreadProps(__spreadValues({}, baseRequest), {
+        transaction,
+        additionalData: insertAffiliateIdentifier ? { applicationUsername: insertAffiliateIdentifier } : void 0
+      });
+      const response = await fetch("https://validator.iaptic.com/v1/validate", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Basic ${btoa(`${iapticAppName}:${iapticPublicKey}`)}`
+        },
+        body: JSON.stringify(payload)
+      });
+      return response.status === 200;
+    } catch (error) {
+      console.error("[Insert Affiliate] Purchase validation failed:", error);
+      return false;
+    }
+  }
+  static async fetchAndConditionallyOpenUrl(affiliateLink, offerCodeUrlId) {
+    const encoded = encodeURIComponent(affiliateLink);
+    try {
+      const res = await fetch(`https://api.insertaffiliate.com/v1/affiliateReturnOfferCode/${encoded}`);
+      const offerCode = (await res.text()).replace(/[^a-zA-Z0-9]/g, "");
+      const errorCodes = [
+        "errorofferCodeNotFound",
+        "errorAffiliateoffercodenotfoundinanycompany",
+        "errorAffiliateoffercodenotfoundinanycompanyAffiliatelinkwas",
+        "Routenotfound"
+      ];
+      if (errorCodes.includes(offerCode)) {
+        console.warn("[Insert Affiliate] Offer Code Not Found");
+        return;
+      }
+      const redeemUrl = `https://apps.apple.com/redeem?ctx=offercodes&id=${offerCodeUrlId}&code=${offerCode}`;
+      window.open(redeemUrl, "_blank");
+    } catch (err) {
+      console.error("[Insert Affiliate] Error fetching/opening offer code:", err);
+    }
+  }
+  static async getOrCreateUserID() {
+    let id = await getValue("userId");
+    if (!id) {
+      id = generateShortDeviceID();
+      await saveValue("userId", id);
+    }
+    return id;
+  }
+  static async fetchShortLink(link) {
+    try {
+      const encoded = encodeURIComponent(link);
+      const companyCode = this.companyCode || await getValue("companyCode");
+      if (!companyCode) return null;
+      const res = await fetch(`https://api.insertaffiliate.com/V1/convert-deep-link-to-short-link?companyId=${companyCode}&deepLinkUrl=${encoded}`);
+      const data = await res.json();
+      return (data == null ? void 0 : data.shortLink) || null;
+    } catch (err) {
+      console.error("[Insert Affiliate] Failed to fetch short link:", (err == null ? void 0 : err.message) || err);
+      return null;
+    }
+  }
+};
+InsertAffiliate.isInitialized = false;
+InsertAffiliate.companyCode = null;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InsertAffiliate
+});

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "insert-affiliate-js-sdk",
+  "version": "1.0.0",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+  "dev": "tsup --watch",
+  "prepare": "npm run build"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.2"
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './sdk/InsertAffiliate';

package/src/sdk/InsertAffiliate.ts

@@ -0,0 +1,239 @@
+// src/sdk/InsertAffiliate.ts
+import { getValue, saveValue } from '../utils/asyncStorage';
+import { generateUUID, generateShortDeviceID } from '../utils/helpers';
+
+interface IapticAndroidReceipt {
+  orderId: string;
+  purchaseToken: string;
+  signature: string;
+}
+
+interface IapticIOSReceipt {
+  transactionReceipt: string;
+}
+
+interface ExpectedTransactionPayload {
+  UUID: string;
+  companyCode: string;
+  shortCode: string;
+  storedDate: string;
+}
+
+export class InsertAffiliate {
+  private static isInitialized: boolean = false;
+  private static companyCode: string | null = null;
+
+  static async initialize(code: string | null): Promise<void> {
+    if (this.isInitialized) {
+      console.warn('[Insert Affiliate] SDK already initialized.');
+      return;
+    }
+    this.companyCode = code;
+    await saveValue('companyCode', code || '');
+    this.isInitialized = true;
+    console.log(`[Insert Affiliate] SDK initialized ${code ? `with company code: ${code}` : 'without a company code.'}`);
+  }
+
+  static async returnInsertAffiliateIdentifier(): Promise<string | null> {
+    const userId = await this.getOrCreateUserID();
+    const referrerLink = await getValue('referrerLink');
+    if (!referrerLink) return null;
+    return `${referrerLink}-${userId}`;
+  }
+
+  static async setInsertAffiliateIdentifier(referringLink: string): Promise<string | null> {
+    const userId = await this.getOrCreateUserID();
+    const shortCode = /^[a-zA-Z0-9]{10}$/.test(referringLink)
+      ? referringLink
+      : await this.fetchShortLink(referringLink);
+
+    if (!shortCode) return null;
+
+    await saveValue('referrerLink', shortCode);
+    return `${shortCode}-${userId}`;
+  }
+
+  static async setShortCode(shortCode: string): Promise<void> {
+    const valid = /^[a-zA-Z0-9]{10}$/.test(shortCode);
+    if (!valid) {
+      console.warn('[Insert Affiliate] Invalid short code.');
+      return;
+    }
+    await this.setInsertAffiliateIdentifier(shortCode);
+  }
+
+  static async trackEvent(eventName: string): Promise<void> {
+    const id = await this.returnInsertAffiliateIdentifier();
+    if (!id) {
+      console.warn('[Insert Affiliate] No affiliate identifier found.');
+      return;
+    }
+
+    try {
+      await fetch('https://api.insertaffiliate.com/v1/trackEvent', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ eventName, deepLinkParam: id }),
+      });
+      console.log('[Insert Affiliate] Event tracked:', eventName);
+    } catch (err) {
+      console.error('[Insert Affiliate] Failed to track event:', err);
+    }
+  }
+
+  static async returnUserAccountTokenAndStoreExpectedTransaction(): Promise<string | null> {
+    const shortCode = await this.returnInsertAffiliateIdentifier();
+    if (!shortCode) return null;
+
+    let token = await getValue('userAccountToken');
+    if (!token) {
+      token = generateUUID();
+      await saveValue('userAccountToken', token);
+    }
+
+    await this.storeExpectedStoreTransaction(token);
+    return token;
+  }
+
+  static async storeExpectedStoreTransaction(userAccountToken: string): Promise<void> {
+    const companyCode = this.companyCode || await getValue('companyCode');
+    const shortCode = await this.returnInsertAffiliateIdentifier();
+
+    if (!companyCode || !shortCode) {
+      console.error('[Insert Affiliate] Missing company code or identifier.');
+      return;
+    }
+
+    const payload: ExpectedTransactionPayload = {
+      UUID: userAccountToken,
+      companyCode,
+      shortCode,
+      storedDate: new Date().toISOString(),
+    };
+
+    try {
+      const res = 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 (res.status === 200) {
+        console.log('[Insert Affiliate] Stored expected transaction');
+      } else {
+        console.warn('[Insert Affiliate] Failed storing transaction:', res.status);
+      }
+    } catch (error) {
+      console.error('[Insert Affiliate] Error storing transaction:', error);
+    }
+  }
+
+  static async validatePurchaseWithIapticAPI(
+    jsonIapPurchase: IapticIOSReceipt | { transactionReceipt: string },
+    iapticAppId: string,
+    iapticAppName: string,
+    iapticPublicKey: string
+  ): Promise<boolean> {
+    try {
+      const isIOS = typeof window !== 'undefined' && /iPad|iPhone|iPod/.test(navigator.userAgent);
+
+      const baseRequest = {
+        id: iapticAppId,
+        type: 'application',
+      };
+
+      let transaction: any;
+
+      if (isIOS) {
+        transaction = {
+          id: iapticAppId,
+          type: 'ios-appstore',
+          appStoreReceipt: jsonIapPurchase.transactionReceipt,
+        };
+      } else {
+        const receiptJson: IapticAndroidReceipt = JSON.parse(atob(jsonIapPurchase.transactionReceipt));
+        transaction = {
+          id: receiptJson.orderId,
+          type: 'android-playstore',
+          purchaseToken: receiptJson.purchaseToken,
+          receipt: jsonIapPurchase.transactionReceipt,
+          signature: receiptJson.signature,
+        };
+      }
+
+      const insertAffiliateIdentifier = await this.returnInsertAffiliateIdentifier();
+
+      const payload = {
+        ...baseRequest,
+        transaction,
+        additionalData: insertAffiliateIdentifier
+          ? { applicationUsername: insertAffiliateIdentifier }
+          : undefined,
+      };
+
+      const response = await fetch('https://validator.iaptic.com/v1/validate', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Basic ${btoa(`${iapticAppName}:${iapticPublicKey}`)}`
+        },
+        body: JSON.stringify(payload),
+      });
+
+      return response.status === 200;
+    } catch (error) {
+      console.error('[Insert Affiliate] Purchase validation failed:', error);
+      return false;
+    }
+  }
+
+  static async fetchAndConditionallyOpenUrl(affiliateLink: string, offerCodeUrlId: string): Promise<void> {
+    const encoded = encodeURIComponent(affiliateLink);
+
+    try {
+      const res = await fetch(`https://api.insertaffiliate.com/v1/affiliateReturnOfferCode/${encoded}`);
+      const offerCode = (await res.text()).replace(/[^a-zA-Z0-9]/g, '');
+
+      const errorCodes = [
+        'errorofferCodeNotFound',
+        'errorAffiliateoffercodenotfoundinanycompany',
+        'errorAffiliateoffercodenotfoundinanycompanyAffiliatelinkwas',
+        'Routenotfound'
+      ];
+
+      if (errorCodes.includes(offerCode)) {
+        console.warn('[Insert Affiliate] Offer Code Not Found');
+        return;
+      }
+
+      const redeemUrl = `https://apps.apple.com/redeem?ctx=offercodes&id=${offerCodeUrlId}&code=${offerCode}`;
+      window.open(redeemUrl, '_blank');
+    } catch (err) {
+      console.error('[Insert Affiliate] Error fetching/opening offer code:', err);
+    }
+  }
+
+  private static async getOrCreateUserID(): Promise<string> {
+    let id = await getValue('userId');
+    if (!id) {
+      id = generateShortDeviceID();
+      await saveValue('userId', id);
+    }
+    return id;
+  }
+
+  private static async fetchShortLink(link: string): Promise<string | null> {
+    try {
+      const encoded = encodeURIComponent(link);
+      const companyCode = this.companyCode || await getValue('companyCode');
+      if (!companyCode) return null;
+
+      const res = await fetch(`https://api.insertaffiliate.com/V1/convert-deep-link-to-short-link?companyId=${companyCode}&deepLinkUrl=${encoded}`);
+      const data = await res.json();
+      return data?.shortLink || null;
+    } catch (err: any) {
+      console.error('[Insert Affiliate] Failed to fetch short link:', err?.message || err);
+      return null;
+    }
+  }
+}

package/src/utils/asyncStorage.ts

@@ -0,0 +1,9 @@
+// src/utils/asyncStorage.ts
+export const saveValue = async (key: string, value: string): Promise<void> => {
+    localStorage.setItem(key, value);
+};
+
+export const getValue = async (key: string): Promise<string | null> => {
+    return localStorage.getItem(key);
+};
+  

package/src/utils/helpers.ts

@@ -0,0 +1,32 @@
+// src/utils/helpers.ts
+export const generateShortDeviceID = (): string => {
+  const hashed = Math.abs(generateUUID().hashCode()) % 0xffffff;
+  return hashed.toString(16).padStart(6, '0').toUpperCase();
+};
+
+export const generateUUID = (): string => {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c: string): string => {
+    const r = Math.floor(Math.random() * 16);
+    const v = c === 'x' ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+};
+
+// Ensure we only patch String.prototype once
+if (!String.prototype.hasOwnProperty('hashCode')) {
+  String.prototype.hashCode = function (): number {
+    let hash = 0;
+    for (let i = 0; i < this.length; i++) {
+      const chr = this.charCodeAt(i);
+      hash = (hash << 5) - hash + chr;
+      hash |= 0; // Convert to 32bit integer
+    }
+    return hash;
+  };
+}
+
+declare global {
+  interface String {
+    hashCode(): number;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "module": "ESNext",
+    "moduleResolution": "Node",
+    "declaration": true,
+    "outDir": "dist",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}

package/tsup.config.js

@@ -0,0 +1,9 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['cjs'], // <- Use CJS for compatibility
+  dts: true,
+  clean: true,
+  outDir: 'dist',
+})

package/uploadNotes.md

@@ -0,0 +1,49 @@
+# 📦 Uploading `insert-affiliate-js-sdk` to npm
+
+This guide walks you through the steps to build, version, tag, and publish the SDK to npm.
+
+---
+
+## ✅ 1. Build the SDK
+
+Run the build command using `tsup` to compile TypeScript into JavaScript:
+
+```bash
+npm run build
+```
+
+This outputs compiled files to the dist/ folder, including:
+
+- CommonJS + ESM builds
+- Type definitions (.d.ts)
+
+
+## 🔢 2. Bump the Version
+Update the version field in package.json based on changes:
+
+Change Type	Version Format
+- Bug fix:	1.0.0 → 1.0.1
+- New feature:	1.0.0 → 1.1.0
+- Breaking change:	1.0.0 → 2.0.0
+
+## 🏷 3. Commit and Tag the Release
+```bash
+git add .
+git commit -m "Release v1.0.1"
+
+# Tag it
+git tag v1.0.1
+
+# Push both the commit and the tag
+git push origin main --tags
+```
+
+## 🔐 4. Login to npm (if you haven’t)
+```bash
+npm login
+```
+
+## 🚀 5. Publish to npm
+```bash
+npm publish --access public
+```