@sanctum-key/react-native-sdk 1.0.0

package/src/modules/api/KYCService.ts

@@ -0,0 +1,666 @@
+import axios from 'axios';
+import { GovernmentDocumentType, GovernmentDocumentTypeShorted, OrientationVideoResponse } from '../../types/KYC.types';
+import { CheckTemplateTypeResponse, ExtractMrzTextResponse } from '../../components/OverLay/type';
+import { SessionResponse, VerificationResult, VerificationSessionRequest } from './types';
+import { KycEnvironment } from '../../types/env.types';
+import { logger } from '../../utils/logger';
+import { Platform } from 'react-native';
+import KYCConfig from '../../config/KYCConfig';
+
+const appendFileToFormData = async (formData: FormData, key: string, uri: string, name: string = 'file.jpg', type: string = 'image/jpeg') => {
+  if (Platform.OS === 'web') {
+    const response = await fetch(uri);
+    const blob = await response.blob();
+    formData.append(key, blob, name);
+  } else {
+    formData.append(key, { uri, type, name } as any);
+  }
+};
+
+
+export interface KYCRequest {
+  userId: string;
+  documentImage: string;
+  selfieImage: string;
+  documentType: 'passport' | 'id_card' | 'drivers_license';
+}
+
+export interface KYCResponse {
+  success: boolean;
+  verificationId: string;
+  status: 'pending' | 'approved' | 'rejected';
+  message?: string;
+}
+
+export interface FaceDetectionRequest {
+  selfieImage: string;
+  documentImage: string;
+}
+
+export interface FaceDetectionResponse {
+  match: boolean;
+  confidence: number;
+  message: string;
+}
+
+export interface SelfieVideoResponse {
+  orientation_direction: "center" | "left" | "right",
+  turn_score: number;
+  bbox: number[];
+  capture: boolean;
+  instruction: string;
+  error: string;
+}
+
+
+export class KYCService {
+  private baseURL: string;
+  private apiKey: string;
+  // Additional service base URLs (fixed as per current infra)
+  private faceServiceURL = 'https://kyc-engine.transfergratis.net:8000';
+  private textExtractionServiceURL = 'https://kyc-engine.transfergratis.net:8006';
+  private mrzServiceURL = 'https://kyc-engine.transfergratis.net:8002';
+  private barcodeServiceURL = 'https://kyc-engine.transfergratis.net:8000';
+  private orientationServiceURL = 'http://18.188.180.154:8080';
+
+  constructor(baseURL: string, apiKey: string) {
+    this.baseURL = baseURL;
+    this.apiKey = apiKey;
+  }
+
+  private getHeaders() {
+    return {
+      'Authorization': `Bearer ${this.apiKey}`,
+      'Content-Type': 'application/json',
+    };
+  }
+
+  async submitKYC(data: KYCRequest): Promise<KYCResponse> {
+    try {
+      const response = await axios.post(
+        `${this.baseURL}/kyc/submit`,
+        data,
+        { headers: this.getHeaders() }
+      );
+      return response.data;
+    } catch (error) {
+      logger.error('Error submitting KYC:', error);
+      throw error;
+    }
+  }
+
+  async detectFace(data: FaceDetectionRequest): Promise<FaceDetectionResponse> {
+    try {
+      const response = await axios.post(
+        `${this.baseURL}/ai/face-detection`,
+        data,
+        { headers: this.getHeaders() }
+      );
+      return response.data;
+    } catch (error) {
+      logger.error('Error detecting face:', error);
+      throw error;
+    }
+  }
+
+  async validateDocument(documentImage: string, documentType: string): Promise<any> {
+    try {
+      const response = await axios.post(
+        `${this.baseURL}/ai/document-validation`,
+        { documentImage, documentType },
+        { headers: this.getHeaders() }
+      );
+      return response.data;
+    } catch (error) {
+      logger.error('Error validating document:', error);
+      throw error;
+    }
+  }
+
+  async getKYCStatus(verificationId: string): Promise<KYCResponse> {
+    try {
+      const response = await axios.get(
+        `${this.baseURL}/kyc/status/${verificationId}`,
+        { headers: this.getHeaders() }
+      );
+      return response.data;
+    } catch (error) {
+      logger.error('Error getting KYC status:', error);
+      throw error;
+    }
+  }
+
+  async processSelfieOrientationPicture(videoFile: string, token: string): Promise<SelfieVideoResponse[]> {
+    try {
+      const formData = new FormData();
+      await appendFileToFormData(formData, 'file', videoFile, 'selfie_picture.jpg', 'image/jpeg');
+
+      const response = await axios.post<SelfieVideoResponse[]>(
+        `${this.faceServiceURL}/detect_face_orientation/`,
+        formData,
+        {
+          timeout: 20000,
+          headers: { 'Content-Type': 'multipart/form-data', 'Authorization': `Bearer ${token}`, },
+        }
+      );
+      return response.data;
+    } catch (error) {
+      logger.error('Error processing selfie orientation:', error);
+      throw error;
+    }
+  }
+
+  async processOrientationVideo(videoFile: string, env: KycEnvironment = 'PRODUCTION'): Promise<OrientationVideoResponse> {
+    try {
+      // SANDBOX mode: skip AI verification and return mock response
+      if (env === 'SANDBOX') {
+        console.log("SANDBOX mode: Skipping AI orientation video processing");
+        logger.log("SANDBOX mode: Returning mock orientation video response");
+        return {
+          success: true,
+          data: {
+            center: { captured: true, frame: 10 },
+            left: { captured: true, frame: 30 },
+            right: { captured: true, frame: 50 }
+          },
+          message: 'SANDBOX: Orientation video processed successfully (mocked)'
+        };
+      }
+
+      // Create FormData for multipart/form-data request
+      const formData = new FormData();
+      await appendFileToFormData(formData, 'file', videoFile, 'orientation_video.mp4', 'video/mp4');
+
+
+      const response = await axios.post(
+        `${this.orientationServiceURL}/process_orientation_video_stream/`,
+        formData,
+        {
+          // Let axios set the proper multipart boundary header automatically
+          timeout: 90000,
+        }
+      );
+
+      return {
+        success: true,
+        data: response.data,
+        message: 'Orientation video processed successfully'
+      };
+    } catch (error: any) {
+      logger.error('Error processing orientation video:', JSON.stringify(error, null, 2));
+
+      // Handle specific error cases
+      if (error.response?.status === 503) {
+        return {
+          success: false,
+          error: {
+            code: 'SERVICE_UNAVAILABLE',
+            message: 'Service not ready, model not initialized.',
+            details: error.response.data
+          },
+          message: 'Service temporarily unavailable'
+        };
+      }
+
+      return {
+        success: false,
+        error: {
+          code: 'PROCESSING_ERROR',
+          message: error.response?.data?.detail || error.message || 'Unknown error occurred',
+          details: error.response?.data
+        },
+        message: 'Failed to process orientation video'
+      };
+    }
+  }
+
+  // STEP 1 - ID CARD VALIDATION
+  async detectFaceOnId(idCardImageUri: string, token: string, docType: string, env: KycEnvironment = 'PRODUCTION'): Promise<{ result: boolean, detail: any[] }> {
+    // SANDBOX mode
+    if (env === 'SANDBOX') {
+      console.log("SANDBOX mode: Skipping AI face detection on ID");
+      logger.log("SANDBOX mode: Returning mock face detection response");
+      return {
+        result: true,
+        detail: [{ confidence: 0.95, bbox: [50, 50, 200, 200] }],
+        card_obb: { x: 50, y: 50, width: 200, height: 200 }
+      } as any;
+    }
+
+    const formData = new FormData();
+    // Defaulting to photo since we don't pass postfix here currently, but making the name generic
+    await appendFileToFormData(formData, 'file', idCardImageUri, 'id_card_photo.jpg', 'image/jpeg');
+
+    logger.log('detectFaceOnId formData', JSON.stringify(formData, null, 2));
+
+    const docTypeShorted = GovernmentDocumentTypeShorted[docType as GovernmentDocumentType];
+    logger.log('detectFaceOnId docTypeShorted', docTypeShorted);
+    try {
+      const res = await axios.post(`${this.faceServiceURL}/detect_face/?doc_type=${docTypeShorted}`, formData,
+        {
+          headers: { 'Content-Type': 'multipart/form-data', 'Authorization': `Bearer ${token}`, },
+          timeout: 20000
+        });
+      logger.log('detectFaceOnId res', JSON.stringify(res.data, null, 2));
+
+      if (res.data?.result) return res.data;
+      throw new Error(res.data?.detail || 'detect_face failed');
+    } catch (error) {
+      logger.error('Error detecting face on id:', JSON.stringify(error));
+      throw error;
+    }
+  }
+
+  //check templatetemplate_type
+  async checkTemplateType(params: { fileUri: string; docType: string; docRegion: string; token: string; postfix: string }, env: KycEnvironment = 'PRODUCTION'): Promise<any> {
+    // SANDBOX mode
+    if (env === 'SANDBOX') {
+      console.log("SANDBOX mode: Skipping AI template type check");
+      logger.log("SANDBOX mode: Returning mock template type response");
+      const { docType, docRegion, postfix } = params;
+      return {
+        template_path: `templates/${docType}_${docRegion}_${postfix}.jpg`,
+        card_obb: { x: 50, y: 50, width: 200, height: 200 }
+      };
+    }
+
+    const { fileUri, docType, docRegion, token, postfix } = params;
+    const formData = new FormData();
+    
+    // ✅ FIX: Dynamically assign the postfix to the filename
+    await appendFileToFormData(formData, 'file', fileUri, `id_card_${postfix}.jpg`, 'image/jpeg');
+
+    const docTypeShorted = GovernmentDocumentTypeShorted[docType as GovernmentDocumentType];
+    const url = `${this.mrzServiceURL}/get_template_version/?doc_type=${encodeURIComponent(docTypeShorted)}&doc_region=${encodeURIComponent(docRegion)}&postfix=${postfix}`;
+
+    logger.log('checkTemplateType params', this.mrzServiceURL, JSON.stringify({ fileUri, docTypeShorted, docRegion, token, postfix, url }, null, 2));
+    try {
+      const res = await axios.post<CheckTemplateTypeResponse>(url, formData, {
+        headers: { 'Content-Type': 'multipart/form-data', 'Authorization': `Bearer ${token}`, },
+        timeout: 60000,
+      });
+      logger.log('checkTemplateType res', JSON.stringify(res.data, null, 2));
+      return res.data;
+    } catch (e: any) {
+      logger.error('Error checking template type:', JSON.stringify(e));
+      throw e;
+    }
+
+  }
+
+  async extractDocumentInformation(params: { fileUri: string; docType: string; docRegion: string; token: string; postfix?: string }): Promise<any> {
+    const { fileUri, docType, docRegion, token, postfix = 'front' } = params;
+    const formData = new FormData();
+    
+    // ✅ FIX: Dynamic filename
+    await appendFileToFormData(formData, 'file', fileUri, `id_card_${postfix}.jpg`, 'image/jpeg');
+
+    const url = `${this.textExtractionServiceURL}/extract_doc_information/?doc_type=${encodeURIComponent(docType)}&doc_region=${encodeURIComponent(docRegion)}`;
+    const attempt = async () => {
+      const res = await axios.post(url, formData, {
+        headers: { 'Content-Type': 'multipart/form-data', 'Authorization': `Bearer ${token}`, },
+        timeout: 60000,
+      });
+      logger.log('extractDocumentInformation res', JSON.stringify(truncateFields(res)));
+
+      if (res.data?.detail) throw new Error(res.data.detail);
+      return res.data;
+    };
+    try {
+      return await attempt();
+    } catch (e) {
+      logger.error('Error extracting document information:', JSON.stringify(truncateFields(e)));
+      throw e;
+    }
+  }
+
+  // STEP 2 - barcode extraction
+  async extractBarcode(params: { fileUri: string; token: string; postfix?: string }, env: KycEnvironment = 'PRODUCTION'): Promise<any> {
+    // SANDBOX mode
+    if (env === 'SANDBOX') {
+      console.log("SANDBOX mode: Skipping AI barcode extraction");
+      logger.log("SANDBOX mode: Returning mock barcode response");
+      return {
+        barcode_data: 'SANDBOX_MOCK_BARCODE_DATA',
+        card_obb: { x: 50, y: 50, width: 200, height: 200 }
+      };
+    }
+
+    const { fileUri, token, postfix = 'back' } = params;
+    const formData = new FormData();
+    
+    // ✅ FIX: Dynamic filename
+    await appendFileToFormData(formData, 'file', fileUri, `id_card_${postfix}.jpg`, 'image/jpeg');
+
+    const url = `${this.barcodeServiceURL}/decode_barcode/`;
+    const attempt = async () => {
+      try {
+        const res = await axios.post(url, formData, {
+          headers: { 'Content-Type': 'multipart/form-data', 'Authorization': `Bearer ${token}`, },
+          timeout: 60000,
+        });
+        logger.log('extractBarcode res', JSON.stringify(res.data, null, 2));
+        if (Object.keys(res.data).length === 0) throw new Error('No data found');
+        return res.data;
+      } catch (e: any) {
+        throw new Error(e?.message || 'Erreur de détection du barcode');
+      }
+    };
+    try {
+      return await attempt();
+    } catch (e) {
+      logger.error('Error extracting Barcode text:', JSON.stringify(e));
+      throw e;
+    }
+  }
+
+  // STEP 3 - MRZ TEXT EXTRACTION
+  async extractMrzText(
+    params: { 
+      fileUri: string; 
+      docType: string; 
+      docRegion: string; 
+      postfix?: string; 
+      token: string; 
+      template_path: string; 
+      mrz_type?: string; 
+    }, 
+    env: KycEnvironment = 'PRODUCTION'
+  ): Promise<any> {
+    // SANDBOX mode
+    if (env === 'SANDBOX') {
+      console.log("SANDBOX mode: Skipping AI MRZ extraction");
+      logger.log("SANDBOX mode: Returning mock MRZ response");
+      const { docType, docRegion, postfix = 'back', mrz_type } = params;
+      return {
+        success: true,
+        parsed_data: {
+          status: 'success',
+          document_type: docType,
+          mrz_type: mrz_type || 'TD1',
+          doc_region: docRegion,
+          postfix: postfix
+        },
+        card_obb: { x: 50, y: 50, width: 200, height: 200 }
+      };
+    }
+
+    const { fileUri, docType, docRegion, postfix = 'back', token, template_path, mrz_type } = params;
+    const formData = new FormData();
+    
+    // ✅ Dynamic filename to prevent passports from crashing (since their MRZ is on the front)
+    await appendFileToFormData(formData, 'file', fileUri, `id_card_${postfix}.jpg`, 'image/jpeg');
+
+    const docTypeShorted = GovernmentDocumentTypeShorted[docType as GovernmentDocumentType] || docType;
+    logger.log("docTypeShorted", docTypeShorted, docRegion, postfix);
+
+    let url = `${this.mrzServiceURL}/extract_mrz_text/?doc_type=${encodeURIComponent(docTypeShorted)}&doc_region=${encodeURIComponent(docRegion)}&postfix=${encodeURIComponent(postfix)}&template_path=${encodeURIComponent(template_path)}`;
+    
+    if (mrz_type && mrz_type.trim() !== '') {
+        url += `&mrz_type=${encodeURIComponent(mrz_type)}`;
+    }
+    
+    logger.log("url", url);
+
+    const attempt = async () => {
+      try {
+        const res = await axios.post<ExtractMrzTextResponse>(url, formData, {
+          headers: { 'Content-Type': 'multipart/form-data', 'Authorization': `Bearer ${token}` },
+          // Note: Reduced timeout to 10000ms (10s) based on our earlier network fix to prevent infinite hanging!
+          timeout: 10000, 
+        });
+        
+        logger.log('extractMrzText res', JSON.stringify(res.data, null, 2));
+        
+        if (Object.keys(res.data).length === 0) throw new Error('No data found');
+        if (res.data?.success === false) throw new Error(res.data.parsed_data?.status || 'Échec de l\'extraction MRZ');
+        
+        return res.data;
+      } catch (e: any) {
+        throw new Error(e?.message || 'Erreur de détection du MRZ');
+      }
+    };
+
+    try {
+      return await attempt();
+    } catch (e) {
+      logger.error('Error extracting MRZ text:', JSON.stringify(errorMessage(e), null, 2));
+      throw e;
+    }
+  }
+
+  // STEP 2 - SELFIE VALIDATION
+  async recognizeFace(params: { idPhotoUri: string; selfiePhotoUri: string }, env: KycEnvironment = 'PRODUCTION'): Promise<{ is_match: boolean; similarity: number; id_bbox?: number[]; selfie_bbox?: number[] }> {
+    // SANDBOX mode
+    if (env === 'SANDBOX') {
+      console.log("SANDBOX mode: Skipping AI face recognition");
+      logger.log("SANDBOX mode: Returning mock face recognition response");
+      return {
+        is_match: true,
+        similarity: 0.95,
+        id_bbox: [50, 50, 200, 200],
+        selfie_bbox: [50, 50, 200, 200]
+      };
+    }
+
+    const { idPhotoUri, selfiePhotoUri } = params;
+    const formData = new FormData();
+    await appendFileToFormData(formData, 'id_photo', idPhotoUri, 'id_card_photo.jpg', 'image/jpeg');
+    await appendFileToFormData(formData, 'selfie_photo', selfiePhotoUri, 'selfie_final.jpg', 'image/jpeg');
+
+    const res = await axios.post(`${this.faceServiceURL}/recognize_face/`, formData, { timeout: 45000 });
+    if (res.data?.detail) throw new Error(res.data.detail);
+    return res.data;
+  }
+
+  // HEALTH CHECKS
+  async healthFaceDetection(): Promise<any> {
+    const res = await axios.get(`${this.faceServiceURL}/health`);
+    return res.data;
+  }
+
+  async healthTextExtraction(): Promise<any> {
+    const res = await axios.get(`${this.textExtractionServiceURL}/health`);
+    return res.data;
+  }
+
+  async healthMrzService(): Promise<any> {
+    const res = await axios.get(`${this.mrzServiceURL}/health`);
+    return res.data;
+  }
+
+  async healthOrientationService(): Promise<any> {
+    const res = await axios.get(`${this.orientationServiceURL}/health`);
+    return res.data;
+  }
+
+  async newSession({ token, apiKey }: { token?: string, apiKey?: string }): Promise<SessionResponse> {
+    try {
+      const data = {
+        "status": "PENDING",
+        "metadata": {},
+      }
+      const res = await axios.post<SessionResponse>(`${KYCConfig.getBackendUrl()}/verification/sessions/`,
+        data, {
+        headers: {
+          'Content-Type': 'application/json',
+          ...(apiKey ? { 'Authorization': `ApiKey ${apiKey}` } : { 'Authorization': `Bearer ${token}` })
+        }
+      });
+      return res.data;
+    } catch (error: any) {
+      logger.error('Error creating session:', JSON.stringify(errorMessage(error), null, 2));
+
+      // Extract backend error message if available
+      const backendMessage = errorMessage(error);
+
+      if (backendMessage) {
+        logger.error('Backend error message:', JSON.stringify(truncateFields(backendMessage), null, 2));
+        throw new Error(`Backend error: ${JSON.stringify(truncateFields(backendMessage))}`);
+      }
+
+      throw error;
+    }
+  }
+
+  async verificationSession(payload: VerificationSessionRequest): Promise<any> {
+    console.log('apiKey in verificationSession', payload.apiKey);
+    try {
+      const { session_id, step, data, templateId, action, apiKey } = payload;
+      const token = apiKey ? undefined : await authentification();
+      const payloadData = {
+        action: action,
+        data: {
+          step,
+          templateId,
+          ...(action === "location_permission" ? { permissionGranted: true, } : {}),
+          ...data,
+        },
+        ...({ session_id: session_id }),
+        timestamp: new Date().toISOString()
+      }
+      const url = `${KYCConfig.getBackendUrl()}/verification/api/kyc/sessions/${session_id}/steps/${step}/`;
+
+      const logPayload = truncateFields({ payloadData, session_id, step });
+      logger.log('verificationSession payload',
+        JSON.stringify(truncateFields({ logPayload, token: token ?? "-", path: url, apiKey }),
+          null, 2))
+
+      const res = await axios.post<SessionResponse>(url,
+        payloadData,
+        {
+          headers: {
+            'Content-Type': 'application/json',
+            ...(apiKey ? { 'Authorization': `ApiKey ${apiKey}` } : { 'Authorization': `Bearer ${token}` })
+          }
+        });
+      logger.log('verificationSession res', JSON.stringify(truncateFields(res.data), null, 2));
+      return res.data;
+
+    } catch (error) {
+      logger.error('Error validating component:', JSON.stringify(error, null, 2));
+      throw new Error(errorMessage(error));
+    }
+  }
+
+  /** Send email verification code. POST /api/v1/accounts/email/send/ */
+  async sendEmailVerificationCode(
+    email: string,
+    auth?: { apiKey?: string; token?: string }
+  ): Promise<unknown> {
+    const url = `${KYCConfig.getBackendUrl()}/accounts/email/send/`;
+    const token = auth?.apiKey ? undefined : (auth?.token ?? await authentification());
+    const res = await axios.post(
+      url,
+      { email },
+      {
+        headers: {
+          'Content-Type': 'application/json',
+          ...(auth?.apiKey ? { 'Authorization': `ApiKey ${auth.apiKey}` } : { 'Authorization': `Bearer ${token}` }),
+        },
+      }
+    );
+    return res.data;
+  }
+
+  /** Verify email with OTP. POST /api/v1/accounts/email/verify/ */
+  async verifyEmailCode(
+    otp: string,
+    auth?: { apiKey?: string; token?: string }
+  ): Promise<unknown> {
+    const url = `${KYCConfig.getBackendUrl()}/accounts/email/verify/`;
+    const token = auth?.apiKey ? undefined : (auth?.token ?? await authentification());
+    const res = await axios.post(
+      url,
+      { otp },
+      {
+        headers: {
+          'Content-Type': 'application/json',
+          ...(auth?.apiKey ? { 'Authorization': `ApiKey ${auth.apiKey}` } : { 'Authorization': `Bearer ${token}` }),
+        },
+      }
+    );
+    return res.data;
+  }
+
+  async getVerificationResult(session_id: string): Promise<VerificationResult> {
+    try {
+      const token = await authentification();
+      const url = `${KYCConfig.getBackendUrl()}/verification/api/kyc/result/?session_id=${session_id}`;
+      const res = await axios.get<VerificationResult>(url,
+        { headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${token}` } });
+      logger.log('getVerificationResult res', JSON.stringify(truncateFields(res.data), null, 2));
+      return res.data;
+    } catch (error) {
+      logger.error('Error getting verification result:', JSON.stringify(errorMessage(error), null, 2));
+      throw error;
+    }
+  }
+}
+
+const kycService = new KYCService("", "");
+export default kycService;
+
+// Pour éviter d'afficher des champs trop longs, on tronque les valeurs longues dans le log
+export function truncateFields(obj: any, maxLength = 420): any {
+  if (typeof obj !== 'object' || obj === null) return obj;
+  if (Array.isArray(obj)) return obj.map(item => truncateFields(item, maxLength));
+  const truncated: any = {};
+  for (const key in obj) {
+    if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
+    const value = obj[key];
+    if (typeof value === 'string' && value.length > maxLength) {
+      truncated[key] = value.slice(0, maxLength) + '... [truncated]';
+    } else if (typeof value === 'object' && value !== null) {
+      truncated[key] = truncateFields(value, maxLength);
+    } else {
+      truncated[key] = value;
+    }
+  }
+  return truncated;
+}
+
+export const authentification = async () => {
+  try {
+    logger.log('authentification params', 'kyc_frontend', 'ZCW4mGaJXWR0UuI40lM1pHNQmYLw2xvX');
+    const params = new URLSearchParams();
+    params.append('client_id', 'kyc_frontend');
+    params.append('client_secret', 'ZCW4mGaJXWR0UuI40lM1pHNQmYLw2xvX');
+    params.append('grant_type', 'client_credentials');
+    const res = await axios.post(`https://keycloak.transfergratis.net/realms/kyc/protocol/openid-connect/token`,
+      params,
+      {
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded',
+        },
+      }
+    );
+    logger.log('authentification res', JSON.stringify(truncateFields(res.data)));
+    return res.data.access_token;
+  } catch (error: any) {
+    logger.error('Error authentifying:', {
+      message: error.message,
+      status: error.response?.status,
+      statusText: error.response?.statusText,
+      data: error.response?.data,
+      url: error.config?.url,
+      method: error.config?.method
+    });
+
+    const backendMessage = errorMessage(error);
+
+    if (backendMessage) {
+      logger.error('Backend authentication error:', JSON.stringify(truncateFields(backendMessage), null, 2));
+      throw new Error(`Authentication failed: ${JSON.stringify(truncateFields(backendMessage))}`);
+    }
+
+    throw error;
+  }
+}
+
+export const errorMessage = (error: any) => {
+  return error.response?.data?.message ||
+    error.response?.data?.detail ||
+    error.response?.data?.error ||
+    error.response?.data;
+}

package/src/modules/api/SelfieVerification.ts

@@ -0,0 +1,33 @@
+import kycService, { authentification, SelfieVideoResponse } from "./KYCService";
+
+import { KycEnvironment } from "../../types/env.types";
+
+const selfieVerification = async (selfieImage: string, env: KycEnvironment = 'PRODUCTION'): Promise<SelfieVideoResponse[]> => {
+    // In SANDBOX mode, skip AI verification and return a mock success response
+    if (env === 'SANDBOX') {
+        console.log("SANDBOX mode: Skipping AI verification for selfie");
+        // Return a mock response that simulates successful verification
+        // This allows the flow to continue without actual AI processing
+        
+        const mockResponse: SelfieVideoResponse[] = [{
+            orientation_direction: "center",
+            turn_score: 1.0,
+            bbox: [0, 0, 100, 100],
+            capture: true,
+            instruction: "SANDBOX: AI verification skipped",
+            error: ""
+        }];
+        return mockResponse;
+    }
+
+    // PRODUCTION mode: perform actual AI verification
+    const token = await authentification();
+    const response = await kycService.processSelfieOrientationPicture(selfieImage, token);
+    console.log("selfieVerification response", JSON.stringify(response, null, 2));
+    return response;
+}
+
+
+
+
+export default selfieVerification;