@sanctum-key/react-native-sdk 1.0.51 → 1.0.52

package/src/modules/api/KYCService.ts

@@ -8,497 +8,647 @@ 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 {
-    // React Native Native structure
-    formData.append(key, { uri, type, name } as any);
-  }
+    if (Platform.OS === 'web') {
+        const response = await fetch(uri);
+        const blob = await response.blob();
+        formData.append(key, blob, name);
+    } else {
+        // React Native Native structure
+        formData.append(key, { uri, type, name } as any);
+    }
 };
 
 const documentTypeMap: Record<string, string> = {
-  passport: "passport",
-  driversLicense: "driving_licence",
-  healthInsuranceCard: "health_insurance_card",
-  residencePermit: "permanent_residence_card",
-  identityCard: "identity_card",
-  nationalId: "identity_card",
-  national_id: "identity_card",
-  drivers_licence: "driving_licence",
-  drivers_license: "driving_licence",
-  driving_license: "driving_licence",
-  permanent_residence: "permanent_residence_card",
+    passport: "passport",
+    driversLicense: "driving_licence",
+    healthInsuranceCard: "health_insurance_card",
+    residencePermit: "permanent_residence_card",
+    identityCard: "identity_card",
+    nationalId: "identity_card",
+    national_id: "identity_card",
+    drivers_licence: "driving_licence",
+    drivers_license: "driving_licence",
+    driving_license: "driving_licence",
+    permanent_residence: "permanent_residence_card",
 };
 
 let cachedToken: string | null = null;
 let tokenExpiryTime: number | null = null;
 let activeAuthRequest: Promise<string> | null = null;
 
-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 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;
-  private faceServiceURL = 'https://face-infera.sanctumkey.com';
-  private textExtractionServiceURL = 'https://text-infera.sanctumkey.com';
-  private mrzServiceURL = 'https://mrz-infera.sanctumkey.com';
-  private barcodeServiceURL = 'https://face-infera.sanctumkey.com';
-  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',
-    };
-  }
-
-  // 🚨 BULLETPROOF MULTIPART FETCHER
-  // Replaces Axios for file uploads to guarantee iOS compatibility
-  private async crossPlatformMultipartUpload<T>(url: string, formData: FormData, token?: string, timeoutMs: number = 60000): Promise<T> {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-
-    const headers: Record<string, string> = {
-      'Accept': 'application/json',
-    };
-    if (token) headers['Authorization'] = `Bearer ${token}`;
+    private baseURL: string;
+    private apiKey: string;
+    private faceServiceURL = 'https://face-infera.sanctumkey.com';
+    private textExtractionServiceURL = 'https://text-infera.sanctumkey.com';
+    private mrzServiceURL = 'https://mrz-infera.sanctumkey.com';
+    private barcodeServiceURL = 'https://face-infera.sanctumkey.com';
+    private orientationServiceURL = 'http://18.188.180.154:8080';
+
+    constructor(baseURL: string, apiKey: string) {
+        this.baseURL = baseURL;
+        this.apiKey = apiKey;
+    }
 
-    try {
-      const response = await fetch(url, {
-        method: 'POST',
-        headers, // Do NOT set Content-Type, native fetch sets the boundary
-        body: formData,
-        signal: controller.signal
-      });
-
-      clearTimeout(timeoutId);
-
-      const responseText = await response.text();
-      let responseData;
-      try {
-        responseData = responseText ? JSON.parse(responseText) : {};
-      } catch (e) {
-        responseData = { detail: responseText };
-      }
-
-      if (!response.ok) {
-        // Mock Axios error structure so your `errorMessage` helper still works!
-        throw { response: { status: response.status, data: responseData } };
-      }
-
-      return responseData as T;
-    } catch (error: any) {
-      clearTimeout(timeoutId);
-      if (error.name === 'AbortError') {
-        throw { response: { data: { message: 'Request timed out' } } };
-      }
-      throw error;
+    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) { throw error; }
-  }
+    // 🚨 BULLETPROOF MULTIPART FETCHER
+    // Replaces Axios for file uploads to guarantee iOS compatibility
+    private async crossPlatformMultipartUpload<T>(url: string, formData: FormData, token?: string, timeoutMs: number = 60000): Promise<T> {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+
+        const headers: Record<string, string> = {
+            'Accept': 'application/json',
+        };
+        if (token) headers['Authorization'] = `Bearer ${token}`;
+
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers, // Do NOT set Content-Type, native fetch sets the boundary
+                body: formData,
+                signal: controller.signal
+            });
+
+            clearTimeout(timeoutId);
+            const responseText = await response.text();
+            let responseData;
+            try {
+                responseData = responseText ? JSON.parse(responseText) : {};
+            } catch (e) {
+                responseData = { detail: responseText };
+            }
+
+            if (!response.ok) {
+                // Mock Axios error structure so your `errorMessage` helper still works!
+                throw { response: { status: response.status, data: responseData } };
+            }
+            return responseData as T;
+        } catch (error: any) {
+            clearTimeout(timeoutId);
+            if (error.name === 'AbortError') {
+                throw { response: { data: { message: 'Request timed out' } } };
+            }
+            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) { throw error; }
-  }
+    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) {
+            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 data = await this.crossPlatformMultipartUpload<SelfieVideoResponse[]>(
-        `${this.faceServiceURL}/detect_face_orientation/`, formData, token, 20000
-      );
-      return data;
-    } catch (error) { throw error; }
-  }
-
-  async processOrientationVideo(videoFile: string, env: KycEnvironment = 'PRODUCTION'): Promise<OrientationVideoResponse> {
-    try {
-      if (env === 'SANDBOX') {
-        return { success: true, data: { center: { captured: true, frame: 10 }, left: { captured: true, frame: 30 }, right: { captured: true, frame: 50 } }, message: 'SANDBOX Mock' };
-      }
-      const formData = new FormData();
-      await appendFileToFormData(formData, 'file', videoFile, 'orientation_video.mp4', 'video/mp4');
-      
-      const data = await this.crossPlatformMultipartUpload<any>(
-        `${this.orientationServiceURL}/process_orientation_video_stream/`, formData, undefined, 90000
-      );
-      
-      return { success: true, data: data, message: 'Orientation video processed successfully' };
-    } catch (error: any) {
-      if (error.response?.status === 503) {
-        return { success: false, error: { code: 'SERVICE_UNAVAILABLE', message: 'Service not ready', details: error.response.data }, message: 'Service temporarily unavailable' };
-      }
-      return { success: false, error: { code: 'PROCESSING_ERROR', message: error.response?.data?.detail || 'Unknown error occurred' }, message: 'Failed to process orientation video' };
+    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) {
+            throw error;
+        }
     }
-  }
 
-  async detectFaceOnId(idCardImageUri: string, token: string, docType: string, env: KycEnvironment = 'PRODUCTION'): Promise<{ result: boolean; detail: any[]; card_obb?: any }> {
-    if (env === 'SANDBOX') {
-      return { result: true, detail: [{ confidence: 0.95, bbox: [50, 50, 200, 200] }], card_obb: { x: 50, y: 50, width: 200, height: 200 } };
+    async processSelfieOrientationPicture(videoFile: string, token: string): Promise<SelfieVideoResponse[]> {
+        try {
+            const formData = new FormData();
+            await appendFileToFormData(formData, 'file', videoFile, 'selfie_picture.jpg', 'image/jpeg');
+
+            const data = await this.crossPlatformMultipartUpload<SelfieVideoResponse[]>(
+                `${this.faceServiceURL}/detect_face_orientation/`,
+                formData,
+                token,
+                20000
+            );
+
+            return data;
+        } catch (error) {
+            throw error;
+        }
     }
-    const formData = new FormData();
-    await appendFileToFormData(formData, 'file', idCardImageUri, 'id_card_photo.jpg', 'image/jpeg');
-    const docTypeShorted = GovernmentDocumentTypeShorted[docType as GovernmentDocumentType] || docType;
-    
-    try {
-      const data = await this.crossPlatformMultipartUpload<any>(
-        `${this.faceServiceURL}/detect_face/?doc_type=${docTypeShorted}`, formData, token, 20000
-      );
-      if (data?.result) return data;
-      throw new Error(data?.detail || 'detect_face failed');
-    } catch (error: any) {
-      throw error;
+
+    async processOrientationVideo(videoFile: string, env: KycEnvironment = 'PRODUCTION'): Promise<OrientationVideoResponse> {
+        try {
+            const formData = new FormData();
+            await appendFileToFormData(formData, 'file', videoFile, 'orientation_video.mp4', 'video/mp4');
+
+            const data = await this.crossPlatformMultipartUpload<any>(
+                `${this.orientationServiceURL}/process_orientation_video_stream/`,
+                formData,
+                undefined,
+                90000
+            );
+
+            return { success: true, data: data, message: 'Orientation video processed successfully' };
+        } catch (error: any) {
+            if (error.response?.status === 503) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'SERVICE_UNAVAILABLE',
+                        message: 'Service not ready',
+                        details: error.response.data
+                    },
+                    message: 'Service temporarily unavailable'
+                };
+            }
+            return {
+                success: false,
+                error: {
+                    code: 'PROCESSING_ERROR',
+                    message: error.response?.data?.detail || 'Unknown error occurred'
+                },
+                message: 'Failed to process orientation video'
+            };
+        }
     }
-  }
 
-  async checkTemplateType(params: { fileUri: string; docType: string; docRegion: string; token: string; postfix: string; issuingSubdivision?: string; }, env: KycEnvironment = 'PRODUCTION'): Promise<any> {
-    if (env === 'SANDBOX') {
-      return { template_path: `templates/${params.docType}_${params.docRegion}_${params.postfix}.jpg`, card_obb: { x: 50, y: 50, width: 200, height: 200 } };
+    async detectFaceOnId(idCardImageUri: string, token: string, docType: string, env: KycEnvironment = 'PRODUCTION'): Promise<{ result: boolean; detail: any[]; card_obb?: any }> {
+        const formData = new FormData();
+        await appendFileToFormData(formData, 'file', idCardImageUri, 'id_card_photo.jpg', 'image/jpeg');
+
+        const docTypeShorted = GovernmentDocumentTypeShorted[docType as GovernmentDocumentType] || docType;
+
+        try {
+            const data = await this.crossPlatformMultipartUpload<any>(
+                `${this.faceServiceURL}/detect_face/?doc_type=${docTypeShorted}`,
+                formData,
+                token,
+                20000
+            );
+
+            if (data?.result) return data;
+            throw new Error(data?.detail || 'detect_face failed');
+        } catch (error: any) {
+            throw error;
+        }
     }
-    const formData = new FormData();
-    await appendFileToFormData(formData, 'file', params.fileUri, `id_card_${params.postfix}.jpg`, 'image/jpeg');
-    const docTypeShorted = GovernmentDocumentTypeShorted[params.docType as GovernmentDocumentType];
-    
-    let url = `${this.mrzServiceURL}/get_template_version/?doc_type=${encodeURIComponent(docTypeShorted)}&doc_region=${encodeURIComponent(params.docRegion)}&postfix=${params.postfix}`;
-    if (params.issuingSubdivision) url += `&issuing_subdivision=${encodeURIComponent(params.issuingSubdivision)}`;
-    
-    try {
-      return await this.crossPlatformMultipartUpload<CheckTemplateTypeResponse>(url, formData, params.token, 60000);
-    } catch (e: any) { throw e; }
-  }
 
-  async extractDocumentInformation(params: { fileUri: string; docType: string; docRegion: string; templatePath: string; issuingSubdivision?: string; token: string; postfix?: string }): Promise<any> {
-    const formData = new FormData();
-    await appendFileToFormData(formData, 'file', params.fileUri, `id_card_${params.postfix || 'front'}.jpg`, 'image/jpeg');
-    
-    let queryParams = `doc_type=${encodeURIComponent(params.docType)}&doc_region=${encodeURIComponent(params.docRegion)}&template_path=${encodeURIComponent(params.templatePath)}&postfix=${params.postfix || 'front'}&cleaned=true`;
-    if (params.issuingSubdivision) queryParams += `&issuing_subdivision=${encodeURIComponent(params.issuingSubdivision)}`;
-    
-    const url = `${this.textExtractionServiceURL}/extract_doc_information/?${queryParams}`;
-    try {
-      const startResData = await this.crossPlatformMultipartUpload<any>(url, formData, params.token, 60000);
-      const jobId = startResData?.job_id;
-      if (!jobId) throw new Error("Backend did not return a job_id");
-
-      const statusUrl = `${this.textExtractionServiceURL}/extract_doc_information/status/${jobId}`;
-      for (let i = 0; i < 15; i++) {
-        await new Promise(resolve => setTimeout(resolve, 2000));
-        // Status polling can remain Axios as it contains no file uploads
-        const statusRes = await axios.get(statusUrl, { headers: { 'Authorization': `Bearer ${params.token}` } });
-        if (statusRes.data.status === 'completed') return statusRes.data.result;
-        if (statusRes.data.status === 'failed') throw new Error(statusRes.data.error || "Document extraction failed.");
-      }
-      throw new Error("Document extraction timed out waiting for results.");
-    } catch (e: any) { throw e; }
-  }
-
-  async extractBarcode(params: { fileUri: string; token: string; docType: string; postfix?: string }, env: KycEnvironment = 'PRODUCTION'): Promise<any> {
-    if (env === 'SANDBOX') return { barcode_data: 'SANDBOX_MOCK_BARCODE_DATA' };
-    
-    const formData = new FormData();
-    await appendFileToFormData(formData, 'file', params.fileUri, `id_${params.postfix || 'back'}_photo.jpg`, 'image/jpeg');
-    const url = `${this.barcodeServiceURL}/decode_barcode/?doc_type=${encodeURIComponent(params.docType)}`;
-    
-    try {
-      return await this.crossPlatformMultipartUpload<any>(url, formData, params.token, 60000);
-    } catch (e: any) { throw e; }
-  }
-
-  // URL-Encoded data is completely fine with Axios, no multipart files here.
-  async formatBarcodeData(params: { textInput: string; token: string }, env: KycEnvironment = 'PRODUCTION'): Promise<any> {
-    if (env === 'SANDBOX') return { barcode_type: "SANDBOX_MOCK", first_name: "JOHN", last_name: "DOE" };
-    const formData = new URLSearchParams();
-    formData.append('text_input', params.textInput);
-    
-    try {
-      const res = await axios.post(`${this.barcodeServiceURL}/format_barcode_data/`, formData.toString(), {
-        headers: { 'Content-Type': 'application/x-www-form-urlencoded', 'Authorization': `Bearer ${params.token}` },
-        timeout: 60000,
-      });
-      return res.data;
-    } catch (e: any) { throw e; }
-  }
-
-  async extractMrzText(params: { fileUri: string; docType: string; docRegion: string; postfix?: string; token: string; template_path: string; mrz_type?: string; }, env: KycEnvironment = 'PRODUCTION'): Promise<any> {
-    if (env === 'SANDBOX') return { success: true, parsed_data: { status: 'success', document_type: params.docType } };
-    
-    const formData = new FormData();
-    await appendFileToFormData(formData, 'file', params.fileUri, `id_card_${params.postfix || 'back'}.jpg`, 'image/jpeg');
-    
-    const safeMrzType = params.mrz_type && params.mrz_type.trim() !== '' ? params.mrz_type : 'TD1';
-    const queryParams = new URLSearchParams({ 
-      doc_type: GovernmentDocumentTypeShorted[params.docType as GovernmentDocumentType] || params.docType, 
-      doc_region: params.docRegion, postfix: params.postfix || 'back', template_path: params.template_path, mrz_type: safeMrzType, reset_cache: 'true' 
-    }).toString();
-    
-    const url = `${this.mrzServiceURL}/extract_mrz_text/?${queryParams}`;
-    
-    try {
-      const data = await this.crossPlatformMultipartUpload<any>(url, formData, params.token, 60000);
-      if (Object.keys(data).length === 0) throw new Error('No data found');
-      if (data?.success === false) throw new Error(`Lecture MRZ refusée: ${data.parsed_data?.status_message}`);
-      return data;
-    } catch (error: any) { throw error; }
-  }
-
-  async recognizeFace(params: { idPhotoUri: string; selfiePhotoUri: string }, env: KycEnvironment = 'PRODUCTION'): Promise<{ is_match: boolean; similarity: number; id_bbox?: number[]; selfie_bbox?: number[] }> {
-    if (env === 'SANDBOX') return { is_match: true, similarity: 0.95 };
-    const formData = new FormData();
-    await appendFileToFormData(formData, 'id_photo', params.idPhotoUri, 'id_card_photo.jpg', 'image/jpeg');
-    await appendFileToFormData(formData, 'selfie_photo', params.selfiePhotoUri, 'selfie_final.jpg', 'image/jpeg');
+    async checkTemplateType(params: { fileUri: string; docType: string; docRegion: string; token: string; postfix: string; issuingSubdivision?: string; }, env: KycEnvironment = 'PRODUCTION'): Promise<any> {
+        const formData = new FormData();
+        await appendFileToFormData(formData, 'file', params.fileUri, `id_card_${params.postfix}.jpg`, 'image/jpeg');
+
+        const docTypeShorted = GovernmentDocumentTypeShorted[params.docType as GovernmentDocumentType];
+
+        let url = `${this.mrzServiceURL}/get_template_version/?doc_type=${encodeURIComponent(docTypeShorted)}&doc_region=${encodeURIComponent(params.docRegion)}&postfix=${params.postfix}`;
+        if (params.issuingSubdivision) url += `&issuing_subdivision=${encodeURIComponent(params.issuingSubdivision)}`;
+
+        try {
+            return await this.crossPlatformMultipartUpload<CheckTemplateTypeResponse>(url, formData, params.token, 60000);
+        } catch (e: any) {
+            throw e;
+        }
+    }
+
+    async extractDocumentInformation(params: { fileUri: string; docType: string; docRegion: string; templatePath: string; issuingSubdivision?: string; token: string; postfix?: string }): Promise<any> {
+        const formData = new FormData();
+        await appendFileToFormData(formData, 'file', params.fileUri, `id_card_${params.postfix || 'front'}.jpg`, 'image/jpeg');
+
+        let queryParams = `doc_type=${encodeURIComponent(params.docType)}&doc_region=${encodeURIComponent(params.docRegion)}&template_path=${encodeURIComponent(params.templatePath)}&postfix=${params.postfix || 'front'}&cleaned=true`;
+
+        if (params.issuingSubdivision) queryParams += `&issuing_subdivision=${encodeURIComponent(params.issuingSubdivision)}`;
+
+        const url = `${this.textExtractionServiceURL}/extract_doc_information/?${queryParams}`;
+
+        try {
+            const startResData = await this.crossPlatformMultipartUpload<any>(url, formData, params.token, 60000);
+
+            const jobId = startResData?.job_id;
+            if (!jobId) throw new Error("Backend did not return a job_id");
+
+            const statusUrl = `${this.textExtractionServiceURL}/extract_doc_information/status/${jobId}`;
+
+            for (let i = 0; i < 15; i++) {
+                await new Promise(resolve => setTimeout(resolve, 2000));
+                // Status polling can remain Axios as it contains no file uploads
+                const statusRes = await axios.get(statusUrl, { headers: { 'Authorization': `Bearer ${params.token}` } });
+
+                if (statusRes.data.status === 'completed') return statusRes.data.result;
+                if (statusRes.data.status === 'failed') throw new Error(statusRes.data.error || "Document extraction failed.");
+            }
+
+            throw new Error("Document extraction timed out waiting for results.");
+        } catch (e: any) {
+            throw e;
+        }
+    }
+
+    async extractBarcode(params: { fileUri: string; token: string; docType: string; postfix?: string }, env: KycEnvironment = 'PRODUCTION'): Promise<any> {
+        const formData = new FormData();
+        await appendFileToFormData(formData, 'file', params.fileUri, `id_${params.postfix || 'back'}_photo.jpg`, 'image/jpeg');
+
+        const url = `${this.barcodeServiceURL}/decode_barcode/?doc_type=${encodeURIComponent(params.docType)}`;
+
+        try {
+            return await this.crossPlatformMultipartUpload<any>(url, formData, params.token, 60000);
+        } catch (e: any) {
+            throw e;
+        }
+    }
+
+    // URL-Encoded data is completely fine with Axios, no multipart files here.
+    async formatBarcodeData(params: { textInput: string; token: string }, env: KycEnvironment = 'PRODUCTION'): Promise<any> {
+        const formData = new URLSearchParams();
+        formData.append('text_input', params.textInput);
+
+        try {
+            const res = await axios.post(`${this.barcodeServiceURL}/format_barcode_data/`, formData.toString(), {
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    'Authorization': `Bearer ${params.token}`
+                },
+                timeout: 60000,
+            });
+            return res.data;
+        } catch (e: any) {
+            throw e;
+        }
+    }
+
+    async extractMrzText(params: { fileUri: string; docType: string; docRegion: string; postfix?: string; token: string; template_path: string; mrz_type?: string; }, env: KycEnvironment = 'PRODUCTION'): Promise<any> {
+        const formData = new FormData();
+        await appendFileToFormData(formData, 'file', params.fileUri, `id_card_${params.postfix || 'back'}.jpg`, 'image/jpeg');
+
+        const safeMrzType = params.mrz_type && params.mrz_type.trim() !== '' ? params.mrz_type : 'TD1';
+
+        const queryParams = new URLSearchParams({
+            doc_type: GovernmentDocumentTypeShorted[params.docType as GovernmentDocumentType] || params.docType,
+            doc_region: params.docRegion,
+            postfix: params.postfix || 'back',
+            template_path: params.template_path,
+            mrz_type: safeMrzType,
+            reset_cache: 'true'
+        }).toString();
+
+        const url = `${this.mrzServiceURL}/extract_mrz_text/?${queryParams}`;
+
+        try {
+            const data = await this.crossPlatformMultipartUpload<any>(url, formData, params.token, 60000);
+            if (Object.keys(data).length === 0) throw new Error('No data found');
+            if (data?.success === false) throw new Error(`Lecture MRZ refusée: ${data.parsed_data?.status_message}`);
+            return data;
+        } catch (error: any) {
+            throw error;
+        }
+    }
+
+    async recognizeFace(params: { idPhotoUri: string; selfiePhotoUri: string }, env: KycEnvironment = 'PRODUCTION'): Promise<{ is_match: boolean; similarity: number; id_bbox?: number[]; selfie_bbox?: number[] }> {
+        const formData = new FormData();
+        await appendFileToFormData(formData, 'id_photo', params.idPhotoUri, 'id_card_photo.jpg', 'image/jpeg');
+        await appendFileToFormData(formData, 'selfie_photo', params.selfiePhotoUri, 'selfie_final.jpg', 'image/jpeg');
+
+        try {
+            const data = await this.crossPlatformMultipartUpload<any>(`${this.faceServiceURL}/recognize_face/`, formData, undefined, 45000);
+            if (data?.detail) throw new Error(data.detail);
+            return data;
+        } catch (error: any) {
+            throw error;
+        }
+    }
+
+    // --- STANDARD AXIOS REQUESTS BELOW (UNCHANGED, SAFE) ---
     
-    try {
-      const data = await this.crossPlatformMultipartUpload<any>(`${this.faceServiceURL}/recognize_face/`, formData, undefined, 45000);
-      if (data?.detail) throw new Error(data.detail);
-      return data;
-    } catch (error: any) { throw error; }
-  }
-
-  // --- STANDARD AXIOS REQUESTS BELOW (UNCHANGED, SAFE) ---
-  
-  async healthFaceDetection(): Promise<any> { return (await axios.get(`${this.faceServiceURL}/health`)).data; }
-  async healthTextExtraction(): Promise<any> { return (await axios.get(`${this.textExtractionServiceURL}/health`)).data; }
-  async healthMrzService(): Promise<any> { return (await axios.get(`${this.mrzServiceURL}/health`)).data; }
-  async healthOrientationService(): Promise<any> { return (await axios.get(`${this.orientationServiceURL}/health`)).data; }
-
-  async newSession({ token, apiKey }: { token?: string, apiKey?: string }): Promise<SessionResponse> {
-    try {
-      const res = await axios.post<SessionResponse>(`${KYCConfig.getBackendUrl()}/verification/sessions/`, { "status": "PENDING", "metadata": {} }, {
-        headers: { 'Content-Type': 'application/json', ...(apiKey ? { 'Authorization': `ApiKey ${apiKey}` } : { 'Authorization': `Bearer ${token}` }) }
-      });
-      return res.data;
-    } catch (error: any) { throw error; }
-  }
-
-  async verificationSession(payload: VerificationSessionRequest): Promise<any> {
-    try {
-      const { session_id, step, data, templateId, action, apiKey } = payload;
-      const token = apiKey ? undefined : await authentification();
-      const normalizedData = { ...data };
-      const rawDocType = normalizedData?.metadata?.document_type || normalizedData?.documentType || normalizedData?.documents?.documentType;
-      
-      if (rawDocType) {
-        const mappedDocType = documentTypeMap[rawDocType] ?? rawDocType;
-        normalizedData.metadata = { ...normalizedData.metadata, document_type: mappedDocType };
-        normalizedData.documentType = mappedDocType;
-        if (normalizedData.documents) {
-          normalizedData.documents = { ...normalizedData.documents, documentType: mappedDocType };
-          if (['passport', 'visa'].includes(mappedDocType.toLowerCase()) && !normalizedData.documents.back) normalizedData.documents.back = {};
+    async healthFaceDetection(): Promise<any> {
+        return (await axios.get(`${this.faceServiceURL}/health`)).data;
+    }
+
+    async healthTextExtraction(): Promise<any> {
+        return (await axios.get(`${this.textExtractionServiceURL}/health`)).data;
+    }
+
+    async healthMrzService(): Promise<any> {
+        return (await axios.get(`${this.mrzServiceURL}/health`)).data;
+    }
+
+    async healthOrientationService(): Promise<any> {
+        return (await axios.get(`${this.orientationServiceURL}/health`)).data;
+    }
+
+    async newSession({ token, apiKey }: { token?: string, apiKey?: string }): Promise<SessionResponse> {
+        try {
+            const res = await axios.post<SessionResponse>(`${KYCConfig.getBackendUrl()}/verification/sessions/`, {
+                "status": "PENDING",
+                "metadata": {}
+            }, {
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...(apiKey ? { 'Authorization': `ApiKey ${apiKey}` } : { 'Authorization': `Bearer ${token}` })
+                }
+            });
+            return res.data;
+        } catch (error: any) {
+            throw error;
         }
-      }
+    }
 
-      const payloadData = { action, data: { ...normalizedData, step, templateId }, session_id, timestamp: new Date().toISOString() };
-      const res = await axios.post<SessionResponse>(`${KYCConfig.getBackendUrl()}/verification/api/kyc/sessions/${session_id}/steps/${step}/`, payloadData, {
-        headers: { "Content-Type": "application/json", ...(apiKey ? { Authorization: `ApiKey ${apiKey}` } : {}), ...(token && !apiKey ? { Authorization: `Bearer ${token}` } : {}) }
-      });
-      return res.data;
-    } catch (error: any) { throw error; }
-  }
+    async verificationSession(payload: VerificationSessionRequest): Promise<any> {
+        try {
+            const { session_id, step, data, templateId, action, apiKey } = payload;
+            const token = apiKey ? undefined : await authentification();
+            const normalizedData = { ...data };
+
+            const rawDocType = normalizedData?.metadata?.document_type || normalizedData?.documentType || normalizedData?.documents?.documentType;
+
+            if (rawDocType) {
+                const mappedDocType = documentTypeMap[rawDocType] ?? rawDocType;
+                normalizedData.metadata = { ...normalizedData.metadata, document_type: mappedDocType };
+                normalizedData.documentType = mappedDocType;
+
+                if (normalizedData.documents) {
+                    normalizedData.documents = { ...normalizedData.documents, documentType: mappedDocType };
+                    if (['passport', 'visa'].includes(mappedDocType.toLowerCase()) && !normalizedData.documents.back)
+                        normalizedData.documents.back = {};
+                }
+            }
+
+            const payloadData = {
+                action,
+                data: { ...normalizedData, step, templateId },
+                session_id,
+                timestamp: new Date().toISOString()
+            };
+
+            const res = await axios.post<SessionResponse>(`${KYCConfig.getBackendUrl()}/verification/api/kyc/sessions/${session_id}/steps/${step}/`, payloadData, {
+                headers: {
+                    "Content-Type": "application/json",
+                    ...(apiKey ? { Authorization: `ApiKey ${apiKey}` } : {}),
+                    ...(token && !apiKey ? { Authorization: `Bearer ${token}` } : {})
+                }
+            });
+
+            return res.data;
+        } catch (error: any) {
+            throw error;
+        }
+    }
 
-  async getVerificationResult(session_id: string, apiKey?: string): Promise<any> {
-    try {
-      const token = apiKey ? undefined : await authentification();
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), 8000);
-      const headers: Record<string, string> = { 'Content-Type': 'application/json' };
-      if (apiKey) headers["Authorization"] = `ApiKey ${apiKey}`;
-      else if (token) headers["Authorization"] = `Bearer ${token}`;
-
-      const res = await axios.get(`${KYCConfig.getBackendUrl()}/verification/api/kyc/result/?session_id=${session_id}`, { headers, signal: controller.signal });
-      clearTimeout(timeoutId);
-      return res.data;
-    } catch (error: any) { throw error; }
-  }
-
-  async validateBackTemplate(params: { region: string; docType: string; frontTemplateName: string; backTemplateName: string; subRegion: string; token: string; }, env: KycEnvironment = 'PRODUCTION'): Promise<any> {
-    const queryParams = new URLSearchParams({ region: params.region, doc_type: params.docType, front_template_name: params.frontTemplateName, back_template_name: params.backTemplateName, sub_region: params.subRegion || "" }).toString();
-    try {
-      const res = await axios.post(`${this.mrzServiceURL}/validate_back_template/?${queryParams}`, null, {
-        headers: { 'Accept': 'application/json', 'Authorization': `Bearer ${params.token}` }, timeout: 20000,
-      });
-      return res.data;
-    } catch (e: any) { throw e; }
-  }
-
-  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;
-  }
-
-  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 sendWhatsAppVerificationCode(
-    sessionId: string,
-    phoneNumber: string,
-    auth?: { apiKey?: string; token?: string }
-  ): Promise<unknown> {
-    const url = `${KYCConfig.getBackendUrl()}/accounts/send-whatsapp-verification/`;
-    const formattedPhoneNumber = phoneNumber.replace(/^\+/, '');
-    const payload = { session_id: sessionId, phone_number: formattedPhoneNumber };
-    const token = auth?.apiKey ? undefined : (auth?.token ?? await authentification());
-    const headers = {
-      'Content-Type': 'application/json',
-      ...(auth?.apiKey ? { 'Authorization': `ApiKey ${auth.apiKey}` } : { 'Authorization': `Bearer ${token}` }),
-    };
-    try {
-      const res = await axios.post(url, payload, { headers });
-      logger.log("✅ WhatsApp Send Success:", res.data);
-      return res.data;
-    } catch (error: any) {
-      if (error.response) {
-        logger.error("🛑 WhatsApp Send Failed (Server Response):", { status: error.response.status, data: error.response.data, headers: error.response.headers });
-      }
-      throw error;
+    async getVerificationResult(session_id: string, apiKey?: string): Promise<any> {
+        try {
+            const token = apiKey ? undefined : await authentification();
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 8000);
+
+            const headers: Record<string, string> = {
+                'Content-Type': 'application/json'
+            };
+
+            if (apiKey) headers["Authorization"] = `ApiKey ${apiKey}`;
+            else if (token) headers["Authorization"] = `Bearer ${token}`;
+
+            const res = await axios.get(`${KYCConfig.getBackendUrl()}/verification/api/kyc/result/?session_id=${session_id}`, {
+                headers,
+                signal: controller.signal
+            });
+
+            clearTimeout(timeoutId);
+            return res.data;
+        } catch (error: any) {
+            throw error;
+        }
     }
-  }
-
-  async verifyWhatsAppCode(
-    sessionId: string,
-    otp: string,
-    phoneNumber: string,
-    auth?: { apiKey?: string; token?: string }
-  ): Promise<unknown> {
-    const url = `${KYCConfig.getBackendUrl()}/accounts/verify-whatsapp-code/`;
-    const formattedPhoneNumber = phoneNumber.replace(/^\+/, '');
-    const payload = { session_id: sessionId, verification_code: otp, phone_number: formattedPhoneNumber };
-    const token = auth?.apiKey ? undefined : (auth?.token ?? await authentification());
-    const headers = {
-      'Content-Type': 'application/json',
-      ...(auth?.apiKey ? { 'Authorization': `ApiKey ${auth.apiKey}` } : { 'Authorization': `Bearer ${token}` }),
-    };
-    try {
-      const res = await axios.post(url, payload, { headers });
-      return res.data;
-    } catch (error: any) {
-      if (error.response) {
-        logger.error("🛑 WhatsApp Verification Failed (Server Response):", { status: error.response.status, data: error.response.data, headers: error.response.headers });
-      }
-      throw error;
+
+    async validateBackTemplate(params: { region: string; docType: string; frontTemplateName: string; backTemplateName: string; subRegion: string; token: string; }, env: KycEnvironment = 'PRODUCTION'): Promise<any> {
+        const queryParams = new URLSearchParams({
+            region: params.region,
+            doc_type: params.docType,
+            front_template_name: params.frontTemplateName,
+            back_template_name: params.backTemplateName,
+            sub_region: params.subRegion || ""
+        }).toString();
+
+        try {
+            const res = await axios.post(`${this.mrzServiceURL}/validate_back_template/?${queryParams}`, null, {
+                headers: {
+                    'Accept': 'application/json',
+                    'Authorization': `Bearer ${params.token}`
+                },
+                timeout: 20000,
+            });
+            return res.data;
+        } catch (e: any) {
+            throw e;
+        }
     }
-  }
 
-  async generateReferralCode(
-    payload: { session_id: string; [key: string]: any },
-    apiKey: string
-  ): Promise<any> {
-    try {
-      logger.log(`Generating referral code for session: ${payload.session_id}`);
-      if (!apiKey) {
-        throw new Error("Authentication failed: API key is required.");
-      }
-      const url = `${KYCConfig.getBackendUrl()}/core/referral-code/generate/`;
-      const headers: Record<string, string> = {
-        "Content-Type": "application/json",
-        "Authorization": `ApiKey ${apiKey}`
-      };
-      const res = await axios.post(url, payload, { headers, timeout: 8000 });
-      logger.log("generateReferralCode SUCCESS:", JSON.stringify(res.data, null, 2));
-      return res.data;
-    } catch (error: any) {
-      const parsedError = errorMessage(error);
-      const finalErrorMessage = parsedError || error?.message || "Failed to generate referral code";
-      logger.error("Error generating referral code:", typeof finalErrorMessage === 'string' ? finalErrorMessage : JSON.stringify(finalErrorMessage));
-      throw new Error(typeof finalErrorMessage === 'string' ? finalErrorMessage : JSON.stringify(finalErrorMessage));
+    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;
+    }
+
+    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 sendWhatsAppVerificationCode(
+        sessionId: string,
+        phoneNumber: string,
+        auth?: { apiKey?: string; token?: string }
+    ): Promise<unknown> {
+        const url = `${KYCConfig.getBackendUrl()}/accounts/send-whatsapp-verification/`;
+        const formattedPhoneNumber = phoneNumber.replace(/^\+/, '');
+        const payload = { session_id: sessionId, phone_number: formattedPhoneNumber };
+        const token = auth?.apiKey ? undefined : (auth?.token ?? await authentification());
+
+        const headers = {
+            'Content-Type': 'application/json',
+            ...(auth?.apiKey ? { 'Authorization': `ApiKey ${auth.apiKey}` } : { 'Authorization': `Bearer ${token}` }),
+        };
+
+        try {
+            const res = await axios.post(url, payload, { headers });
+            logger.log("✅ WhatsApp Send Success:", res.data);
+            return res.data;
+        } catch (error: any) {
+            if (error.response) {
+                logger.error("🛑 WhatsApp Send Failed (Server Response):", {
+                    status: error.response.status,
+                    data: error.response.data,
+                    headers: error.response.headers
+                });
+            }
+            throw error;
+        }
+    }
+
+    async verifyWhatsAppCode(
+        sessionId: string,
+        otp: string,
+        phoneNumber: string,
+        auth?: { apiKey?: string; token?: string }
+    ): Promise<unknown> {
+        const url = `${KYCConfig.getBackendUrl()}/accounts/verify-whatsapp-code/`;
+        const formattedPhoneNumber = phoneNumber.replace(/^\+/, '');
+        const payload = { session_id: sessionId, verification_code: otp, phone_number: formattedPhoneNumber };
+        const token = auth?.apiKey ? undefined : (auth?.token ?? await authentification());
+
+        const headers = {
+            'Content-Type': 'application/json',
+            ...(auth?.apiKey ? { 'Authorization': `ApiKey ${auth.apiKey}` } : { 'Authorization': `Bearer ${token}` }),
+        };
+
+        try {
+            const res = await axios.post(url, payload, { headers });
+            return res.data;
+        } catch (error: any) {
+            if (error.response) {
+                logger.error("🛑 WhatsApp Verification Failed (Server Response):", {
+                    status: error.response.status,
+                    data: error.response.data,
+                    headers: error.response.headers
+                });
+            }
+            throw error;
+        }
+    }
+
+    async generateReferralCode(
+        payload: { session_id: string;[key: string]: any },
+        apiKey: string
+    ): Promise<any> {
+        try {
+            logger.log(`Generating referral code for session: ${payload.session_id}`);
+            if (!apiKey) {
+                throw new Error("Authentication failed: API key is required.");
+            }
+
+            const url = `${KYCConfig.getBackendUrl()}/core/referral-code/generate/`;
+            const headers: Record<string, string> = {
+                "Content-Type": "application/json",
+                "Authorization": `ApiKey ${apiKey}`
+            };
+
+            const res = await axios.post(url, payload, { headers, timeout: 8000 });
+            logger.log("generateReferralCode SUCCESS:", JSON.stringify(res.data, null, 2));
+            return res.data;
+        } catch (error: any) {
+            const parsedError = errorMessage(error);
+            const finalErrorMessage = parsedError || error?.message || "Failed to generate referral code";
+            logger.error("Error generating referral code:", typeof finalErrorMessage === 'string' ? finalErrorMessage : JSON.stringify(finalErrorMessage));
+            throw new Error(typeof finalErrorMessage === 'string' ? finalErrorMessage : JSON.stringify(finalErrorMessage));
+        }
     }
-  }
 }
 
 const kycService = new KYCService("", "");
 export default kycService;
 
-export function truncateFields(obj: any, maxLength = 420): any { /* logic unchanged */ return obj; }
+export function truncateFields(obj: any, maxLength = 420): any {
+    /* logic unchanged */
+    return obj;
+}
 
 export const authentification = async (): Promise<string> => {
-  try {
-    if (cachedToken && tokenExpiryTime && Date.now() < tokenExpiryTime - 10000) return cachedToken;
-    if (activeAuthRequest) return activeAuthRequest;
-    
-    activeAuthRequest = (async () => {
-      const res = await axios.post(
-        `https://idms.sanctumkey.com/realms/kyc/protocol/openid-connect/token`,
-        'client_id=kyc_frontend&client_secret=QhgAmvKgmwODzsEp98dnA4PeUEMMaFHd&grant_type=client_credentials',
-        { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } }
-      );
-      
-      const token = res.data.access_token;
-      if (!token) {
-        throw new Error("Keycloak returned a success response but no access_token was found.");
-      }
-      
-      cachedToken = token;
-      tokenExpiryTime = Date.now() + ((res.data.expires_in || 300) * 1000);
-      activeAuthRequest = null; // 🚨 FIX: Clear the promise once resolved
-      
-      return cachedToken as string;
-    })();
-    
-    return await activeAuthRequest;
-  } catch (error: any) {
-    cachedToken = null;
-    tokenExpiryTime = null; 
-    activeAuthRequest = null;
-    
-    const safeErrorMessage = error?.response?.data?.error_description || error?.message || 'Unknown error';
-    logger.error('Error authentifying:', safeErrorMessage);
-    throw new Error(`Échec de l'authentification: ${safeErrorMessage}`);
-  }
+    try {
+        if (cachedToken && tokenExpiryTime && Date.now() < tokenExpiryTime - 10000) return cachedToken;
+        if (activeAuthRequest) return activeAuthRequest;
+
+        activeAuthRequest = (async () => {
+            const res = await axios.post(
+                `https://idms.sanctumkey.com/realms/kyc/protocol/openid-connect/token`,
+                'client_id=kyc_frontend&client_secret=QhgAmvKgmwODzsEp98dnA4PeUEMMaFHd&grant_type=client_credentials',
+                { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } }
+            );
+
+            const token = res.data.access_token;
+            if (!token) {
+                throw new Error("Keycloak returned a success response but no access_token was found.");
+            }
+
+            cachedToken = token;
+            tokenExpiryTime = Date.now() + ((res.data.expires_in || 300) * 1000);
+            activeAuthRequest = null; // 🚨 FIX: Clear the promise once resolved
+            return cachedToken as string;
+        })();
+
+        return await activeAuthRequest;
+    } catch (error: any) {
+        cachedToken = null;
+        tokenExpiryTime = null;
+        activeAuthRequest = null;
+        const safeErrorMessage = error?.response?.data?.error_description || error?.message || 'Unknown error';
+        logger.error('Error authentifying:', safeErrorMessage);
+        throw new Error(`Échec de l'authentification: ${safeErrorMessage}`);
+    }
 }
 
 export const clearAuthToken = () => {
-  logger.log("Wiping AI services auth token cache...");
-  cachedToken = null;
-  tokenExpiryTime = null;
-  activeAuthRequest = null;
+    logger.log("Wiping AI services auth token cache...");
+    cachedToken = null;
+    tokenExpiryTime = null;
+    activeAuthRequest = null;
 };
 
-
 export const errorMessage = (error: any) => {
-  return error.response?.data?.message || error.response?.data?.detail || error.response?.data?.error || error.response?.data || error.message;
+    return error.response?.data?.message || error.response?.data?.detail || error.response?.data?.error || error.response?.data || error.message;
 }