zopassport 0.1.0

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

@@ -0,0 +1,155 @@
+// src/lib/api/avatar.ts
+// ZO API avatar generation functions
+
+import { ZoApiClient } from './client';
+import { StorageAdapter } from '../utils/storage';
+import type {
+  ZoAvatarGenerateRequest,
+  ZoAvatarGenerateResponse,
+  ZoAvatarStatusResponse,
+  ZoErrorResponse,
+} from '../types';
+
+export class ZoAvatar {
+  constructor(
+    private client: ZoApiClient,
+    private storage: StorageAdapter
+  ) {}
+
+  /**
+   * Generate avatar for user
+   */
+  async generateAvatar(
+    accessToken: string,
+    bodyType: 'bro' | 'bae'
+  ): Promise<{
+    success: boolean;
+    task_id?: string;
+    status?: string;
+    error?: string;
+  }> {
+    try {
+      const payload: ZoAvatarGenerateRequest = {
+        body_type: bodyType,
+      };
+
+      const response = await this.client.axiosInstance.post<ZoAvatarGenerateResponse>(
+        '/api/v1/avatar/generate/',
+        payload,
+        {
+          headers: {
+            Authorization: `Bearer ${accessToken}`,
+          },
+        }
+      );
+
+      return {
+        success: true,
+        task_id: response.data.task_id,
+        status: response.data.status,
+      };
+    } catch (error: any) {
+      const errorData = error.response?.data as ZoErrorResponse;
+      return {
+        success: false,
+        error: errorData?.detail || errorData?.message || 'Failed to generate avatar',
+      };
+    }
+  }
+
+  /**
+   * Check avatar generation status
+   */
+  async getAvatarStatus(
+    accessToken: string,
+    taskId: string
+  ): Promise<{
+    success: boolean;
+    status?: 'pending' | 'processing' | 'completed' | 'failed';
+    avatarUrl?: string;
+    error?: string;
+  }> {
+    try {
+      const response = await this.client.axiosInstance.get<ZoAvatarStatusResponse>(
+        `/api/v1/avatar/status/${taskId}/`,
+        {
+          headers: {
+            Authorization: `Bearer ${accessToken}`,
+          },
+        }
+      );
+
+      return {
+        success: true,
+        status: response.data.status,
+        avatarUrl: response.data.result?.avatar_url,
+      };
+    } catch (error: any) {
+      const errorData = error.response?.data as ZoErrorResponse;
+      return {
+        success: false,
+        error: errorData?.detail || errorData?.message || 'Failed to get avatar status',
+      };
+    }
+  }
+
+  /**
+   * Poll avatar status until completion
+   */
+  async pollAvatarStatus(
+    accessToken: string,
+    taskId: string,
+    options: {
+      onProgress?: (status: string) => void;
+      onComplete?: (avatarUrl: string) => void;
+      onError?: (error: string) => void;
+      maxAttempts?: number;
+      interval?: number;
+    } = {}
+  ): Promise<void> {
+    const {
+      onProgress,
+      onComplete,
+      onError,
+      maxAttempts = 30,
+      interval = 2000,
+    } = options;
+
+    let attempts = 0;
+
+    const poll = async () => {
+      attempts++;
+
+      if (attempts > maxAttempts) {
+        const timeoutError = 'Avatar generation timed out';
+        onError?.(timeoutError);
+        return;
+      }
+
+      const result = await this.getAvatarStatus(accessToken, taskId);
+
+      if (!result.success) {
+        onError?.(result.error || 'Unknown error');
+        return;
+      }
+
+      onProgress?.(result.status || 'unknown');
+
+      if (result.status === 'completed' && result.avatarUrl) {
+        onComplete?.(result.avatarUrl);
+        return;
+      }
+
+      if (result.status === 'failed') {
+        onError?.('Avatar generation failed');
+        return;
+      }
+
+      // Continue polling
+      setTimeout(poll, interval);
+    };
+
+    poll();
+  }
+}
+

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

@@ -0,0 +1,135 @@
+// src/lib/api/client.ts
+// ZO API HTTP client configuration
+
+import axios, { AxiosInstance } from 'axios';
+import { StorageAdapter, STORAGE_KEYS, LocalStorageAdapter } from '../utils/storage';
+
+export interface ZoPassportConfig {
+  /** Your ZO client key (required) */
+  clientKey: string;
+  /** API base URL (default: https://api.io.zo.xyz) */
+  baseUrl?: string;
+  /** Request timeout in ms (default: 10000) */
+  timeout?: number;
+  /** Storage adapter for tokens (default: LocalStorageAdapter) */
+  storageAdapter?: StorageAdapter;
+}
+
+/**
+ * Generate new device credentials
+ */
+function generateDeviceCredentials(): { deviceId: string; deviceSecret: string } {
+  const deviceId = `web-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+  const deviceSecret = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+  return { deviceId, deviceSecret };
+}
+
+export class ZoApiClient {
+  private client: AxiosInstance;
+  private config: ZoPassportConfig;
+  private storage: StorageAdapter;
+
+  constructor(config: ZoPassportConfig) {
+    this.config = config;
+    this.storage = config.storageAdapter || new LocalStorageAdapter();
+
+    this.client = axios.create({
+      baseURL: config.baseUrl || 'https://api.io.zo.xyz',
+      timeout: config.timeout || 10000,
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+      },
+    });
+
+    this.setupInterceptors();
+  }
+
+  private async setupInterceptors() {
+    // Request interceptor: Add required headers
+    this.client.interceptors.request.use(async (config) => {
+      // Always add client key
+      config.headers['client-key'] = this.config.clientKey;
+
+      // Get or generate device credentials
+      const credentials = await this.getOrCreateDeviceCredentials();
+      config.headers['client-device-id'] = credentials.deviceId;
+      config.headers['client-device-secret'] = credentials.deviceSecret;
+
+      // Add auth token if available
+      const token = await this.storage.getItem(STORAGE_KEYS.ACCESS_TOKEN);
+      if (token) {
+        config.headers['Authorization'] = `Bearer ${token}`;
+      }
+
+      return config;
+    });
+
+    // Response interceptor: Handle token refresh on 401
+    this.client.interceptors.response.use(
+      (response) => response,
+      async (error) => {
+        const originalRequest = error.config;
+
+        // If 401 and we haven't retried yet
+        if (error.response?.status === 401 && !originalRequest._retry) {
+          originalRequest._retry = true;
+
+          const refreshToken = await this.storage.getItem(STORAGE_KEYS.REFRESH_TOKEN);
+          if (refreshToken) {
+            try {
+              const response = await this.client.post('/api/v1/auth/token/refresh/', {
+                refresh_token: refreshToken,
+              });
+
+              if (response.data?.access) {
+                await this.storage.setItem(STORAGE_KEYS.ACCESS_TOKEN, response.data.access);
+                if (response.data.refresh) {
+                  await this.storage.setItem(STORAGE_KEYS.REFRESH_TOKEN, response.data.refresh);
+                }
+
+                // Retry original request with new token
+                originalRequest.headers['Authorization'] = `Bearer ${response.data.access}`;
+                return this.client(originalRequest);
+              }
+            } catch (refreshError) {
+              // Refresh failed - clear session
+              await this.storage.removeItem(STORAGE_KEYS.ACCESS_TOKEN);
+              await this.storage.removeItem(STORAGE_KEYS.REFRESH_TOKEN);
+            }
+          }
+        }
+
+        return Promise.reject(error);
+      }
+    );
+  }
+
+  private async getOrCreateDeviceCredentials(): Promise<{ deviceId: string; deviceSecret: string }> {
+    // Try to get from storage
+    const storedId = await this.storage.getItem(STORAGE_KEYS.CLIENT_DEVICE_ID);
+    const storedSecret = await this.storage.getItem(STORAGE_KEYS.CLIENT_DEVICE_SECRET);
+
+    if (storedId && storedSecret) {
+      return { deviceId: storedId, deviceSecret: storedSecret };
+    }
+
+    // Generate new credentials
+    const credentials = generateDeviceCredentials();
+
+    // Save to storage
+    await this.storage.setItem(STORAGE_KEYS.CLIENT_DEVICE_ID, credentials.deviceId);
+    await this.storage.setItem(STORAGE_KEYS.CLIENT_DEVICE_SECRET, credentials.deviceSecret);
+
+    return credentials;
+  }
+
+  get axiosInstance(): AxiosInstance {
+    return this.client;
+  }
+
+  getStorage(): StorageAdapter {
+    return this.storage;
+  }
+}
+

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

@@ -0,0 +1,8 @@
+// src/lib/api/index.ts
+// Re-export all API modules
+
+export { ZoApiClient, type ZoPassportConfig } from './client';
+export { ZoAuth } from './auth';
+export { ZoProfile } from './profile';
+export { ZoAvatar } from './avatar';
+

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

@@ -0,0 +1,80 @@
+// src/lib/api/profile.ts
+// ZO API profile functions
+
+import { ZoApiClient } from './client';
+import { StorageAdapter } from '../utils/storage';
+import type { ZoProfileResponse, ZoProfileUpdatePayload, ZoErrorResponse } from '../types';
+
+export class ZoProfile {
+  constructor(
+    private client: ZoApiClient,
+    private storage: StorageAdapter
+  ) {}
+
+  /**
+   * Get user profile
+   */
+  async getProfile(accessToken: string): Promise<{
+    success: boolean;
+    profile?: ZoProfileResponse;
+    error?: string;
+  }> {
+    try {
+      const response = await this.client.axiosInstance.get<ZoProfileResponse>(
+        '/api/v1/profile/me/',
+        {
+          headers: {
+            Authorization: `Bearer ${accessToken}`,
+          },
+        }
+      );
+
+      return {
+        success: true,
+        profile: response.data,
+      };
+    } catch (error: any) {
+      const errorData = error.response?.data as ZoErrorResponse;
+      return {
+        success: false,
+        error: errorData?.detail || errorData?.message || 'Failed to fetch profile',
+      };
+    }
+  }
+
+  /**
+   * Update user profile (partial updates supported)
+   */
+  async updateProfile(
+    accessToken: string,
+    updates: ZoProfileUpdatePayload
+  ): Promise<{
+    success: boolean;
+    profile?: ZoProfileResponse;
+    error?: string;
+  }> {
+    try {
+      const response = await this.client.axiosInstance.post<ZoProfileResponse>(
+        '/api/v1/profile/me/',
+        updates,
+        {
+          headers: {
+            Authorization: `Bearer ${accessToken}`,
+          },
+        }
+      );
+
+      return {
+        success: true,
+        profile: response.data,
+      };
+    } catch (error: any) {
+      const errorData = error.response?.data as ZoErrorResponse;
+      return {
+        success: false,
+        error: errorData?.detail || errorData?.message || 'Failed to update profile',
+      };
+    }
+  }
+}
+

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

@@ -0,0 +1,59 @@
+// src/lib/api/wallet.ts
+// Framework-agnostic Wallet API
+
+import { ZoApiClient } from './client';
+import type { BalanceResponse, TransactionsResponse, Transaction } from '../types/wallet';
+
+export class ZoWallet {
+    private client: ZoApiClient;
+
+    constructor(client: ZoApiClient) {
+        this.client = client;
+    }
+
+    /**
+     * Get wallet balance
+     * @returns Wallet balance amount
+     */
+    async getBalance(): Promise<number> {
+        try {
+            const response = await this.client.axiosInstance.get<BalanceResponse>(
+                '/api/v1/web3/token/airdrops/summary'
+            );
+            return response.data?.data?.total_amount ?? 0;
+        } catch (error) {
+            console.error('[ZoWallet] Failed to fetch balance:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Get transaction history
+     * @param page - Optional page number for pagination
+     * @returns Array of transactions
+     */
+    async getTransactions(page?: number): Promise<{
+        transactions: Transaction[];
+        next?: string;
+        previous?: string;
+        count: number;
+    }> {
+        try {
+            const url = page
+                ? `/api/v1/profile/completion-grants/claims?page=${page}`
+                : '/api/v1/profile/completion-grants/claims';
+
+            const response = await this.client.axiosInstance.get<TransactionsResponse>(url);
+
+            return {
+                transactions: response.data?.data?.results ?? [],
+                next: response.data?.data?.next,
+                previous: response.data?.data?.previous,
+                count: response.data?.data?.count ?? 0,
+            };
+        } catch (error) {
+            console.error('[ZoWallet] Failed to fetch transactions:', error);
+            throw error;
+        }
+    }
+}

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

@@ -0,0 +1,78 @@
+// src/lib/types/auth.ts
+// Authentication-related types
+
+export interface ZoAuthOTPRequest {
+  mobile_country_code: string;
+  mobile_number: string;
+  message_channel?: string;
+}
+
+export interface ZoAuthOTPVerifyRequest {
+  mobile_country_code: string;
+  mobile_number: string;
+  otp: string;
+}
+
+export interface ZoAuthTokens {
+  access: string;
+  refresh: string;
+  access_expiry: string;
+  refresh_expiry: string;
+}
+
+export interface ZoAuthResponse {
+  // Legacy fields (for backward compatibility)
+  token: string;  // Same as access_token
+  valid_till: string;  // Same as access_token_expiry
+  
+  // Current fields
+  access_token: string;
+  access_token_expiry: string;
+  refresh_token: string;
+  refresh_token_expiry: string;
+  client_key: string;
+  device_id: string;
+  device_secret: string;
+  device_info: Record<string, any>;
+  user: ZoUser;
+}
+
+export interface ZoUser {
+  id: string;  // UUID
+  pid: string;  // PID123
+  first_name: string;
+  last_name: string;
+  mobile_number: string;
+  email_address: string;
+  date_of_birth: string | null;
+  bio: string;
+  pfp_image: string;
+  wallet_address: string;  // Auto-provisioned during auth
+  membership: 'founder' | 'citizen' | 'none';
+  body_type: 'bro' | 'bae';
+  place_name: string;
+  home_location: {
+    lat: number;
+    lng: number;
+  } | null;
+  cultures: Array<{
+    key: string;
+    name: string;
+    icon: string;
+    description: string;
+  }>;
+  founder_tokens: string[];  // Array of token IDs like ["523", "204"]
+  avatar?: {
+    image: string;
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+  };
+}
+
+export interface ZoErrorResponse {
+  detail?: string;
+  error?: string;
+  message?: string;
+  errors?: string[];
+  success?: boolean;
+}
+

package/app/src/sdk/lib/types/avatar.ts

@@ -0,0 +1,22 @@
+// src/lib/types/avatar.ts
+// Avatar-related types
+
+export interface ZoAvatarGenerateRequest {
+  body_type: 'bro' | 'bae';
+}
+
+export interface ZoAvatarGenerateResponse {
+  task_id: string;
+  status: 'pending' | 'processing' | 'completed' | 'failed';
+  message: string;
+}
+
+export interface ZoAvatarStatusResponse {
+  task_id: string;
+  status: 'pending' | 'processing' | 'completed' | 'failed';
+  result?: {
+    avatar_url: string;
+  };
+  error?: string;
+}
+

package/app/src/sdk/lib/types/index.ts

@@ -0,0 +1,8 @@
+// src/lib/types/index.ts
+// Re-export all types
+
+export * from './auth';
+export * from './profile';
+export * from './avatar';
+export * from './wallet';
+

package/app/src/sdk/lib/types/profile.ts

@@ -0,0 +1,18 @@
+// src/lib/types/profile.ts
+// Profile-related types
+
+import { ZoUser } from './auth';
+
+export interface ZoProfileResponse extends ZoUser {
+  mobile_country_code: string;
+}
+
+export interface ZoProfileUpdatePayload {
+  first_name?: string;
+  last_name?: string;
+  bio?: string;
+  date_of_birth?: string;
+  place_name?: string;
+  body_type?: 'bro' | 'bae';
+}
+

package/app/src/sdk/lib/types/wallet.ts

@@ -0,0 +1,103 @@
+// src/lib/types/wallet.ts
+// Wallet-related types
+
+// Existing wallet types
+export interface ZoWallet {
+  address: string;
+  network: 'base' | 'avalanche';
+  balance?: number;
+}
+
+export interface ZoTokenBalanceResponse {
+  balance: number;
+  currency: {
+    name: string;
+    symbol: string;
+  };
+}
+
+// Wallet balance and transaction types
+export interface WalletBalance {
+  total_amount: number;
+  currency: string;
+}
+
+export interface Transaction {
+  id: string;
+  created_at: string;
+  updated_at: string;
+  amount: number;
+  description: string;
+  claimed_at: string;
+  grant: {
+    id: string;
+    name: string;
+    description: string;
+  };
+  action: 'deposit' | 'spend';
+}
+
+export interface WalletUser {
+  avatar?: {
+    image: string;
+  };
+  first_name: string;
+  nickname?: string;
+  wallet_address: string;
+}
+
+// API Response types
+export interface BalanceResponse {
+  data: {
+    total_amount: number;
+  };
+}
+
+export interface TransactionsResponse {
+  data: {
+    results: Transaction[];
+    next?: string;
+    previous?: string;
+    count: number;
+  };
+}
+
+// Formatted types for display
+export interface FormattedTransaction {
+  id: string;
+  description: string;
+  amount: string;
+  date: string;
+  timestamp: string;
+  action: 'deposit' | 'spend';
+  color: string;
+}
+
+// React Component Props (optional, for React components)
+export interface WalletCardProps {
+  balance: number;
+  user: WalletUser;
+  isOpen?: boolean;
+  onToggle?: () => void;
+  isLoading?: boolean;
+}
+
+export interface TransactionItemProps {
+  transaction: Transaction;
+  showDate?: boolean;
+}
+
+export interface TransactionListProps {
+  transactions: Transaction[];
+  isLoading?: boolean;
+  onEndReached?: () => void;
+}
+
+export interface MovingShineProps {
+  duration?: number;
+}
+
+export interface WalletScreenProps {
+  onBack?: () => void;
+}
+