@onairos/react-native 1.0.0

package/src/services/oauthService.ts

@@ -0,0 +1,360 @@
+import { Linking, Platform } from 'react-native';
+import { updateCredentials, OnairosCredentials } from '../utils/secureStorage';
+import { sha256 } from '../utils/crypto';
+
+// Define OAuth configuration types
+export interface OAuthConfig {
+  clientId: string;
+  redirectUri: string;
+  scope: string;
+  authorizationEndpoint: string;
+  tokenEndpoint: string;
+  responseType: string;
+}
+
+// Platform-specific OAuth configurations
+const OAUTH_CONFIGS: Record<string, OAuthConfig> = {
+  instagram: {
+    clientId: 'YOUR_INSTAGRAM_CLIENT_ID', // Replace with actual client ID
+    redirectUri: 'onairosreact://auth/instagram',
+    scope: 'user_profile,user_media',
+    authorizationEndpoint: 'https://api.instagram.com/oauth/authorize',
+    tokenEndpoint: 'https://api.instagram.com/oauth/access_token',
+    responseType: 'code',
+  },
+  youtube: {
+    clientId: 'YOUR_YOUTUBE_CLIENT_ID', // Replace with actual client ID
+    redirectUri: 'onairosreact://auth/youtube',
+    scope: 'https://www.googleapis.com/auth/youtube.readonly',
+    authorizationEndpoint: 'https://accounts.google.com/o/oauth2/auth',
+    tokenEndpoint: 'https://oauth2.googleapis.com/token',
+    responseType: 'code',
+  },
+  pinterest: {
+    clientId: 'YOUR_PINTEREST_CLIENT_ID', // Replace with actual client ID
+    redirectUri: 'onairosreact://auth/pinterest',
+    scope: 'boards:read,pins:read',
+    authorizationEndpoint: 'https://www.pinterest.com/oauth/',
+    tokenEndpoint: 'https://api.pinterest.com/v5/oauth/token',
+    responseType: 'code',
+  },
+  reddit: {
+    clientId: 'YOUR_REDDIT_CLIENT_ID', // Replace with actual client ID
+    redirectUri: 'onairosreact://auth/reddit',
+    scope: 'identity,read',
+    authorizationEndpoint: 'https://www.reddit.com/api/v1/authorize',
+    tokenEndpoint: 'https://www.reddit.com/api/v1/access_token',
+    responseType: 'code',
+  },
+};
+
+/**
+ * Generate a state value for OAuth to prevent CSRF attacks
+ */
+const generateState = (): string => {
+  const randomValue = Math.random().toString(36).substring(2, 15);
+  return sha256(randomValue).substring(0, 10);
+};
+
+/**
+ * Initialize OAuth service handlers and listeners
+ */
+export const initializeOAuthService = (): void => {
+  // Set up deep linking handlers for OAuth redirects
+  Linking.addEventListener('url', handleDeepLink);
+};
+
+/**
+ * Clean up OAuth service handlers and listeners
+ */
+export const cleanupOAuthService = (): void => {
+  // Clean up deep linking handlers
+  if (Platform.OS === 'android') {
+    Linking.removeEventListener('url', handleDeepLink);
+  }
+};
+
+// Keep track of current OAuth state and callbacks
+let currentOAuthState: string | null = null;
+let currentOAuthPlatform: string | null = null;
+let currentOAuthResolve: ((value: any) => void) | null = null;
+let currentOAuthReject: ((error: Error) => void) | null = null;
+
+/**
+ * Handle deep link callbacks from OAuth providers
+ */
+const handleDeepLink = async (event: { url: string }): Promise<void> => {
+  try {
+    const { url } = event;
+    
+    // Check if this is an OAuth callback URL
+    if (!url.startsWith('onairosreact://auth/')) {
+      return;
+    }
+    
+    // Extract platform from URL path
+    const platform = url.split('onairosreact://auth/')[1].split('?')[0];
+    
+    // Only handle if it matches current OAuth flow
+    if (platform !== currentOAuthPlatform) {
+      return;
+    }
+    
+    // Parse URL parameters
+    const params = new URL(url).searchParams;
+    const code = params.get('code');
+    const state = params.get('state');
+    const error = params.get('error');
+    
+    // Validate state to prevent CSRF attacks
+    if (state !== currentOAuthState) {
+      if (currentOAuthReject) {
+        currentOAuthReject(new Error('OAuth state mismatch - possible CSRF attack'));
+      }
+      return;
+    }
+    
+    // Handle errors
+    if (error) {
+      if (currentOAuthReject) {
+        currentOAuthReject(new Error(`OAuth error: ${error}`));
+      }
+      return;
+    }
+    
+    // Proceed with token exchange if code is present
+    if (code) {
+      const tokenResult = await exchangeCodeForToken(platform, code);
+      
+      if (currentOAuthResolve) {
+        currentOAuthResolve(tokenResult);
+      }
+    } else {
+      if (currentOAuthReject) {
+        currentOAuthReject(new Error('No authorization code received'));
+      }
+    }
+  } catch (error) {
+    console.error('Error handling OAuth deep link:', error);
+    if (currentOAuthReject) {
+      currentOAuthReject(error as Error);
+    }
+  } finally {
+    // Reset state
+    currentOAuthState = null;
+    currentOAuthPlatform = null;
+    currentOAuthResolve = null;
+    currentOAuthReject = null;
+  }
+};
+
+/**
+ * Exchange OAuth authorization code for access token
+ */
+const exchangeCodeForToken = async (platform: string, code: string): Promise<any> => {
+  try {
+    const config = OAUTH_CONFIGS[platform];
+    
+    if (!config) {
+      throw new Error(`Unsupported platform: ${platform}`);
+    }
+    
+    // Prepare token request parameters
+    const params = new URLSearchParams({
+      grant_type: 'authorization_code',
+      code,
+      redirect_uri: config.redirectUri,
+      client_id: config.clientId,
+    });
+    
+    // Exchange code for token
+    const response = await fetch(config.tokenEndpoint, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: params.toString(),
+    });
+    
+    const data = await response.json();
+    
+    if (!response.ok) {
+      throw new Error(data.error || 'Failed to exchange code for token');
+    }
+    
+    // Fetch user information based on the platform
+    const userInfo = await fetchUserInfo(platform, data.access_token);
+    
+    return {
+      token: data.access_token,
+      refreshToken: data.refresh_token,
+      expiresIn: data.expires_in,
+      username: userInfo.username,
+      userId: userInfo.id,
+    };
+  } catch (error) {
+    console.error(`Error exchanging code for token (${platform}):`, error);
+    throw error;
+  }
+};
+
+/**
+ * Fetch user information from the connected platform
+ */
+const fetchUserInfo = async (platform: string, accessToken: string): Promise<any> => {
+  try {
+    let endpoint;
+    let headers: Record<string, string> = {
+      Authorization: `Bearer ${accessToken}`,
+    };
+    
+    // Platform-specific API endpoints for user info
+    switch (platform) {
+      case 'instagram':
+        endpoint = 'https://graph.instagram.com/me?fields=id,username';
+        break;
+      case 'youtube':
+        endpoint = 'https://www.googleapis.com/youtube/v3/channels?part=snippet&mine=true';
+        break;
+      case 'pinterest':
+        endpoint = 'https://api.pinterest.com/v5/user_account';
+        break;
+      case 'reddit':
+        endpoint = 'https://oauth.reddit.com/api/v1/me';
+        break;
+      default:
+        throw new Error(`Unsupported platform: ${platform}`);
+    }
+    
+    const response = await fetch(endpoint, { headers });
+    const data = await response.json();
+    
+    if (!response.ok) {
+      throw new Error(data.error || 'Failed to fetch user info');
+    }
+    
+    // Extract user information based on platform-specific response format
+    switch (platform) {
+      case 'instagram':
+        return { id: data.id, username: data.username };
+      case 'youtube':
+        return { 
+          id: data.items[0].id, 
+          username: data.items[0].snippet.title 
+        };
+      case 'pinterest':
+        return { 
+          id: data.id, 
+          username: data.username || data.full_name 
+        };
+      case 'reddit':
+        return { id: data.id, username: data.name };
+      default:
+        throw new Error(`Unsupported platform: ${platform}`);
+    }
+  } catch (error) {
+    console.error(`Error fetching user info (${platform}):`, error);
+    throw error;
+  }
+};
+
+/**
+ * Initiate OAuth flow for a specific platform
+ */
+export const connectPlatform = (platform: string): Promise<any> => {
+  return new Promise((resolve, reject) => {
+    try {
+      const config = OAUTH_CONFIGS[platform];
+      
+      if (!config) {
+        reject(new Error(`Unsupported platform: ${platform}`));
+        return;
+      }
+      
+      // Generate and save state for CSRF protection
+      const state = generateState();
+      currentOAuthState = state;
+      currentOAuthPlatform = platform;
+      currentOAuthResolve = resolve;
+      currentOAuthReject = reject;
+      
+      // Build OAuth URL
+      const authUrl = new URL(config.authorizationEndpoint);
+      authUrl.searchParams.append('client_id', config.clientId);
+      authUrl.searchParams.append('redirect_uri', config.redirectUri);
+      authUrl.searchParams.append('response_type', config.responseType);
+      authUrl.searchParams.append('scope', config.scope);
+      authUrl.searchParams.append('state', state);
+      
+      // Open browser to start OAuth flow
+      Linking.openURL(authUrl.toString());
+    } catch (error) {
+      reject(error);
+      
+      // Reset state on error
+      currentOAuthState = null;
+      currentOAuthPlatform = null;
+      currentOAuthResolve = null;
+      currentOAuthReject = null;
+    }
+  });
+};
+
+/**
+ * Disconnect a platform by removing its credentials
+ */
+export const disconnectPlatform = async (
+  platform: string, 
+  credentials: OnairosCredentials
+): Promise<boolean> => {
+  try {
+    if (!credentials.platforms) {
+      return false;
+    }
+    
+    // Create new credentials object with the platform removed
+    const updatedPlatforms = { ...credentials.platforms };
+    delete updatedPlatforms[platform as keyof typeof updatedPlatforms];
+    
+    // Update stored credentials
+    const result = await updateCredentials({
+      platforms: updatedPlatforms,
+    });
+    
+    return result;
+  } catch (error) {
+    console.error(`Error disconnecting platform (${platform}):`, error);
+    return false;
+  }
+};
+
+/**
+ * Store platform connection in credentials
+ */
+export const storePlatformConnection = async (
+  platform: string,
+  connectionData: any,
+  credentials: OnairosCredentials
+): Promise<boolean> => {
+  try {
+    // Create updated platforms object
+    const updatedPlatforms = {
+      ...credentials.platforms,
+      [platform]: {
+        token: connectionData.token,
+        username: connectionData.username,
+        userId: connectionData.userId,
+      },
+    };
+    
+    // Update stored credentials
+    const result = await updateCredentials({
+      platforms: updatedPlatforms,
+    });
+    
+    return result;
+  } catch (error) {
+    console.error(`Error storing platform connection (${platform}):`, error);
+    return false;
+  }
+};

package/src/types/declarations.d.ts

@@ -0,0 +1,26 @@
+// Type declarations for modules without type definitions
+
+declare module 'react-native-rsa-native' {
+  export const RSA: {
+    encrypt: (data: string, publicKey: string) => Promise<string>;
+    decrypt: (data: string, privateKey: string) => Promise<string>;
+    sign: (data: string, privateKey: string, hash?: string) => Promise<string>;
+    verify: (data: string, signature: string, publicKey: string, hash?: string) => Promise<boolean>;
+    generateKeys: (keySize?: number) => Promise<{ private: string; public: string }>;
+  };
+}
+
+declare module 'react-native-crypto-js' {
+  export const AES: {
+    encrypt: (message: string, secretKey: string) => any;
+    decrypt: (ciphertext: any, secretKey: string) => string;
+  };
+  
+  export function sha256(message: string): any;
+  export function MD5(message: string): any;
+  export function SHA1(message: string): any;
+  export function SHA512(message: string): any;
+  export function HmacSHA256(message: string, key: string): any;
+}
+
+// Declare any other missing module types here

package/src/types/index.ts

@@ -0,0 +1,82 @@
+export interface OnairosButtonProps {
+  AppName: string;
+  requestData: Record<string, Record<string, string>>;
+  returnLink: string;
+  embedd?: boolean;
+  color?: string;
+  icon?: string;
+  onResolved: (apiUrl: string, accessToken: string, loginDetails?: Record<string, any>) => void;
+  login?: boolean;
+  buttonType?: 'circle' | 'pill';
+  debug?: boolean;
+  test?: boolean;
+}
+
+export interface UniversalOnboardingProps {
+  visible: boolean;
+  onClose: () => void;
+  AppName: string;
+  requestData: Record<string, Record<string, string>>;
+  returnLink: string;
+  onComplete: (apiUrl: string, accessToken: string, data: any) => void;
+  embedd?: boolean;
+  debug?: boolean;
+  test?: boolean;
+}
+
+export interface ConnectionStatus {
+  instagram?: { userName: string };
+  pinterest?: { userName: string };
+  reddit?: { userName: string };
+  youtube?: { userName: string };
+}
+
+export interface PlatformListProps {
+  connections: ConnectionStatus;
+  onToggle: (platform: string, connect: boolean) => Promise<void>;
+  isLoading: boolean;
+  canProceed: boolean;
+  onProceed: () => void;
+}
+
+export interface PinInputProps {
+  onSubmit: (pin: string) => void;
+  minLength?: number;
+  requireSpecialChar?: boolean;
+  requireNumber?: boolean;
+}
+
+export interface TrainingModalProps {
+  progress: number;
+  eta: string;
+  onCancel: () => void;
+}
+
+export interface OAuthWebViewProps {
+  url: string;
+  platform: string;
+  onComplete: () => void;
+  onClose: () => void;
+}
+
+export interface CredentialsResult {
+  isValid: boolean;
+  credentials?: {
+    username?: string;
+    userPin?: string;
+    accessToken?: string;
+  };
+}
+
+export interface PlatformConfig {
+  name: string;
+  icon: string;
+  color: string;
+  description?: string;
+}
+
+export interface ApiResponse<T> {
+  success: boolean;
+  data?: T;
+  error?: string;
+} 

package/src/utils/api.js

@@ -0,0 +1,112 @@
+import axios from 'axios';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+const API_URL = 'https://api2.onairos.uk';
+
+/**
+ * Create an API instance with authorization headers
+ * @returns {Promise<Object>} - The axios instance
+ */
+export const createApiInstance = async () => {
+  const token = await AsyncStorage.getItem('onairosToken');
+  
+  return axios.create({
+    baseURL: API_URL,
+    headers: {
+      'Content-Type': 'application/json',
+      ...(token ? { 'Authorization': `Bearer ${token}` } : {})
+    }
+  });
+};
+
+/**
+ * Validate the domain with the Onairos API
+ * @returns {Promise<Object>} - The validation response
+ */
+export const validateDomain = async () => {
+  try {
+    const api = await createApiInstance();
+    const response = await api.post('/valid/validate-domain');
+    return response.data;
+  } catch (error) {
+    console.error('Error validating domain:', error);
+    return { status: false };
+  }
+};
+
+/**
+ * Fetch account information
+ * @param {string} identifier - The username or email
+ * @param {boolean} isEmail - Whether the identifier is an email
+ * @returns {Promise<Object>} - The account information
+ */
+export const fetchAccountInfo = async (identifier, isEmail = false) => {
+  try {
+    const api = await createApiInstance();
+    const jsonData = isEmail
+      ? { Info: { identifier } }
+      : { Info: { userName: identifier } };
+    
+    const endpoint = isEmail ? '/getAccountInfo/email' : '/getAccountInfo';
+    const response = await api.post(endpoint, jsonData);
+    
+    return response.data;
+  } catch (error) {
+    console.error('Error fetching account info:', error);
+    throw error;
+  }
+};
+
+/**
+ * Get API URL for data requests
+ * @param {Array} approvedRequests - The approved data requests
+ * @param {string} pin - The encrypted PIN
+ * @param {string} othentSub - The hashed Othent sub
+ * @returns {Promise<Object>} - The API URL response
+ */
+export const getApiUrl = async (approvedRequests, pin, othentSub) => {
+  try {
+    const api = await createApiInstance();
+    const jsonData = {
+      Info: {
+        EncryptedUserPin: pin,
+        confirmations: approvedRequests,
+        web3Type: 'othent',
+        Domain: Platform.OS,
+        proofMode: false,
+        OthentSub: othentSub,
+      },
+    };
+    
+    const response = await api.post('/getAPIurl', jsonData);
+    return response.data;
+  } catch (error) {
+    console.error('Error getting API URL:', error);
+    throw error;
+  }
+};
+
+/**
+ * Create a new user account
+ * @param {string} othentSub - The hashed Othent sub
+ * @param {string} pin - The PIN
+ * @param {Array} socialAccounts - The selected social accounts
+ * @param {string} email - The user's email
+ * @returns {Promise<Object>} - The account creation response
+ */
+export const createAccount = async (othentSub, pin, socialAccounts, email) => {
+  try {
+    const api = await createApiInstance();
+    const response = await api.post('/createAccount', {
+      othentSub,
+      pin,
+      socialAccounts,
+      email
+    });
+    
+    return response.data;
+  } catch (error) {
+    console.error('Error creating account:', error);
+    throw error;
+  }
+}; 

package/src/utils/auth.js

@@ -0,0 +1,104 @@
+import axios from 'axios';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+const API_URL = 'https://api2.onairos.uk';
+
+/**
+ * Get the encrypted PIN for a user
+ * @param {string} hashedOthentSub - The hashed Othent sub
+ * @returns {Promise<Object>} - The response containing the encrypted PIN
+ */
+export const getPin = async (hashedOthentSub) => {
+  try {
+    const response = await axios.post(`${API_URL}/getPin`, {
+      hashedOthentSub
+    });
+    
+    return response.data;
+  } catch (error) {
+    console.error('Error getting PIN:', error);
+    throw error;
+  }
+};
+
+/**
+ * Verify a token with the Onairos API
+ * @param {string} token - The token to verify
+ * @returns {Promise<boolean>} - Whether the token is valid
+ */
+export const verifyToken = async (token) => {
+  try {
+    const response = await axios.post(`${API_URL}/verifyToken`, {}, {
+      headers: {
+        'Authorization': `Bearer ${token}`
+      }
+    });
+    
+    return response.data.valid;
+  } catch (error) {
+    console.error('Error verifying token:', error);
+    return false;
+  }
+};
+
+/**
+ * Store authentication data
+ * @param {string} token - The authentication token
+ * @param {string} username - The username
+ * @param {Object} othentData - The Othent user data
+ */
+export const storeAuthData = async (token, username = null, othentData = null) => {
+  try {
+    await AsyncStorage.setItem('onairosToken', token);
+    
+    if (username) {
+      await AsyncStorage.setItem('username', username);
+    }
+    
+    if (othentData) {
+      await AsyncStorage.setItem('othentToken', JSON.stringify(othentData));
+    }
+  } catch (error) {
+    console.error('Error storing auth data:', error);
+    throw error;
+  }
+};
+
+/**
+ * Clear authentication data
+ */
+export const clearAuthData = async () => {
+  try {
+    await AsyncStorage.removeItem('onairosToken');
+    await AsyncStorage.removeItem('username');
+    await AsyncStorage.removeItem('othentToken');
+  } catch (error) {
+    console.error('Error clearing auth data:', error);
+    throw error;
+  }
+};
+
+/**
+ * Get stored authentication data
+ * @returns {Promise<Object>} - The stored authentication data
+ */
+export const getStoredAuthData = async () => {
+  try {
+    const token = await AsyncStorage.getItem('onairosToken');
+    const username = await AsyncStorage.getItem('username');
+    const othentToken = await AsyncStorage.getItem('othentToken');
+    
+    return {
+      token,
+      username,
+      othentToken: othentToken ? JSON.parse(othentToken) : null
+    };
+  } catch (error) {
+    console.error('Error getting stored auth data:', error);
+    return {
+      token: null,
+      username: null,
+      othentToken: null
+    };
+  }
+};