@influto/react-native-sdk 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 InfluTo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,245 @@
+# InfluTo React Native SDK
+
+Track influencer referrals and conversions in your React Native app.
+
+## Installation
+
+```bash
+npm install @influto/react-native-sdk
+# or
+yarn add @influto/react-native-sdk
+```
+
+**Peer Dependencies:**
+```bash
+npm install @react-native-async-storage/async-storage
+```
+
+## Quick Start
+
+### 1. Initialize SDK
+
+```typescript
+import InfluTo from '@influto/react-native-sdk';
+
+// In your App.js or root component
+await InfluTo.initialize({
+  apiKey: 'it_abc123...',  // Get from InfluTo dashboard
+  debug: __DEV__  // Enable logging in development
+});
+```
+
+### 2. Check Attribution
+
+```typescript
+// During onboarding, check if user came from a referral
+const attribution = await InfluTo.checkAttribution();
+
+if (attribution.attributed) {
+  console.log('User came from:', attribution.referralCode);
+
+  // Show trial or special offer
+  showTrialPaywall(attribution.referralCode);
+} else {
+  // Organic user - show regular paywall
+  showRegularPaywall();
+}
+```
+
+### 3. Identify User
+
+```typescript
+// After user completes onboarding or you have their ID
+await InfluTo.identifyUser('revenuecat_user_id_123');
+```
+
+### 4. Track Events (Optional)
+
+```typescript
+// Track key events for analytics
+await InfluTo.trackEvent({
+  eventType: 'trial_started',
+  appUserId: 'revenuecat_user_id_123',
+  properties: {
+    trial_days: 7,
+    product_id: 'monthly_subscription'
+  }
+});
+```
+
+## Complete Integration Example
+
+```typescript
+import React, { useEffect, useState } from 'react';
+import InfluTo from '@influto/react-native-sdk';
+import Purchases from 'react-native-purchases';
+
+function App() {
+  const [hasReferral, setHasReferral] = useState(false);
+  const [referralCode, setReferralCode] = useState(null);
+
+  useEffect(() => {
+    async function setupInfluTo() {
+      // 1. Initialize InfluTo
+      await InfluTo.initialize({
+        apiKey: 'it_abc123...',
+        debug: __DEV__
+      });
+
+      // 2. Check attribution
+      const attribution = await InfluTo.checkAttribution();
+
+      if (attribution.attributed) {
+        setHasReferral(true);
+        setReferralCode(attribution.referralCode);
+
+        // 3. Store in RevenueCat for webhook attribution
+        await Purchases.setAttributes({
+          'referral_code': attribution.referralCode
+        });
+      }
+
+      // 4. Identify user when available
+      const customerInfo = await Purchases.getCustomerInfo();
+      await InfluTo.identifyUser(customerInfo.originalAppUserId);
+    }
+
+    setupInfluTo();
+  }, []);
+
+  // Show appropriate paywall based on attribution
+  const showPaywall = async () => {
+    const offerings = await Purchases.getOfferings();
+
+    if (hasReferral) {
+      // Show trial offering
+      const trialOffering = offerings.all['trial'] || offerings.current;
+      await RevenueCatUI.presentPaywall({ offering: trialOffering });
+
+      // Track event
+      await InfluTo.trackEvent({
+        eventType: 'trial_paywall_shown',
+        appUserId: customerInfo.originalAppUserId,
+        properties: { referral_code: referralCode }
+      });
+    } else {
+      // Show regular offering
+      await RevenueCatUI.presentPaywall();
+    }
+  };
+
+  return (
+    <YourApp hasReferral={hasReferral} onShowPaywall={showPaywall} />
+  );
+}
+```
+
+## API Reference
+
+### `InfluTo.initialize(config)`
+
+Initialize the SDK. Call once when app starts.
+
+**Parameters:**
+- `config.apiKey` (required): Your API key from InfluTo dashboard
+- `config.debug` (optional): Enable debug logging (defaults to `false`)
+
+**Returns:** `Promise<void>`
+
+### `InfluTo.checkAttribution()`
+
+Check if user was referred by an influencer.
+
+**Returns:** `Promise<AttributionResult>`
+
+**Example:**
+```typescript
+const result = await InfluTo.checkAttribution();
+// { attributed: true, referralCode: 'FITGURU25', clickedAt: '2025-12-01T10:30:00Z' }
+```
+
+### `InfluTo.identifyUser(appUserId, properties?)`
+
+Identify user with their app user ID.
+
+**Parameters:**
+- `appUserId` (required): RevenueCat ID or your custom user ID
+- `properties` (optional): Additional user properties
+
+**Returns:** `Promise<void>`
+
+### `InfluTo.trackEvent(options)`
+
+Track custom analytics event.
+
+**Parameters:**
+- `options.eventType` (required): Event name
+- `options.appUserId` (required): User ID
+- `options.properties` (optional): Event properties
+- `options.referralCode` (optional): Associated referral code
+
+**Returns:** `Promise<void>`
+
+### `InfluTo.getActiveCampaigns()`
+
+Get list of active campaigns for this app.
+
+**Returns:** `Promise<Campaign[]>`
+
+### `InfluTo.getReferralCode()`
+
+Get stored referral code (if any).
+
+**Returns:** `Promise<string | null>`
+
+### `InfluTo.clearAttribution()`
+
+Clear stored attribution data (useful for testing).
+
+**Returns:** `Promise<void>`
+
+## Integration with RevenueCat
+
+InfluTo works seamlessly with RevenueCat:
+
+1. **Store referral code in RevenueCat attributes:**
+```typescript
+const attribution = await InfluTo.checkAttribution();
+if (attribution.attributed) {
+  await Purchases.setAttributes({
+    'referral_code': attribution.referralCode
+  });
+}
+```
+
+2. **Configure RevenueCat webhook** in InfluTo dashboard
+
+3. **InfluTo automatically tracks** subscription events and calculates commissions
+
+## Platform Support
+
+- ✅ iOS 13.0+
+- ✅ Android 5.0+ (API level 21+)
+- ✅ Expo (managed & bare workflows)
+
+## Troubleshooting
+
+**Attribution not working?**
+- Ensure you called `initialize()` before `checkAttribution()`
+- Check API key is correct
+- Verify app is configured in InfluTo dashboard
+- Check network connectivity
+
+**User not identified?**
+- Make sure you call `identifyUser()` after user completes onboarding
+- Verify user ID matches what RevenueCat sends in webhooks
+
+## Support
+
+- **Documentation:** https://docs.influ.to
+- **Email:** support@influ.to
+- **Discord:** https://discord.gg/influto
+
+## License
+
+MIT © InfluTo

package/lib/InfluTo.d.ts

@@ -0,0 +1,81 @@
+/**
+ * InfluTo SDK for React Native
+ *
+ * Track influencer referrals and conversions in your mobile app
+ *
+ * @example
+ * ```typescript
+ * import InfluTo from '@influto/react-native-sdk';
+ *
+ * // Initialize (same key for dev & production)
+ * await InfluTo.initialize({
+ *   apiKey: 'it_abc123...',
+ *   debug: __DEV__  // Enable logging in development
+ * });
+ *
+ * // Check attribution
+ * const attribution = await InfluTo.checkAttribution();
+ * if (attribution.attributed) {
+ *   console.log('User came from referral:', attribution.referralCode);
+ * }
+ * ```
+ */
+import type { InfluToConfig, AttributionResult, Campaign, TrackEventOptions } from './types';
+declare class InfluToSDK {
+    private config;
+    private apiUrl;
+    private isInitialized;
+    /**
+     * Initialize InfluTo SDK
+     *
+     * Call this once when your app starts, after user grants tracking permission
+     */
+    initialize(config: InfluToConfig): Promise<void>;
+    /**
+     * Check if current user has attribution to a referral
+  
+     *
+     * Call this during app onboarding to see if user should get trial/discount
+     *
+     * @returns Attribution result with referral code if attributed
+     */
+    checkAttribution(): Promise<AttributionResult>;
+    /**
+     * Identify user with app_user_id
+     *
+     * Call this when you have the user's RevenueCat ID or custom user ID
+     */
+    identifyUser(appUserId: string, properties?: Record<string, any>): Promise<void>;
+    /**
+     * Track custom event
+     *
+     * Use this to track key events like trial_started, paywall_viewed, etc.
+     */
+    trackEvent(options: TrackEventOptions): Promise<void>;
+    /**
+     * Get active campaigns
+     *
+     * Useful for showing available promotions in-app
+     */
+    getActiveCampaigns(): Promise<Campaign[]>;
+    /**
+     * Get stored referral code (if any)
+     */
+    getReferralCode(): Promise<string | null>;
+    /**
+     * Clear stored attribution data
+     *
+     * Useful for testing or user logout
+     */
+    clearAttribution(): Promise<void>;
+    /**
+     * Get device information for fingerprinting
+     */
+    private getDeviceInfo;
+    /**
+     * Make API request with authentication
+     */
+    private apiRequest;
+}
+declare const InfluTo: InfluToSDK;
+export default InfluTo;

package/lib/InfluTo.js

@@ -0,0 +1,270 @@
+"use strict";
+/**
+ * InfluTo SDK for React Native
+ *
+ * Track influencer referrals and conversions in your mobile app
+ *
+ * @example
+ * ```typescript
+ * import InfluTo from '@influto/react-native-sdk';
+ *
+ * // Initialize (same key for dev & production)
+ * await InfluTo.initialize({
+ *   apiKey: 'it_abc123...',
+ *   debug: __DEV__  // Enable logging in development
+ * });
+ *
+ * // Check attribution
+ * const attribution = await InfluTo.checkAttribution();
+ * if (attribution.attributed) {
+ *   console.log('User came from referral:', attribution.referralCode);
+ * }
+ * ```
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_native_1 = require("react-native");
+const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
+const STORAGE_PREFIX = '@influto/';
+const STORAGE_KEYS = {
+    ATTRIBUTION: `${STORAGE_PREFIX}attribution`,
+    APP_USER_ID: `${STORAGE_PREFIX}app_user_id`,
+    REFERRAL_CODE: `${STORAGE_PREFIX}referral_code`,
+    SDK_INITIALIZED: `${STORAGE_PREFIX}initialized`,
+};
+class InfluToSDK {
+    constructor() {
+        this.config = null;
+        this.apiUrl = 'https://api.influ.to/api';
+        this.isInitialized = false;
+    }
+    /**
+     * Initialize InfluTo SDK
+     *
+     * Call this once when your app starts, after user grants tracking permission
+     */
+    async initialize(config) {
+        this.config = config;
+        // Use custom API URL if provided (internal testing only)
+        if (config.apiUrl) {
+            this.apiUrl = config.apiUrl;
+        }
+        if (config.debug) {
+            console.log('[InfluTo] Initializing SDK...');
+            console.log('[InfluTo] API URL:', this.apiUrl);
+        }
+        try {
+            // Call init endpoint
+            const response = await this.apiRequest('/sdk/init', {
+                method: 'POST',
+                body: JSON.stringify({
+                    app_version: require('react-native').Platform.constants?.version || 'unknown',
+                    sdk_version: '1.0.0',
+                    platform: react_native_1.Platform.OS
+                })
+            });
+            if (response.initialized) {
+                this.isInitialized = true;
+                await async_storage_1.default.setItem(STORAGE_KEYS.SDK_INITIALIZED, 'true');
+                if (config.debug) {
+                    console.log('[InfluTo] SDK initialized successfully');
+                    console.log('[InfluTo] Active campaigns:', response.campaigns?.length || 0);
+                }
+            }
+        }
+        catch (error) {
+            console.error('[InfluTo] Initialization failed:', error);
+            throw error;
+        }
+    }
+    /**
+     * Check if current user has attribution to a referral
+  
+     *
+     * Call this during app onboarding to see if user should get trial/discount
+     *
+     * @returns Attribution result with referral code if attributed
+     */
+    async checkAttribution() {
+        if (!this.isInitialized) {
+            throw new Error('InfluTo SDK not initialized. Call InfluTo.initialize() first.');
+        }
+        try {
+            // Check if already stored locally
+            const storedAttribution = await async_storage_1.default.getItem(STORAGE_KEYS.ATTRIBUTION);
+            if (storedAttribution) {
+                if (this.config?.debug) {
+                    console.log('[InfluTo] Attribution found in storage');
+                }
+                return JSON.parse(storedAttribution);
+            }
+            // Track install and check attribution
+            const deviceInfo = await this.getDeviceInfo();
+            const response = await this.apiRequest('/sdk/track-install', {
+                method: 'POST',
+                body: JSON.stringify(deviceInfo)
+            });
+            if (response.attributed && response.referral_code) {
+                const attribution = {
+                    attributed: true,
+                    referralCode: response.referral_code,
+                    attributionMethod: response.attribution_method,
+                    clickedAt: response.clicked_at,
+                    message: response.message
+                };
+                // Store for future use
+                await async_storage_1.default.setItem(STORAGE_KEYS.ATTRIBUTION, JSON.stringify(attribution));
+                await async_storage_1.default.setItem(STORAGE_KEYS.REFERRAL_CODE, response.referral_code);
+                if (this.config?.debug) {
+                    console.log('[InfluTo] ✅ Attribution found:', response.referral_code);
+                }
+                return attribution;
+            }
+            else {
+                if (this.config?.debug) {
+                    console.log('[InfluTo] No attribution found (organic install)');
+                }
+                return {
+                    attributed: false,
+                    message: response.message || 'No attribution found'
+                };
+            }
+        }
+        catch (error) {
+            console.error('[InfluTo] Error checking attribution:', error);
+            return {
+                attributed: false,
+                message: 'Error checking attribution'
+            };
+        }
+    }
+    /**
+     * Identify user with app_user_id
+     *
+     * Call this when you have the user's RevenueCat ID or custom user ID
+     */
+    async identifyUser(appUserId, properties) {
+        if (!this.isInitialized) {
+            console.warn('[InfluTo] SDK not initialized');
+            return;
+        }
+        await async_storage_1.default.setItem(STORAGE_KEYS.APP_USER_ID, appUserId);
+        try {
+            await this.apiRequest('/sdk/identify', {
+                method: 'POST',
+                body: JSON.stringify({
+                    app_user_id: appUserId,
+                    properties: properties || {}
+                })
+            });
+            if (this.config?.debug) {
+                console.log('[InfluTo] User identified:', appUserId);
+            }
+        }
+        catch (error) {
+            console.error('[InfluTo] Error identifying user:', error);
+        }
+    }
+    /**
+     * Track custom event
+     *
+     * Use this to track key events like trial_started, paywall_viewed, etc.
+     */
+    async trackEvent(options) {
+        if (!this.isInitialized) {
+            console.warn('[InfluTo] SDK not initialized');
+            return;
+        }
+        try {
+            await this.apiRequest('/sdk/event', {
+                method: 'POST',
+                body: JSON.stringify(options)
+            });
+            if (this.config?.debug) {
+                console.log('[InfluTo] Event tracked:', options.eventType);
+            }
+        }
+        catch (error) {
+            console.error('[InfluTo] Error tracking event:', error);
+        }
+    }
+    /**
+     * Get active campaigns
+     *
+     * Useful for showing available promotions in-app
+     */
+    async getActiveCampaigns() {
+        if (!this.isInitialized) {
+            return [];
+        }
+        try {
+            const response = await this.apiRequest('/sdk/campaigns');
+            return response || [];
+        }
+        catch (error) {
+            console.error('[InfluTo] Error fetching campaigns:', error);
+            return [];
+        }
+    }
+    /**
+     * Get stored referral code (if any)
+     */
+    async getReferralCode() {
+        return await async_storage_1.default.getItem(STORAGE_KEYS.REFERRAL_CODE);
+    }
+    /**
+     * Clear stored attribution data
+     *
+     * Useful for testing or user logout
+     */
+    async clearAttribution() {
+        await async_storage_1.default.multiRemove([
+            STORAGE_KEYS.ATTRIBUTION,
+            STORAGE_KEYS.REFERRAL_CODE,
+            STORAGE_KEYS.APP_USER_ID
+        ]);
+    }
+    /**
+     * Get device information for fingerprinting
+     */
+    async getDeviceInfo() {
+        const DeviceInfo = require('react-native').DeviceInfo || {};
+        return {
+            platform: react_native_1.Platform.OS,
+            deviceId: DeviceInfo.getUniqueId?.() || undefined,
+            deviceBrand: DeviceInfo.getBrand?.() || undefined,
+            deviceModel: DeviceInfo.getModel?.() || undefined,
+            osVersion: DeviceInfo.getSystemVersion?.() || react_native_1.Platform.Version?.toString(),
+            screenResolution: `${DeviceInfo.getDeviceWidth?.()}x${DeviceInfo.getDeviceHeight?.()}` || undefined,
+            timezone: DeviceInfo.getTimezone?.() || undefined,
+            language: DeviceInfo.getPreferredLocales?.()?.[0] || undefined
+        };
+    }
+    /**
+     * Make API request with authentication
+     */
+    async apiRequest(endpoint, options = {}) {
+        if (!this.config) {
+            throw new Error('SDK not configured');
+        }
+        const url = `${this.apiUrl}${endpoint}`;
+        const response = await fetch(url, {
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.config.apiKey}`,
+                ...options.headers
+            }
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`API request failed: ${response.status} - ${error}`);
+        }
+        return await response.json();
+    }
+}
+// Export singleton instance
+const InfluTo = new InfluToSDK();
+exports.default = InfluTo;

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * InfluTo React Native SDK
+ * Main exports
+ */
+export { default } from './InfluTo';
+export * from './types';

package/lib/index.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * InfluTo React Native SDK
+ * Main exports
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+var InfluTo_1 = require("./InfluTo");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(InfluTo_1).default; } });
+__exportStar(require("./types"), exports);

package/lib/types.d.ts

@@ -0,0 +1,76 @@
+/**
+ * InfluTo SDK Types
+ */
+export interface InfluToConfig {
+    /**
+     * Your InfluTo API key from dashboard
+     */
+    apiKey: string;
+    /**
+     * Enable debug logging (useful during development)
+     */
+    debug?: boolean;
+    /**
+     * @internal - Custom API URL (not for public use)
+     */
+    apiUrl?: string;
+}
+export interface AttributionResult {
+    /**
+     * Whether user was attributed to a referral
+     */
+    attributed: boolean;
+    /**
+     * Referral code if attributed
+     */
+    referralCode?: string;
+    /**
+     * Attribution method used
+     */
+    attributionMethod?: string;
+    /**
+     * When referral link was clicked
+     */
+    clickedAt?: string;
+    /**
+     * Attribution confidence (0.0-1.0)
+     */
+    confidence?: number;
+    /**
+     * Message explaining result
+     */
+    message?: string;
+}
+export interface Campaign {
+    id: string;
+    name: string;
+    description?: string;
+}
+export interface TrackEventOptions {
+    /**
+     * Event name
+     */
+    eventType: string;
+    /**
+     * User identifier (RevenueCat ID or custom)
+     */
+    appUserId: string;
+    /**
+     * Custom event properties
+     */
+    properties?: Record<string, any>;
+    /**
+     * Associated referral code
+     */
+    referralCode?: string;
+}
+export interface DeviceInfo {
+    platform: 'ios' | 'android';
+    deviceId?: string;
+    deviceBrand?: string;
+    deviceModel?: string;
+    osVersion?: string;
+    screenResolution?: string;
+    timezone?: string;
+    language?: string;
+}

package/lib/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * InfluTo SDK Types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@influto/react-native-sdk",
+  "version": "1.0.0",
+  "description": "InfluTo SDK for React Native - Track influencer referrals and conversions",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run build",
+    "test": "jest"
+  },
+  "keywords": [
+    "influto",
+    "influencer",
+    "affiliate",
+    "attribution",
+    "react-native",
+    "ios",
+    "android",
+    "revenuecat",
+    "tracking",
+    "analytics",
+    "referral"
+  ],
+  "author": "InfluTo <support@influ.to>",
+  "license": "MIT",
+  "peerDependencies": {
+    "react": ">=16.8.0",
+    "react-native": ">=0.60.0"
+  },
+  "dependencies": {
+    "@react-native-async-storage/async-storage": "^2.0.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.2.0",
+    "@types/react-native": "^0.72.0",
+    "typescript": "^5.3.0"
+  },
+  "bugs": {
+    "url": "https://influ.to/support"
+  },
+  "homepage": "https://influ.to",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/InfluTo.ts

@@ -0,0 +1,304 @@
+/**
+ * InfluTo SDK for React Native
+ *
+ * Track influencer referrals and conversions in your mobile app
+ *
+ * @example
+ * ```typescript
+ * import InfluTo from '@influto/react-native-sdk';
+ *
+ * // Initialize (same key for dev & production)
+ * await InfluTo.initialize({
+ *   apiKey: 'it_abc123...',
+ *   debug: __DEV__  // Enable logging in development
+ * });
+ *
+ * // Check attribution
+ * const attribution = await InfluTo.checkAttribution();
+ * if (attribution.attributed) {
+ *   console.log('User came from referral:', attribution.referralCode);
+ * }
+ * ```
+ */
+
+import { Platform } from 'react-native';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import type {
+  InfluToConfig,
+  AttributionResult,
+  Campaign,
+  TrackEventOptions,
+  DeviceInfo
+} from './types';
+
+const STORAGE_PREFIX = '@influto/';
+const STORAGE_KEYS = {
+  ATTRIBUTION: `${STORAGE_PREFIX}attribution`,
+  APP_USER_ID: `${STORAGE_PREFIX}app_user_id`,
+  REFERRAL_CODE: `${STORAGE_PREFIX}referral_code`,
+  SDK_INITIALIZED: `${STORAGE_PREFIX}initialized`,
+};
+
+class InfluToSDK {
+  private config: InfluToConfig | null = null;
+  private apiUrl: string = 'https://api.influ.to/api';
+  private isInitialized: boolean = false;
+
+  /**
+   * Initialize InfluTo SDK
+   *
+   * Call this once when your app starts, after user grants tracking permission
+   */
+  async initialize(config: InfluToConfig): Promise<void> {
+    this.config = config;
+
+    // Use custom API URL if provided (internal testing only)
+    if (config.apiUrl) {
+      this.apiUrl = config.apiUrl;
+    }
+
+    if (config.debug) {
+      console.log('[InfluTo] Initializing SDK...');
+      console.log('[InfluTo] API URL:', this.apiUrl);
+    }
+
+    try {
+      // Call init endpoint
+      const response = await this.apiRequest('/sdk/init', {
+        method: 'POST',
+        body: JSON.stringify({
+          app_version: require('react-native').Platform.constants?.version || 'unknown',
+          sdk_version: '1.0.0',
+          platform: Platform.OS
+        })
+      });
+
+      if (response.initialized) {
+        this.isInitialized = true;
+        await AsyncStorage.setItem(STORAGE_KEYS.SDK_INITIALIZED, 'true');
+
+        if (config.debug) {
+          console.log('[InfluTo] SDK initialized successfully');
+          console.log('[InfluTo] Active campaigns:', response.campaigns?.length || 0);
+        }
+      }
+    } catch (error) {
+      console.error('[InfluTo] Initialization failed:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Check if current user has attribution to a referral
+
+   *
+   * Call this during app onboarding to see if user should get trial/discount
+   *
+   * @returns Attribution result with referral code if attributed
+   */
+  async checkAttribution(): Promise<AttributionResult> {
+    if (!this.isInitialized) {
+      throw new Error('InfluTo SDK not initialized. Call InfluTo.initialize() first.');
+    }
+
+    try {
+      // Check if already stored locally
+      const storedAttribution = await AsyncStorage.getItem(STORAGE_KEYS.ATTRIBUTION);
+      if (storedAttribution) {
+        if (this.config?.debug) {
+          console.log('[InfluTo] Attribution found in storage');
+        }
+        return JSON.parse(storedAttribution);
+      }
+
+      // Track install and check attribution
+      const deviceInfo = await this.getDeviceInfo();
+
+      const response = await this.apiRequest('/sdk/track-install', {
+        method: 'POST',
+        body: JSON.stringify(deviceInfo)
+      });
+
+      if (response.attributed && response.referral_code) {
+        const attribution: AttributionResult = {
+          attributed: true,
+          referralCode: response.referral_code,
+          attributionMethod: response.attribution_method,
+          clickedAt: response.clicked_at,
+          message: response.message
+        };
+
+        // Store for future use
+        await AsyncStorage.setItem(STORAGE_KEYS.ATTRIBUTION, JSON.stringify(attribution));
+        await AsyncStorage.setItem(STORAGE_KEYS.REFERRAL_CODE, response.referral_code);
+
+        if (this.config?.debug) {
+          console.log('[InfluTo] ✅ Attribution found:', response.referral_code);
+        }
+
+        return attribution;
+      } else {
+        if (this.config?.debug) {
+          console.log('[InfluTo] No attribution found (organic install)');
+        }
+
+        return {
+          attributed: false,
+          message: response.message || 'No attribution found'
+        };
+      }
+    } catch (error) {
+      console.error('[InfluTo] Error checking attribution:', error);
+      return {
+        attributed: false,
+        message: 'Error checking attribution'
+      };
+    }
+  }
+
+  /**
+   * Identify user with app_user_id
+   *
+   * Call this when you have the user's RevenueCat ID or custom user ID
+   */
+  async identifyUser(appUserId: string, properties?: Record<string, any>): Promise<void> {
+    if (!this.isInitialized) {
+      console.warn('[InfluTo] SDK not initialized');
+      return;
+    }
+
+    await AsyncStorage.setItem(STORAGE_KEYS.APP_USER_ID, appUserId);
+
+    try {
+      await this.apiRequest('/sdk/identify', {
+        method: 'POST',
+        body: JSON.stringify({
+          app_user_id: appUserId,
+          properties: properties || {}
+        })
+      });
+
+      if (this.config?.debug) {
+        console.log('[InfluTo] User identified:', appUserId);
+      }
+    } catch (error) {
+      console.error('[InfluTo] Error identifying user:', error);
+    }
+  }
+
+  /**
+   * Track custom event
+   *
+   * Use this to track key events like trial_started, paywall_viewed, etc.
+   */
+  async trackEvent(options: TrackEventOptions): Promise<void> {
+    if (!this.isInitialized) {
+      console.warn('[InfluTo] SDK not initialized');
+      return;
+    }
+
+    try {
+      await this.apiRequest('/sdk/event', {
+        method: 'POST',
+        body: JSON.stringify(options)
+      });
+
+      if (this.config?.debug) {
+        console.log('[InfluTo] Event tracked:', options.eventType);
+      }
+    } catch (error) {
+      console.error('[InfluTo] Error tracking event:', error);
+    }
+  }
+
+  /**
+   * Get active campaigns
+   *
+   * Useful for showing available promotions in-app
+   */
+  async getActiveCampaigns(): Promise<Campaign[]> {
+    if (!this.isInitialized) {
+      return [];
+    }
+
+    try {
+      const response = await this.apiRequest('/sdk/campaigns');
+      return response || [];
+    } catch (error) {
+      console.error('[InfluTo] Error fetching campaigns:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Get stored referral code (if any)
+   */
+  async getReferralCode(): Promise<string | null> {
+    return await AsyncStorage.getItem(STORAGE_KEYS.REFERRAL_CODE);
+  }
+
+  /**
+   * Clear stored attribution data
+   *
+   * Useful for testing or user logout
+   */
+  async clearAttribution(): Promise<void> {
+    await AsyncStorage.multiRemove([
+      STORAGE_KEYS.ATTRIBUTION,
+      STORAGE_KEYS.REFERRAL_CODE,
+      STORAGE_KEYS.APP_USER_ID
+    ]);
+  }
+
+  /**
+   * Get device information for fingerprinting
+   */
+  private async getDeviceInfo(): Promise<DeviceInfo> {
+    const DeviceInfo = require('react-native').DeviceInfo || {};
+
+    return {
+      platform: Platform.OS as 'ios' | 'android',
+      deviceId: DeviceInfo.getUniqueId?.() || undefined,
+      deviceBrand: DeviceInfo.getBrand?.() || undefined,
+      deviceModel: DeviceInfo.getModel?.() || undefined,
+      osVersion: DeviceInfo.getSystemVersion?.() || Platform.Version?.toString(),
+      screenResolution: `${DeviceInfo.getDeviceWidth?.()}x${DeviceInfo.getDeviceHeight?.()}` || undefined,
+      timezone: DeviceInfo.getTimezone?.() || undefined,
+      language: DeviceInfo.getPreferredLocales?.()?.[0] || undefined
+    };
+  }
+
+  /**
+   * Make API request with authentication
+   */
+  private async apiRequest(
+    endpoint: string,
+    options: RequestInit = {}
+  ): Promise<any> {
+    if (!this.config) {
+      throw new Error('SDK not configured');
+    }
+
+    const url = `${this.apiUrl}${endpoint}`;
+
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.config.apiKey}`,
+        ...options.headers
+      }
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`API request failed: ${response.status} - ${error}`);
+    }
+
+    return await response.json();
+  }
+}
+
+// Export singleton instance
+const InfluTo = new InfluToSDK();
+export default InfluTo;

package/src/index.ts

@@ -0,0 +1,7 @@
+/**
+ * InfluTo React Native SDK
+ * Main exports
+ */
+
+export { default } from './InfluTo';
+export * from './types';

package/src/types.ts

@@ -0,0 +1,91 @@
+/**
+ * InfluTo SDK Types
+ */
+
+export interface InfluToConfig {
+  /**
+   * Your InfluTo API key from dashboard
+   */
+  apiKey: string;
+
+  /**
+   * Enable debug logging (useful during development)
+   */
+  debug?: boolean;
+
+  /**
+   * @internal - Custom API URL (not for public use)
+   */
+  apiUrl?: string;
+}
+
+export interface AttributionResult {
+  /**
+   * Whether user was attributed to a referral
+   */
+  attributed: boolean;
+
+  /**
+   * Referral code if attributed
+   */
+  referralCode?: string;
+
+  /**
+   * Attribution method used
+   */
+  attributionMethod?: string;
+
+  /**
+   * When referral link was clicked
+   */
+  clickedAt?: string;
+
+  /**
+   * Attribution confidence (0.0-1.0)
+   */
+  confidence?: number;
+
+  /**
+   * Message explaining result
+   */
+  message?: string;
+}
+
+export interface Campaign {
+  id: string;
+  name: string;
+  description?: string;
+}
+
+export interface TrackEventOptions {
+  /**
+   * Event name
+   */
+  eventType: string;
+
+  /**
+   * User identifier (RevenueCat ID or custom)
+   */
+  appUserId: string;
+
+  /**
+   * Custom event properties
+   */
+  properties?: Record<string, any>;
+
+  /**
+   * Associated referral code
+   */
+  referralCode?: string;
+}
+
+export interface DeviceInfo {
+  platform: 'ios' | 'android';
+  deviceId?: string;
+  deviceBrand?: string;
+  deviceModel?: string;
+  osVersion?: string;
+  screenResolution?: string;
+  timezone?: string;
+  language?: string;
+}