zopassport 0.1.0

package/app/src/components/wallet/styles/walletStyles.ts

@@ -0,0 +1,210 @@
+// Wallet Styles - Extracted from Zostel app
+import { StyleSheet } from 'react-native';
+import { WALLET_COLORS, WALLET_DIMENSIONS } from '../../../../assets/wallet/constants';
+
+export const walletStyles = StyleSheet.create({
+  // Layout
+  flex: {
+    flex: 1,
+  },
+  screen: {
+    flex: 1,
+    backgroundColor: WALLET_COLORS.background,
+  },
+  container: {
+    flexDirection: 'column-reverse',
+  },
+  
+  // Header
+  header: {
+    width: '100%',
+    flexDirection: 'row',
+    paddingVertical: 16,
+    paddingHorizontal: 24,
+    alignItems: 'flex-start',
+  },
+  titleContainer: {
+    ...StyleSheet.absoluteFillObject,
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+  
+  // Wallet Card
+  cardPressContainer: {
+    padding: 24,
+    paddingBottom: 0,
+    paddingTop: 8,
+  },
+  card: {
+    aspectRatio: WALLET_DIMENSIONS.cardAspectRatio,
+    width: '100%',
+    borderRadius: WALLET_DIMENSIONS.cardBorderRadius,
+    backgroundColor: WALLET_COLORS.cardBackground,
+  },
+  cardContainer: {
+    margin: 24,
+    flex: 1,
+    alignSelf: 'stretch',
+    backgroundColor: WALLET_COLORS.cardInner,
+    borderRadius: WALLET_DIMENSIONS.innerBorderRadius,
+    paddingBottom: 4,
+  },
+  cardContent: {
+    flex: 1,
+    padding: 16,
+    backgroundColor: WALLET_COLORS.cardContent,
+    borderRadius: WALLET_DIMENSIONS.innerBorderRadius,
+    borderWidth: 1,
+    borderColor: WALLET_COLORS.cardBorder,
+  },
+  cardShadow: {
+    width: '80%',
+    height: 24,
+    backgroundColor: WALLET_COLORS.shadowDark,
+    position: 'absolute',
+    top: '45%',
+    left: '10%',
+    shadowColor: 'black',
+    shadowOffset: { width: 0, height: -10 },
+    shadowOpacity: 0.75,
+    shadowRadius: 16,
+    elevation: 5,
+  },
+  
+  // Balance
+  balanceRow: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    justifyContent: 'space-between',
+  },
+  balanceWrapper: {
+    flexDirection: 'row',
+    alignItems: 'baseline',
+    gap: 4,
+  },
+  
+  // User Info
+  avatarInfo: {
+    flexDirection: 'row',
+    gap: 8,
+  },
+  
+  // Card Cover
+  cardCover: {
+    aspectRatio: WALLET_DIMENSIONS.coverAspectRatio,
+    width: '100%',
+    position: 'absolute',
+    bottom: 0,
+    left: 0,
+    right: 0,
+    borderBottomLeftRadius: WALLET_DIMENSIONS.innerBorderRadius,
+    borderBottomRightRadius: WALLET_DIMENSIONS.innerBorderRadius,
+    overflow: 'hidden',
+  },
+  cardCoverTextContainer: {
+    position: 'absolute',
+    bottom: 0,
+    left: 0,
+    right: 0,
+    top: 0,
+    justifyContent: 'center',
+    alignItems: 'center',
+  },
+  
+  // Shine Effect
+  shineContainer: {
+    ...StyleSheet.absoluteFillObject,
+    overflow: 'hidden',
+  },
+  shineEffect: {
+    position: 'absolute',
+    width: 150,
+    left: -60,
+    top: -140,
+    bottom: 0,
+  },
+  
+  // Text Styles
+  whiteText: {
+    color: WALLET_COLORS.textWhite,
+  },
+  grayText: {
+    color: WALLET_COLORS.textGray,
+  },
+  
+  // Token
+  tokenVideo: {
+    width: WALLET_DIMENSIONS.tokenVideoSize,
+    height: WALLET_DIMENSIONS.tokenVideoSize,
+    borderRadius: WALLET_DIMENSIONS.tokenVideoSize,
+    overflow: 'hidden',
+  },
+  token: {
+    width: WALLET_DIMENSIONS.tokenSize,
+    height: WALLET_DIMENSIONS.tokenSize,
+  },
+  tokenContainer: {
+    flexDirection: 'row',
+    gap: 4,
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+  textShadow: {
+    shadowRadius: 8,
+    shadowOpacity: 1,
+  },
+  
+  // Transactions
+  txnContent: {
+    alignSelf: 'stretch',
+    paddingHorizontal: 24,
+    gap: 32,
+    paddingBottom: 24,
+    paddingTop: 40,
+  },
+  txnRow: {
+    minHeight: 40,
+    flexDirection: 'row',
+    gap: 12,
+    justifyContent: 'space-between',
+    alignItems: 'center',
+  },
+  iconBgTilted: {
+    transform: [{ rotate: '-45deg' }],
+    width: 40,
+    height: 40,
+    borderRadius: 20,
+    backgroundColor: '#202020',
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+  
+  // States
+  loader: {
+    flex: 1,
+    alignItems: 'center',
+    justifyContent: 'center',
+    marginTop: 240,
+  },
+  openBg: {
+    ...StyleSheet.absoluteFillObject,
+    backgroundColor: WALLET_COLORS.background,
+    opacity: 0.8,
+  },
+  zoDescriptionContainer: {
+    position: 'absolute',
+    bottom: 140,
+  },
+  description: {
+    paddingHorizontal: 24,
+    color: WALLET_COLORS.textWhite,
+  },
+  
+  // Spacing
+  bar: {
+    height: 56,
+  },
+});
+
+export default walletStyles;
+

package/app/src/sdk/ZoPassportSDK.ts

@@ -0,0 +1,277 @@
+// ZoPassportSDK - Main SDK class
+// One-stop initialization for the entire Zo Passport experience
+
+import { ZoApiClient, ZoPassportConfig } from './lib/api/client';
+import { ZoAuth } from './lib/api/auth';
+import { ZoProfile } from './lib/api/profile';
+import { ZoAvatar } from './lib/api/avatar';
+import { ZoWallet } from './lib/api/wallet';
+import { LocalStorageAdapter, AsyncStorageAdapter, StorageAdapter, STORAGE_KEYS } from './lib/utils/storage';
+import type { ZoUser, ZoAuthResponse, Transaction } from './lib/types';
+
+export interface ZoPassportSDKConfig extends ZoPassportConfig {
+  /** Optional: Provide a custom storage adapter (default: LocalStorageAdapter) */
+  storageAdapter?: StorageAdapter;
+  /** Optional: Enable auto token refresh (default: true) */
+  autoRefresh?: boolean;
+  /** Optional: Token refresh interval in ms (default: 60000 = 1 minute) */
+  refreshInterval?: number;
+}
+
+export class ZoPassportSDK {
+  private client: ZoApiClient;
+  private storage: StorageAdapter;
+  private refreshTimer: ReturnType<typeof setTimeout> | null = null;
+
+  public auth: ZoAuth;
+  public profile: ZoProfile;
+  public avatar: ZoAvatar;
+  public wallet: ZoWallet;
+
+  private _user: ZoUser | null = null;
+  private _isAuthenticated: boolean = false;
+
+  constructor(config: ZoPassportSDKConfig) {
+    // Initialize storage adapter
+    this.storage = config.storageAdapter || new LocalStorageAdapter();
+
+    // Initialize API client
+    this.client = new ZoApiClient({
+      ...config,
+      storageAdapter: this.storage,
+    });
+
+    // Initialize API modules
+    this.auth = new ZoAuth(this.client, this.storage);
+    this.profile = new ZoProfile(this.client, this.storage);
+    this.avatar = new ZoAvatar(this.client, this.storage);
+    this.wallet = new ZoWallet(this.client);
+
+    // Start auto-refresh if enabled
+    if (config.autoRefresh !== false) {
+      this.startAutoRefresh(config.refreshInterval || 60000);
+    }
+
+    // Load existing session
+    this.loadSession();
+  }
+
+  // =====================
+  // Session Management
+  // =====================
+
+  private async loadSession(): Promise<void> {
+    try {
+      const userJson = await this.storage.getItem(STORAGE_KEYS.USER);
+      const accessToken = await this.storage.getItem(STORAGE_KEYS.ACCESS_TOKEN);
+
+      if (userJson && accessToken) {
+        this._user = JSON.parse(userJson);
+        this._isAuthenticated = true;
+      }
+    } catch (error) {
+      console.warn('[ZoPassport] Failed to load session:', error);
+    }
+  }
+
+  private async saveSession(authResponse: ZoAuthResponse): Promise<void> {
+    await this.storage.setItem(STORAGE_KEYS.ACCESS_TOKEN, authResponse.access_token);
+    await this.storage.setItem(STORAGE_KEYS.REFRESH_TOKEN, authResponse.refresh_token);
+    await this.storage.setItem(STORAGE_KEYS.TOKEN_EXPIRY, authResponse.access_token_expiry);
+    await this.storage.setItem(STORAGE_KEYS.REFRESH_EXPIRY, authResponse.refresh_token_expiry);
+    await this.storage.setItem(STORAGE_KEYS.USER, JSON.stringify(authResponse.user));
+    await this.storage.setItem(STORAGE_KEYS.CLIENT_DEVICE_ID, authResponse.device_id || '');
+    await this.storage.setItem(STORAGE_KEYS.CLIENT_DEVICE_SECRET, authResponse.device_secret || '');
+
+    this._user = authResponse.user;
+    this._isAuthenticated = true;
+  }
+
+  async clearSession(): Promise<void> {
+    await this.storage.removeItem(STORAGE_KEYS.ACCESS_TOKEN);
+    await this.storage.removeItem(STORAGE_KEYS.REFRESH_TOKEN);
+    await this.storage.removeItem(STORAGE_KEYS.TOKEN_EXPIRY);
+    await this.storage.removeItem(STORAGE_KEYS.REFRESH_EXPIRY);
+    await this.storage.removeItem(STORAGE_KEYS.USER);
+    await this.storage.removeItem(STORAGE_KEYS.CLIENT_DEVICE_ID);
+    await this.storage.removeItem(STORAGE_KEYS.CLIENT_DEVICE_SECRET);
+
+    this._user = null;
+    this._isAuthenticated = false;
+  }
+
+  // =====================
+  // Auto Token Refresh
+  // =====================
+
+  private startAutoRefresh(interval: number): void {
+    this.refreshTimer = setInterval(async () => {
+      await this.refreshTokenIfNeeded();
+    }, interval);
+  }
+
+  private stopAutoRefresh(): void {
+    if (this.refreshTimer) {
+      clearInterval(this.refreshTimer);
+      this.refreshTimer = null;
+    }
+  }
+
+  private async refreshTokenIfNeeded(): Promise<void> {
+    const tokenExpiry = await this.storage.getItem(STORAGE_KEYS.TOKEN_EXPIRY);
+    const refreshToken = await this.storage.getItem(STORAGE_KEYS.REFRESH_TOKEN);
+
+    if (!tokenExpiry || !refreshToken) return;
+
+    const expiryDate = new Date(tokenExpiry);
+    const now = new Date();
+    const twoMinutes = 2 * 60 * 1000;
+
+    // Refresh if expiring within 2 minutes
+    if (expiryDate.getTime() - now.getTime() < twoMinutes) {
+      const result = await this.auth.refreshAccessToken(refreshToken);
+      if (result.success && result.tokens) {
+        await this.storage.setItem(STORAGE_KEYS.ACCESS_TOKEN, result.tokens.access);
+        await this.storage.setItem(STORAGE_KEYS.REFRESH_TOKEN, result.tokens.refresh);
+        await this.storage.setItem(STORAGE_KEYS.TOKEN_EXPIRY, result.tokens.access_expiry);
+        await this.storage.setItem(STORAGE_KEYS.REFRESH_EXPIRY, result.tokens.refresh_expiry);
+      }
+    }
+  }
+
+  // =====================
+  // Public API
+  // =====================
+
+  get user(): ZoUser | null {
+    return this._user;
+  }
+
+  get isAuthenticated(): boolean {
+    return this._isAuthenticated;
+  }
+
+  /**
+   * Complete phone authentication flow
+   */
+  async loginWithPhone(
+    countryCode: string,
+    phoneNumber: string,
+    otp: string
+  ): Promise<{ success: boolean; user?: ZoUser; error?: string }> {
+    const result = await this.auth.verifyOTP(countryCode, phoneNumber, otp);
+
+    if (result.success && result.data) {
+      await this.saveSession(result.data);
+      return { success: true, user: result.data.user };
+    }
+
+    return { success: false, error: result.error };
+  }
+
+  /**
+   * Logout and clear session
+   */
+  async logout(): Promise<void> {
+    await this.clearSession();
+    this.stopAutoRefresh();
+  }
+
+  /**
+   * Get current user profile
+   */
+  async getProfile(): Promise<ZoUser | null> {
+    const accessToken = await this.storage.getItem(STORAGE_KEYS.ACCESS_TOKEN);
+    if (!accessToken) return null;
+
+    const result = await this.profile.getProfile(accessToken);
+    if (result.success && result.profile) {
+      this._user = result.profile as ZoUser;
+      await this.storage.setItem(STORAGE_KEYS.USER, JSON.stringify(result.profile));
+      return result.profile as ZoUser;
+    }
+
+    return null;
+  }
+
+  /**
+   * Update user profile
+   */
+  async updateProfile(updates: {
+    first_name?: string;
+    last_name?: string;
+    bio?: string;
+    date_of_birth?: string;
+    place_name?: string;
+    body_type?: 'bro' | 'bae';
+  }): Promise<{ success: boolean; profile?: ZoUser; error?: string }> {
+    const accessToken = await this.storage.getItem(STORAGE_KEYS.ACCESS_TOKEN);
+    if (!accessToken) return { success: false, error: 'Not authenticated' };
+
+    const result = await this.profile.updateProfile(accessToken, updates);
+    if (result.success && result.profile) {
+      this._user = result.profile as ZoUser;
+      await this.storage.setItem(STORAGE_KEYS.USER, JSON.stringify(result.profile));
+      return { success: true, profile: result.profile as ZoUser };
+    }
+
+    return { success: false, error: result.error };
+  }
+
+  /**
+   * Generate avatar
+   */
+  async generateAvatar(bodyType: 'bro' | 'bae'): Promise<{
+    success: boolean;
+    avatarUrl?: string;
+    error?: string;
+  }> {
+    const accessToken = await this.storage.getItem(STORAGE_KEYS.ACCESS_TOKEN);
+    if (!accessToken) return { success: false, error: 'Not authenticated' };
+
+    // Start generation
+    const startResult = await this.avatar.generateAvatar(accessToken, bodyType);
+    if (!startResult.success || !startResult.task_id) {
+      return { success: false, error: startResult.error };
+    }
+
+    // Poll for completion
+    return new Promise((resolve) => {
+      this.avatar.pollAvatarStatus(accessToken, startResult.task_id!, {
+        onComplete: (avatarUrl) => {
+          resolve({ success: true, avatarUrl });
+        },
+        onError: (error) => {
+          resolve({ success: false, error });
+        },
+      });
+    });
+  }
+
+  /**
+   * Get wallet balance
+   */
+  async getWalletBalance(): Promise<number> {
+    return this.wallet.getBalance();
+  }
+
+  /**
+   * Get wallet transactions
+   */
+  async getWalletTransactions(page?: number): Promise<{
+    transactions: Transaction[];
+    next?: string;
+    previous?: string;
+    count: number;
+  }> {
+    return this.wallet.getTransactions(page);
+  }
+
+  /**
+   * Cleanup
+   */
+  destroy(): void {
+    this.stopAutoRefresh();
+  }
+}
+

package/app/src/sdk/lib/api/auth.ts

@@ -0,0 +1,223 @@
+// src/lib/api/auth.ts
+// ZO API authentication functions
+
+import { ZoApiClient } from './client';
+import { StorageAdapter, STORAGE_KEYS } from '../utils/storage';
+import type {
+  ZoAuthOTPRequest,
+  ZoAuthOTPVerifyRequest,
+  ZoAuthResponse,
+  ZoErrorResponse,
+} from '../types';
+
+export class ZoAuth {
+  constructor(
+    private client: ZoApiClient,
+    private storage: StorageAdapter
+  ) {}
+
+  /**
+   * Send OTP to phone number
+   * Step 1 of ZO phone authentication
+   */
+  async sendOTP(
+    countryCode: string,
+    phoneNumber: string
+  ): Promise<{ success: boolean; message: string }> {
+    try {
+      const payload: ZoAuthOTPRequest = {
+        mobile_country_code: countryCode,
+        mobile_number: phoneNumber,
+        message_channel: '', // Empty string as per ZO API spec
+      };
+
+      const response = await this.client.axiosInstance.post(
+        '/api/v1/auth/login/mobile/otp/',
+        payload
+      );
+
+      if (response.status >= 200 && response.status < 300) {
+        return {
+          success: true,
+          message: response.data?.message || 'OTP sent successfully',
+        };
+      }
+
+      return {
+        success: false,
+        message: response.data?.message || `Unexpected status: ${response.status}`,
+      };
+    } catch (error: any) {
+      const errorData = error.response?.data as ZoErrorResponse;
+      const errorMessage = errorData?.detail || errorData?.message || errorData?.error || error.message || 'Failed to send OTP';
+
+      return {
+        success: false,
+        message: errorMessage,
+      };
+    }
+  }
+
+  /**
+   * Verify OTP and authenticate user
+   * Step 2 of ZO phone authentication
+   * Returns full auth response with tokens and user profile
+   */
+  async verifyOTP(
+    countryCode: string,
+    phoneNumber: string,
+    otp: string
+  ): Promise<{
+    success: boolean;
+    data?: ZoAuthResponse;
+    error?: string;
+  }> {
+    try {
+      const payload: ZoAuthOTPVerifyRequest = {
+        mobile_country_code: countryCode,
+        mobile_number: phoneNumber,
+        otp,
+      };
+
+      const response = await this.client.axiosInstance.post<ZoAuthResponse>(
+        '/api/v1/auth/login/mobile/',
+        payload
+      );
+
+      // Parse response data if it's a string
+      let responseData: ZoAuthResponse;
+      if (typeof response.data === 'string') {
+        try {
+          responseData = JSON.parse(response.data);
+        } catch {
+          return {
+            success: false,
+            error: 'Invalid response format from authentication service',
+          };
+        }
+      } else {
+        responseData = response.data;
+      }
+
+      // Validate response structure
+      if (!responseData || !responseData.user || !responseData.access_token) {
+        return {
+          success: false,
+          error: 'Invalid response structure from authentication service',
+        };
+      }
+
+      // Store session data
+      await this.storeSession(responseData);
+
+      return {
+        success: true,
+        data: responseData,
+      };
+    } catch (error: any) {
+      const errorMessage = this.extractErrorMessage(error);
+      return {
+        success: false,
+        error: errorMessage,
+      };
+    }
+  }
+
+  /**
+   * Refresh access token using refresh token
+   */
+  async refreshAccessToken(
+    refreshToken: string
+  ): Promise<{
+    success: boolean;
+    tokens?: {
+      access: string;
+      refresh: string;
+      access_expiry: string;
+      refresh_expiry: string;
+    };
+    error?: string;
+  }> {
+    try {
+      const response = await this.client.axiosInstance.post('/api/v1/auth/token/refresh/', {
+        refresh_token: refreshToken,
+      });
+
+      return {
+        success: true,
+        tokens: response.data,
+      };
+    } catch (error: any) {
+      return {
+        success: false,
+        error: 'Failed to refresh authentication',
+      };
+    }
+  }
+
+  /**
+   * Check if user is authenticated
+   */
+  async checkLoginStatus(accessToken: string): Promise<{
+    success: boolean;
+    isAuthenticated: boolean;
+  }> {
+    try {
+      const response = await this.client.axiosInstance.get('/api/v1/auth/login/check/', {
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+        },
+      });
+
+      return {
+        success: true,
+        isAuthenticated: response.data.authenticated === true,
+      };
+    } catch {
+      return {
+        success: false,
+        isAuthenticated: false,
+      };
+    }
+  }
+
+  /**
+   * Store session data in storage
+   */
+  private async storeSession(data: ZoAuthResponse): Promise<void> {
+    await this.storage.setItem(STORAGE_KEYS.ACCESS_TOKEN, data.access_token);
+    await this.storage.setItem(STORAGE_KEYS.REFRESH_TOKEN, data.refresh_token);
+    await this.storage.setItem(STORAGE_KEYS.TOKEN_EXPIRY, data.access_token_expiry);
+    await this.storage.setItem(STORAGE_KEYS.REFRESH_EXPIRY, data.refresh_token_expiry);
+    await this.storage.setItem(STORAGE_KEYS.USER, JSON.stringify(data.user));
+
+    if (data.device_id) {
+      await this.storage.setItem(STORAGE_KEYS.CLIENT_DEVICE_ID, data.device_id);
+    }
+    if (data.device_secret) {
+      await this.storage.setItem(STORAGE_KEYS.CLIENT_DEVICE_SECRET, data.device_secret);
+    }
+  }
+
+  /**
+   * Extract error message from various ZO API error formats
+   */
+  private extractErrorMessage(error: any): string {
+    const errorData = error.response?.data;
+
+    if (errorData) {
+      // Format 1: { success: false, errors: [...] }
+      if (errorData.errors && Array.isArray(errorData.errors)) {
+        return errorData.errors[0] || 'Invalid OTP';
+      }
+      // Format 2: { detail: "...", message: "..." }
+      if (errorData.detail) return errorData.detail;
+      if (errorData.message) return errorData.message;
+      // Format 3: { error: "..." }
+      if (errorData.error) return errorData.error;
+    }
+
+    return 'Authentication failed';
+  }
+}
+