@sanctum-key/react-native-sdk 1.0.32 → 1.0.34

package/src/modules/api/KYCService.ts

@@ -23,19 +23,17 @@ const documentTypeMap: Record<string, string> = {
   healthInsuranceCard: "health_insurance_card",
   residencePermit: "permanent_residence_card",
   identityCard: "identity_card",
-
-  nationalId: "identity_card",          // We saw this in your earlier logs!
-  national_id: "identity_card",
-  
-  drivers_licence: "driving_licence",   // Plural 'drivers' to singular 'driving'
-  drivers_license: "driving_licence",   // American spelling 'license'
-  driving_license: "driving_licence",   // American spelling 'license'
-  permanent_residence: "permanent_residence_card", // Missing the word '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; 
+let activeAuthRequest: Promise<string> | null = null;
 
 export interface KYCRequest {
   userId: string;
@@ -71,11 +69,10 @@ export interface SelfieVideoResponse {
   error: string;
 }
 
-
 export class KYCService {
   private baseURL: string;
   private apiKey: string;
-  // Additional service base URLs (fixed as per current infra)
+  
   private faceServiceURL = 'https://face-infera.sanctumkey.com';
   private textExtractionServiceURL = 'https://text-infera.sanctumkey.com';
   private mrzServiceURL = 'https://mrz-infera.sanctumkey.com';
@@ -150,7 +147,6 @@ export class KYCService {
   }
 
   async processSelfieOrientationPicture(videoFile: string, token: string): Promise<SelfieVideoResponse[]> {
-    
     try {
       const formData = new FormData();
       await appendFileToFormData(formData, 'file', videoFile, 'selfie_picture.jpg', 'image/jpeg');
@@ -160,7 +156,10 @@ export class KYCService {
         formData,
         {
           timeout: 20000,
-          headers: { 'Content-Type': 'multipart/form-data', 'Authorization': `Bearer ${token}`, },
+          headers: {
+            // 🚨 Removed explicit Content-Type to allow boundary injection
+            'Authorization': `Bearer ${token}`,
+          },
         }
       );
       return response.data;
@@ -172,7 +171,6 @@ export class KYCService {
 
   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");
@@ -187,11 +185,9 @@ export class KYCService {
         };
       }
 
-      // 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,
@@ -208,8 +204,6 @@ export class KYCService {
       };
     } 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,
@@ -221,7 +215,6 @@ export class KYCService {
           message: 'Service temporarily unavailable'
         };
       }
-
       return {
         success: false,
         error: {
@@ -236,13 +229,11 @@ export class KYCService {
 
   // STEP 1 - ID CARD VALIDATION
   async detectFaceOnId(
-    idCardImageUri: string, 
-    token: string, 
-    docType: string, 
+    idCardImageUri: string,
+    token: string,
+    docType: string,
     env: KycEnvironment = 'PRODUCTION'
-  ): Promise<{ result: boolean; detail: any[]; card_obb?: any }> { // Added card_obb to signature
-    
-    // SANDBOX mode
+  ): Promise<{ result: boolean; detail: any[]; card_obb?: any }> {
     if (env === 'SANDBOX') {
       logger.log("SANDBOX mode: Returning mock face detection response");
       return {
@@ -251,39 +242,33 @@ export class KYCService {
         card_obb: { x: 50, y: 50, width: 200, height: 200 }
       };
     }
-  
+
     const formData = new FormData();
     await appendFileToFormData(formData, 'file', idCardImageUri, 'id_card_photo.jpg', 'image/jpeg');
-  
-    const docTypeShorted = GovernmentDocumentTypeShorted[docType as GovernmentDocumentType] || docType;
 
-    // Log metadata, NOT the FormData object
+    const docTypeShorted = GovernmentDocumentTypeShorted[docType as GovernmentDocumentType] || docType;
     logger.log('detectFaceOnId Request:', { docTypeShorted, imageUri: idCardImageUri });
-  
+
     try {
       const res = await axios.post(
-        `${this.faceServiceURL}/detect_face/?doc_type=${docTypeShorted}`, 
+        `${this.faceServiceURL}/detect_face/?doc_type=${docTypeShorted}`,
         formData,
         {
-          headers: { 
-            'Content-Type': 'multipart/form-data', 
-            'Authorization': `Bearer ${token}` 
+          headers: {
+            // 🚨 Removed explicit Content-Type to allow boundary injection
+            'Authorization': `Bearer ${token}`
           },
-          timeout: 20000 // 20 seconds is good, but ensure the image is compressed before this step!
+          timeout: 20000 
         }
       );
       
-      // It's safe to stringify res.data if the backend returns a clean JSON object
       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: any) {
-      // Use your safe error extractor, avoid JSON.stringify on raw Axios errors
       const safeError = errorMessage(error) || error.message;
       logger.error('Error detecting face on id:', safeError);
       throw error;
@@ -292,18 +277,16 @@ export class KYCService {
 
   //check templatetemplate_type
   async checkTemplateType(
-    params: { 
-      fileUri: string; 
-      docType: string; 
-      docRegion: string; 
-      token: string; 
+    params: {
+      fileUri: string;
+      docType: string;
+      docRegion: string;
+      token: string;
       postfix: string;
-      issuingSubdivision?: string; 
-    }, 
+      issuingSubdivision?: 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");
@@ -315,26 +298,28 @@ export class KYCService {
     }
 
     const { fileUri, docType, docRegion, token, postfix, issuingSubdivision } = params;
+
     const formData = new FormData();
-    
     await appendFileToFormData(formData, 'file', fileUri, `id_card_${postfix}.jpg`, 'image/jpeg');
 
     const docTypeShorted = GovernmentDocumentTypeShorted[docType as GovernmentDocumentType];
     
-    // Build the base URL
     let url = `${this.mrzServiceURL}/get_template_version/?doc_type=${encodeURIComponent(docTypeShorted)}&doc_region=${encodeURIComponent(docRegion)}&postfix=${postfix}`;
-
     if (issuingSubdivision) {
       url += `&issuing_subdivision=${encodeURIComponent(issuingSubdivision)}`;
     }
 
     logger.log('checkTemplateType params', this.mrzServiceURL, JSON.stringify({ fileUri, docTypeShorted, docRegion, issuingSubdivision, token, postfix, url }, null, 2));
-    
+
     try {
       const res = await axios.post<CheckTemplateTypeResponse>(url, formData, {
-        headers: { 'Content-Type': 'multipart/form-data', 'Authorization': `Bearer ${token}`, },
+        headers: {
+          // 🚨 Removed explicit Content-Type to allow boundary injection
+          'Authorization': `Bearer ${token}`,
+        },
         timeout: 60000,
       });
+
       logger.log('checkTemplateType res', JSON.stringify(res.data, null, 2));
       return res.data;
     } catch (e: any) {
@@ -343,69 +328,62 @@ export class KYCService {
     }
   }
 
-  async extractDocumentInformation(params: { 
-    fileUri: string; 
-    docType: string; 
-    docRegion: string; 
-    templatePath: string; 
+  async extractDocumentInformation(params: {
+    fileUri: string;
+    docType: string;
+    docRegion: string;
+    templatePath: string;
     issuingSubdivision?: string;
-    token: string; 
-    postfix?: string 
+    token: string;
+    postfix?: string
   }): Promise<any> {
     const { fileUri, docType, docRegion, templatePath, issuingSubdivision, token, postfix = 'front' } = params;
-    
-    // 1. Prepare Form Data
+
     const formData = new FormData();
     await appendFileToFormData(formData, 'file', fileUri, `id_card_${postfix}.jpg`, 'image/jpeg');
 
     let queryParams = `doc_type=${encodeURIComponent(docType)}&doc_region=${encodeURIComponent(docRegion)}&template_path=${encodeURIComponent(templatePath)}&postfix=${postfix}&cleaned=true`;
-    
     if (issuingSubdivision) {
       queryParams += `&issuing_subdivision=${encodeURIComponent(issuingSubdivision)}`;
     }
+
     logger.log(`URL PARAMS: ${queryParams}`)
-    
     const url = `${this.textExtractionServiceURL}/extract_doc_information/?${queryParams}`;
 
     try {
       const startRes = await axios.post(url, formData, {
-        headers: { 'Content-Type': 'multipart/form-data', 'Authorization': `Bearer ${token}` },
+        headers: {
+          // 🚨 Removed explicit Content-Type to allow boundary injection
+          'Authorization': `Bearer ${token}`
+        },
         timeout: 60000,
       });
-      
+
       const jobId = startRes.data?.job_id;
       if (!jobId) throw new Error("Backend did not return a job_id");
-
       logger.log(`Extraction job started: ${jobId}. Polling for results...`);
 
-      // 4. Poll the Status Endpoint
       const statusUrl = `${this.textExtractionServiceURL}/extract_doc_information/status/${jobId}`;
-      
-      // Poll every 2 seconds, up to 15 times (30 seconds max)
       const maxRetries = 15;
+
       for (let i = 0; i < maxRetries; i++) {
-        // Wait 2 seconds before checking
         await new Promise(resolve => setTimeout(resolve, 2000));
-        
         const statusRes = await axios.get(statusUrl, {
-           headers: { 'Authorization': `Bearer ${token}` }
+          headers: {
+            'Authorization': `Bearer ${token}`
+          }
         });
-
         const statusData = statusRes.data;
 
         if (statusData.status === 'completed') {
           logger.log('Extraction completed successfully', JSON.stringify(truncateFields(statusData.result)));
-          return statusData.result; 
+          return statusData.result;
         }
-
         if (statusData.status === 'failed') {
           throw new Error(statusData.error || "Document extraction failed during processing.");
         }
-
       }
-
       throw new Error("Document extraction timed out waiting for results.");
-
     } catch (e: any) {
       const errorMsg = e.response?.data?.detail || e.message;
       logger.error('Error extracting document information:', errorMsg);
@@ -414,20 +392,16 @@ export class KYCService {
   }
 
   async extractBarcode(params: { fileUri: string; token: string; docType: 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 }
-      };
+      return { barcode_data: 'SANDBOX_MOCK_BARCODE_DATA', card_obb: { x: 50, y: 50, width: 200, height: 200 } };
     }
 
     const { fileUri, token, docType, postfix = 'back' } = params;
     logger.log(docType)
-    const formData = new FormData();
     
+    const formData = new FormData();
     await appendFileToFormData(formData, 'file', fileUri, `id_${postfix}_photo.jpg`, 'image/jpeg');
 
     const url = `${this.barcodeServiceURL}/decode_barcode/?doc_type=${encodeURIComponent(docType)}`;
@@ -435,13 +409,13 @@ export class KYCService {
     const attempt = async () => {
       try {
         const res = await axios.post(url, formData, {
-          headers: { 'Content-Type': 'multipart/form-data', 'Authorization': `Bearer ${token}` },
+          headers: {
+            // 🚨 Removed explicit Content-Type to allow boundary injection
+            'Authorization': `Bearer ${token}`
+          },
           timeout: 60000,
         });
-        
         logger.log('📦 Raw extractBarcode response:', JSON.stringify(res.data, null, 2));
-        
-        
         return res.data;
       } catch (e: any) {
         throw new Error(e?.message || 'Erreur de détection du code-barres');
@@ -457,20 +431,15 @@ export class KYCService {
   }
 
   async formatBarcodeData(params: { textInput: string; token: string }, env: KycEnvironment = 'PRODUCTION'): Promise<any> {
-    // SANDBOX mode
     if (env === 'SANDBOX') {
       console.log("SANDBOX mode: Skipping AI barcode formatting");
       logger.log("SANDBOX mode: Returning mock formatted barcode response");
-      return {
-        barcode_type: "SANDBOX_MOCK",
-        first_name: "JOHN",
-        last_name: "DOE",
-        card_number: "000000000000"
-      };
+      return { barcode_type: "SANDBOX_MOCK", first_name: "JOHN", last_name: "DOE", card_number: "000000000000" };
     }
 
     const { textInput, token } = params;
     
+    // URLSearchParams requires urlencoded, this remains untouched
     const formData = new URLSearchParams();
     formData.append('text_input', textInput);
 
@@ -479,15 +448,13 @@ export class KYCService {
     const attempt = async () => {
       try {
         const res = await axios.post(url, formData.toString(), {
-          headers: { 
-            'Content-Type': 'application/x-www-form-urlencoded', 
-            'Authorization': `Bearer ${token}` 
+          headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'Authorization': `Bearer ${token}`
           },
           timeout: 60000,
         });
-        
         logger.log('📦 Raw formatBarcodeData response:', JSON.stringify(res.data, null, 2));
-        
         return res.data;
       } catch (e: any) {
         throw new Error(e?.message || 'Erreur de formatage du code-barres');
@@ -502,7 +469,6 @@ export class KYCService {
     }
   }
 
-
   async extractMrzText(
     params: {
       fileUri: string;
@@ -514,125 +480,107 @@ export class KYCService {
       mrz_type?: string;
     },
     env: KycEnvironment = 'PRODUCTION'
- ): Promise<any> {
-   // SANDBOX mode
-   if (env === 'SANDBOX') {
-     console.log("SANDBOX mode: Skipping AI MRZ extraction");
-     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;
-
-   // ... top of extractMrzText (params extraction, etc) ...
-   const docTypeShorted = GovernmentDocumentTypeShorted[docType as GovernmentDocumentType] || docType;
-   const safeMrzType = mrz_type && mrz_type.trim() !== '' ? mrz_type : 'TD1';
-   
-   logger.log("docTypeShorted", docTypeShorted, docRegion, postfix);
-
-   const queryParams = new URLSearchParams({
-       doc_type: docTypeShorted,
-       doc_region: docRegion,
-       postfix: postfix,
-       template_path: template_path,
-       mrz_type: safeMrzType,
-       reset_cache: 'true'
-   }).toString();
-
-   const url = `${this.mrzServiceURL}/extract_mrz_text/?${queryParams}`;
-   logger.log("url", url);
-
-   try {
-     let response;
-
-     if (Platform.OS === 'web') {
-         const nativeFetch = window.fetch;
-         const NativeFormData = window.FormData;
-
-         const formData = new NativeFormData();
-         
-         // Fetch the Blob natively
-         const fileReq = await nativeFetch(fileUri);
-         const blob = await fileReq.blob();
-         
-         // Append the Blob. The native browser will perfectly handle the multipart boundary.
-         formData.append('file', blob, `id_card_${postfix}.jpg`);
-
-         // Execute using Native Fetch!
-         response = await nativeFetch(url, {
-             method: 'POST',
-             headers: { 
-                 'Authorization': `Bearer ${token}`,
-                 'Accept': 'application/json'
-             },
-             body: formData,
-         });
-
-     } else {
-         // 📱 MOBILE NATIVE: React Native's Native Bridge expects this exact object
-         const formData = new FormData();
-         const filePayload = {
-             uri: fileUri, 
-             type: 'image/jpeg',
-             name: `id_card_${postfix}.jpg`,
-         };
-         formData.append('file', filePayload as any);
-
-         response = await fetch(url, {
-             method: 'POST',
-             headers: { 
-                 'Authorization': `Bearer ${token}`,
-                 'Accept': 'application/json'
-             },
-             body: formData,
-         });
-     }
-
-     if (!response.ok) {
-         const errorText = await response.text();
-         logger.error('Backend MRZ Error Details:', errorText);
-         throw new Error(`Erreur serveur: ${response.status}`);
-     }
-
-     const data = await response.json();
-     logger.log('extractMrzText res', JSON.stringify(data, null, 2));
-
-     if (Object.keys(data).length === 0) throw new Error('No data found');
-     
-     if (data?.success === false) {
-         const serverMessage = data.parsed_data?.status_message || data.parsed_data?.status || 'Échec de l\'extraction MRZ';
-         throw new Error(`Lecture MRZ refusée: ${serverMessage}`);
-     }
-
-     return data;
-
-   } catch (error: any) {
-     logger.error("MRZ Fetch Error: ", error?.message || error);
-     throw new Error(error?.message || 'Erreur de connexion lors de l\'extraction MRZ');
-   }
- }
+  ): Promise<any> {
+    if (env === 'SANDBOX') {
+      console.log("SANDBOX mode: Skipping AI MRZ extraction");
+      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 docTypeShorted = GovernmentDocumentTypeShorted[docType as GovernmentDocumentType] || docType;
+    const safeMrzType = mrz_type && mrz_type.trim() !== '' ? mrz_type : 'TD1';
+
+    logger.log("docTypeShorted", docTypeShorted, docRegion, postfix);
+
+    const queryParams = new URLSearchParams({
+      doc_type: docTypeShorted,
+      doc_region: docRegion,
+      postfix: postfix,
+      template_path: template_path,
+      mrz_type: safeMrzType,
+      reset_cache: 'true'
+    }).toString();
+
+    const url = `${this.mrzServiceURL}/extract_mrz_text/?${queryParams}`;
+    logger.log("url", url);
+
+    try {
+      let response;
+
+      if (Platform.OS === 'web') {
+        const nativeFetch = window.fetch;
+        const NativeFormData = window.FormData;
+        const formData = new NativeFormData();
+        const fileReq = await nativeFetch(fileUri);
+        const blob = await fileReq.blob();
+        formData.append('file', blob, `id_card_${postfix}.jpg`);
+
+        response = await nativeFetch(url, {
+          method: 'POST',
+          headers: {
+            'Authorization': `Bearer ${token}`,
+            'Accept': 'application/json'
+          },
+          body: formData,
+        });
+      } else {
+        // 📱 NATIVE FETCH APPROACH (Untouched, robust as is)
+        const formData = new FormData();
+        const filePayload = {
+          uri: fileUri,
+          type: 'image/jpeg',
+          name: `id_card_${postfix}.jpg`,
+        };
+        formData.append('file', filePayload as any);
+
+        response = await fetch(url, {
+          method: 'POST',
+          headers: {
+            'Authorization': `Bearer ${token}`,
+            'Accept': 'application/json'
+          },
+          body: formData,
+        });
+      }
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        logger.error('Backend MRZ Error Details:', errorText);
+        throw new Error(`Erreur serveur: ${response.status}`);
+      }
+      const data = await response.json();
+      logger.log('extractMrzText res', JSON.stringify(data, null, 2));
+
+      if (Object.keys(data).length === 0) throw new Error('No data found');
+      if (data?.success === false) {
+        const serverMessage = data.parsed_data?.status_message || data.parsed_data?.status || 'Échec de l\'extraction MRZ';
+        throw new Error(`Lecture MRZ refusée: ${serverMessage}`);
+      }
+      return data;
+    } catch (error: any) {
+      logger.error("MRZ Fetch Error: ", error?.message || error);
+      throw new Error(error?.message || 'Erreur de connexion lors de l\'extraction MRZ');
+    }
+  }
 
   // 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]
-      };
+      return { is_match: true, similarity: 0.95, id_bbox: [50, 50, 200, 200], selfie_bbox: [50, 50, 200, 200] };
     }
 
     const { idPhotoUri, selfiePhotoUri } = params;
@@ -640,7 +588,11 @@ export class KYCService {
     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 });
+    const res = await axios.post(`${this.faceServiceURL}/recognize_face/`, formData, { 
+      // Let Axios determine Content-Type boundary natively
+      timeout: 45000 
+    });
+
     if (res.data?.detail) throw new Error(res.data.detail);
     return res.data;
   }
@@ -672,8 +624,7 @@ export class KYCService {
         "status": "PENDING",
         "metadata": {},
       }
-      const res = await axios.post<SessionResponse>(`${KYCConfig.getBackendUrl()}/verification/sessions/`,
-        data, {
+      const res = await axios.post<SessionResponse>(`${KYCConfig.getBackendUrl()}/verification/sessions/`, data, {
         headers: {
           'Content-Type': 'application/json',
           ...(apiKey ? { 'Authorization': `ApiKey ${apiKey}` } : { 'Authorization': `Bearer ${token}` })
@@ -682,146 +633,112 @@ export class KYCService {
       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> {
-  try {
-    const { session_id, step, data, templateId, action, apiKey } = payload;
-    const token = apiKey ? undefined : await authentification();
-
-    if (!apiKey && !token) {
-      throw new Error("Authentication failed: No API key or Token available.");
-    }
-
-    // 1. Original Shallow Clone (Preserves file paths perfectly)
-    const normalizedData = { ...data };
-
-    logger.log("🔍 [DocType Check] Raw incoming data.metadata.document_type:", normalizedData?.metadata?.document_type);
-    logger.log("🔍 [DocType Check] Raw incoming data.documentType:", normalizedData?.documentType);
-
-    // Enhanced fallback to guarantee we find the document type
-    const rawDocType = 
-      normalizedData?.metadata?.document_type || 
-      normalizedData?.documentType || 
-      normalizedData?.documents?.documentType;
-
-    if (rawDocType) {
-      const originalDocType = rawDocType;
-      const mappedDocType = documentTypeMap[originalDocType] ?? originalDocType;
-
-      normalizedData.metadata = {
-        ...normalizedData.metadata,
-        document_type: mappedDocType,
-      };
+    try {
+      const { session_id, step, data, templateId, action, apiKey } = payload;
+      const token = apiKey ? undefined : await authentification();
+      if (!apiKey && !token) {
+        throw new Error("Authentication failed: No API key or Token available.");
+      }
       
-      normalizedData.documentType = mappedDocType;
-
-      if (normalizedData.documents) {
-        normalizedData.documents = {
-          ...normalizedData.documents,
-          documentType: mappedDocType
+      const normalizedData = { ...data };
+      logger.log("🔍 [DocType Check] Raw incoming data.metadata.document_type:", normalizedData?.metadata?.document_type);
+      logger.log("🔍 [DocType Check] Raw incoming data.documentType:", normalizedData?.documentType);
+      
+      const rawDocType = normalizedData?.metadata?.document_type || normalizedData?.documentType || normalizedData?.documents?.documentType;
+      
+      if (rawDocType) {
+        const originalDocType = rawDocType;
+        const mappedDocType = documentTypeMap[originalDocType] ?? originalDocType;
+        normalizedData.metadata = {
+          ...normalizedData.metadata,
+          document_type: mappedDocType,
         };
-
-        const isSingleSided = ['passport', 'visa'].includes(mappedDocType.toLowerCase());
-        if (isSingleSided && !normalizedData.documents.back) {
-          normalizedData.documents.back = {}; 
-        }
-
-        if (normalizedData.documents.front?.mrz && typeof normalizedData.documents.front.mrz === 'string') {
-          try {
-            normalizedData.documents.front = {
-              ...normalizedData.documents.front,
-              mrz: JSON.parse(normalizedData.documents.front.mrz)
-            };
-          } catch (e) {
-            logger.log("Warning: Could not parse front MRZ JSON");
+        normalizedData.documentType = mappedDocType;
+        if (normalizedData.documents) {
+          normalizedData.documents = { ...normalizedData.documents, documentType: mappedDocType };
+          const isSingleSided = ['passport', 'visa'].includes(mappedDocType.toLowerCase());
+          if (isSingleSided && !normalizedData.documents.back) {
+            normalizedData.documents.back = {};
           }
-        }
-
-        if (normalizedData.documents.back?.mrz && typeof normalizedData.documents.back.mrz === 'string') {
-          try {
-            normalizedData.documents.back = {
-              ...normalizedData.documents.back,
-              mrz: JSON.parse(normalizedData.documents.back.mrz)
-            };
-          } catch (e) {
-            logger.log("Warning: Could not parse back MRZ JSON");
+          if (normalizedData.documents.front?.mrz && typeof normalizedData.documents.front.mrz === 'string') {
+            try {
+              normalizedData.documents.front = { ...normalizedData.documents.front, mrz: JSON.parse(normalizedData.documents.front.mrz) };
+            } catch (e) {
+              logger.log("Warning: Could not parse front MRZ JSON");
+            }
+          }
+          if (normalizedData.documents.back?.mrz && typeof normalizedData.documents.back.mrz === 'string') {
+            try {
+              normalizedData.documents.back = { ...normalizedData.documents.back, mrz: JSON.parse(normalizedData.documents.back.mrz) };
+            } catch (e) {
+              logger.log("Warning: Could not parse back MRZ JSON");
+            }
           }
         }
       }
-    }
-
-    const payloadData = {
-      action,
-      data: {
-        ...normalizedData,
-        step,
-        templateId,
-      },
-      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(
-        {
-          url,
-          apiKey: apiKey ? "***HIDDEN***" : "None",
-          token: token ? "***HIDDEN***" : "None",
-          payload: logPayload,
+      const payloadData = {
+        action,
+        data: {
+          ...normalizedData,
+          step,
+          templateId,
         },
-        null,
-        2
-      )
-    );
-
-    const headers: Record<string, string> = {
-      "Content-Type": "application/json",
-      ...(apiKey ? { Authorization: `ApiKey ${apiKey}` } : {}),
-      ...(token && !apiKey ? { Authorization: `Bearer ${token}` } : {})
-    };
-
-    const res = await axios.post<SessionResponse>(url, payloadData, { headers });
+        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(
+          {
+            url,
+            apiKey: apiKey ? "***HIDDEN***" : "None",
+            token: token ? "***HIDDEN***" : "None",
+            payload: logPayload,
+          },
+          null,
+          2
+        )
+      );
 
-    logger.log(
-      "verificationSession res",
-      JSON.stringify(truncateFields(res.data), null, 2)
-    );
-    return res.data;
+      const headers: Record<string, string> = {
+        "Content-Type": "application/json",
+        ...(apiKey ? { Authorization: `ApiKey ${apiKey}` } : {}),
+        ...(token && !apiKey ? { Authorization: `Bearer ${token}` } : {})
+      };
 
-  } catch (error: any) {
-    const parsedError = errorMessage(error);
-    const finalErrorMessage = parsedError || error?.message || "Unknown validation error";
-    
-    logger.error(
-      "Error validating component:",
-      JSON.stringify(finalErrorMessage, null, 2)
-    );
-    throw new Error(typeof finalErrorMessage === 'string' ? finalErrorMessage : JSON.stringify(finalErrorMessage));
+      const res = await axios.post<SessionResponse>(url, payloadData, { headers });
+      
+      logger.log(
+        "verificationSession res",
+        JSON.stringify(truncateFields(res.data), null, 2)
+      );
+      return res.data;
+    } catch (error: any) {
+      const parsedError = errorMessage(error);
+      const finalErrorMessage = parsedError || error?.message || "Unknown validation error";
+      logger.error(
+        "Error validating component:",
+        JSON.stringify(finalErrorMessage, null, 2)
+      );
+      throw new Error(typeof finalErrorMessage === 'string' ? finalErrorMessage : JSON.stringify(finalErrorMessage));
+    }
   }
-}
 
-  /** Send email verification code. POST /api/v1/accounts/email/send/ */
-  async sendEmailVerificationCode(
-    email: string,
-    auth?: { apiKey?: string; token?: string }
-  ): Promise<unknown> {
+  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(
@@ -837,11 +754,7 @@ export class KYCService {
     return res.data;
   }
 
-  /** Verify email with OTP. POST /api/v1/accounts/email/verify/ */
-  async verifyEmailCode(
-    otp: string,
-    auth?: { apiKey?: string; token?: string }
-  ): Promise<unknown> {
+  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(
@@ -859,231 +772,168 @@ export class KYCService {
 
   async getVerificationResult(session_id: string, apiKey?: string): Promise<any> {
     try {
-  
       const token = apiKey ? undefined : await authentification();
-  
       const url = `${KYCConfig.getBackendUrl()}/verification/api/kyc/result/?session_id=${session_id}`;
-  
       const controller = new AbortController();
       const timeoutId = setTimeout(() => {
         logger.log("⏳ 8 seconds passed. Force-killing hanging Axios request...");
         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}`;
       }
-  
       logger.log("3. Firing Axios GET to:", url);
-  
-      const res = await axios.get(url, {
-        headers,
-        signal: controller.signal 
-      });
-  
-      // Clear the timeout if the request succeeds!
+      
+      const res = await axios.get(url, { headers, signal: controller.signal });
       clearTimeout(timeoutId);
       
       return res.data;
-  
     } catch (error: any) {
-      // Catch the AbortController kill signal and format it as a timeout
       if (axios.isCancel(error) || error.name === 'AbortError' || error.name === 'CanceledError') {
         logger.error('Axios request was forcefully aborted due to timeout');
         throw new Error('Timeout exceeded');
       }
-  
       logger.error('Error getting verification result:', JSON.stringify(errorMessage(error) || error.message, null, 2));
       throw error;
     }
   }
 
-  /** Send WhatsApp verification code. POST /api/v1/accounts/send-whatsapp-verification/ */
   async sendWhatsAppVerificationCode(
     sessionId: string,
     phoneNumber: string,
     auth?: { apiKey?: string; token?: string }
   ): Promise<unknown> {
     const url = `${KYCConfig.getBackendUrl()}/accounts/send-whatsapp-verification/`;
-    
-    // 1. Formatting (Ensure consistency with verification step)
     const formattedPhoneNumber = phoneNumber.replace(/^\+/, '');
-    
-    // 2. Prepare Payload
-    const payload = {
-        session_id: sessionId,
-        phone_number: formattedPhoneNumber
-    };
-
-
-
+    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}` }),
+      '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;
-        
+      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;
+      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, 
+    phoneNumber: string,
     auth?: { apiKey?: string; token?: string }
   ): Promise<unknown> {
-    const url = `${KYCConfig.getBackendUrl()}/accounts/verify-whatsapp-code/`; 
-    
+    const url = `${KYCConfig.getBackendUrl()}/accounts/verify-whatsapp-code/`;
     const formattedPhoneNumber = phoneNumber.replace(/^\+/, '');
-    
-    const payload = {
-        session_id: sessionId,
-        verification_code: otp,
-        phone_number: formattedPhoneNumber
-    };
-
-
-
+    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}` }),
+      '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;
-        
+      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;
+      if (error.response) {
+        logger.error("🛑 WhatsApp Verification Failed (Server Response):", {
+          status: error.response.status,
+          data: error.response.data,
+          headers: error.response.headers
+        });
+      }
+      throw error;
     }
-}
-
-// Inside KYCService.ts
-
-async validateBackTemplate(params: {
-  region: string;
-  docType: string;
-  frontTemplateName: string;
-  backTemplateName: string;
-  subRegion: string;
-  token: string;
-}, env: KycEnvironment = 'PRODUCTION'): Promise<any> {
-  if (env === 'SANDBOX') {
-    logger.log("SANDBOX mode: Skipping back template validation");
-    return { is_match: true, status_message: "SANDBOX: Valid Match" };
   }
 
-  const { region, docType, frontTemplateName, backTemplateName, subRegion, token } = params;
-  
-  const queryParams = new URLSearchParams({
-    region: region,
-    doc_type: docType,
-    front_template_name: frontTemplateName,
-    back_template_name: backTemplateName,
-    sub_region: subRegion || ""
-  }).toString();
-
-  const url = `${this.mrzServiceURL}/validate_back_template/?${queryParams}`;
-
-  logger.log('validateBackTemplate URL', url);
-
-  try {
-    // Pass `null` for the body since the data is now in the URL
-    const res = await axios.post(url, null, {
-      headers: { 
-        'Accept': 'application/json',
-        'Authorization': `Bearer ${token}` 
-      },
-      timeout: 20000,
-    });
-    logger.log('validateBackTemplate res', JSON.stringify(res.data, null, 2));
-    return res.data;
-  } catch (e: any) {
-    const errorMsg = e.response?.data?.detail || e.response?.data?.Error || e.message;
-    logger.error('Error validating back template:', JSON.stringify(errorMsg));
-    throw new Error(typeof errorMsg === 'string' ? errorMsg : 'Template validation failed');
+  async validateBackTemplate(params: {
+    region: string;
+    docType: string;
+    frontTemplateName: string;
+    backTemplateName: string;
+    subRegion: string;
+    token: string;
+  }, env: KycEnvironment = 'PRODUCTION'): Promise<any> {
+    if (env === 'SANDBOX') {
+      logger.log("SANDBOX mode: Skipping back template validation");
+      return { is_match: true, status_message: "SANDBOX: Valid Match" };
+    }
+    const { region, docType, frontTemplateName, backTemplateName, subRegion, token } = params;
+    const queryParams = new URLSearchParams({
+      region: region,
+      doc_type: docType,
+      front_template_name: frontTemplateName,
+      back_template_name: backTemplateName,
+      sub_region: subRegion || ""
+    }).toString();
+    const url = `${this.mrzServiceURL}/validate_back_template/?${queryParams}`;
+    logger.log('validateBackTemplate URL', url);
+    
+    try {
+      const res = await axios.post(url, null, {
+        headers: {
+          'Accept': 'application/json',
+          'Authorization': `Bearer ${token}`
+        },
+        timeout: 20000,
+      });
+      logger.log('validateBackTemplate res', JSON.stringify(res.data, null, 2));
+      return res.data;
+    } catch (e: any) {
+      const errorMsg = e.response?.data?.detail || e.response?.data?.Error || e.message;
+      logger.error('Error validating back template:', JSON.stringify(errorMsg));
+      throw new Error(typeof errorMsg === 'string' ? errorMsg : 'Template validation failed');
+    }
   }
-}
 
-/**
-   * Generates a new referral code for a specific session.
-   * Endpoint: POST /api/v1/core/referral-code/generate/
-   */
-async generateReferralCode(
-  payload: { session_id: string; [key: string]: any }, 
-  apiKey: string // 🚨 Now strictly required
-): Promise<any> {
-  try {
-    logger.log(`Generating referral code for session: ${payload.session_id}`);
-
-    if (!apiKey) {
-      throw new Error("Authentication failed: API key is required.");
+  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 url = `${KYCConfig.getBackendUrl()}/core/referral-code/generate/`;
-
-    const headers: Record<string, string> = {
-      "Content-Type": "application/json",
-      "Authorization": `ApiKey ${apiKey}` // 🚨 Strictly using 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;
 
-// 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));
@@ -1102,28 +952,18 @@ export function truncateFields(obj: any, maxLength = 420): any {
   return truncated;
 }
 
-
-
-
-// Strictly define the return type as Promise<string>
 export const authentification = async (): Promise<string> => {
   try {
-    // 1. If we have a valid token (with 10 seconds of breathing room), return it immediately
     if (cachedToken && tokenExpiryTime && Date.now() < tokenExpiryTime - 10000) {
       return cachedToken;
     }
-
-    // 2. RACE CONDITION PREVENTION
     if (activeAuthRequest) {
       return activeAuthRequest;
     }
-
-    // 3. Create the request and lock it
+    
     activeAuthRequest = (async () => {
       logger.log('Authenticating: Fetching new Keycloak token...');
-      
       const params = 'client_id=kyc_frontend&client_secret=QhgAmvKgmwODzsEp98dnA4PeUEMMaFHd&grant_type=client_credentials';
-      
       const res = await axios.post(
         `https://idms.sanctumkey.com/realms/kyc/protocol/openid-connect/token`,
         params,
@@ -1133,44 +973,27 @@ export const authentification = async (): Promise<string> => {
           },
         }
       );
-      
       cachedToken = res.data.access_token;
-      
       if (!cachedToken) {
         throw new Error("Keycloak returned a success response but no access_token was found.");
       }
-
-      // Calculate exact expiry timestamp (expires_in is usually in seconds)
-      const expiresInMs = (res.data.expires_in || 300) * 1000; 
+      const expiresInMs = (res.data.expires_in || 300) * 1000;
       tokenExpiryTime = Date.now() + expiresInMs;
-
-      return cachedToken; 
+      return cachedToken;
     })();
-
+    
     const finalToken = await activeAuthRequest;
     return finalToken;
-
   } catch (error: any) {
-    cachedToken = null; // Clear bad cache
-    
-    const safeErrorMessage = 
-      error?.response?.data?.error_description || 
-      error?.response?.data?.error || 
-      error?.message || 
-      'Unknown network error';
-      
+    cachedToken = null;
+    const safeErrorMessage = error?.response?.data?.error_description || error?.response?.data?.error || error?.message || 'Unknown network error';
     logger.error('Error authentifying:', safeErrorMessage);
     throw new Error(`Échec de l'authentification: ${safeErrorMessage}`);
-    
   } finally {
-    // 4. Always clear the lock when the request finishes
     activeAuthRequest = null;
   }
 }
 
 export const errorMessage = (error: any) => {
-  return error.response?.data?.message ||
-    error.response?.data?.detail ||
-    error.response?.data?.error ||
-    error.response?.data;
+  return error.response?.data?.message || error.response?.data?.detail || error.response?.data?.error || error.response?.data;
 }