@sanctum-key/react-native-sdk 1.0.19 → 1.0.20

package/src/modules/api/CardAuthentification.ts

@@ -30,19 +30,20 @@ export async function frontVerification(
         code: string,
         currentSide: string,
         templatePath?: string,
-        mrzType?: string
+        mrzType?: string,
+        issuingSubdivision?: string 
     },
     env: KycEnvironment = 'PRODUCTION'
 ) {
     try {
         console.log("Front verification START", JSON.stringify({ result }, null, 2));
         logger.log("Front verification", JSON.stringify({ result }, null, 2));
-
+        
         const authMethods = Array.isArray(result.regionMapping?.authMethod)
             ? result.regionMapping.authMethod.map(m => String(m).toUpperCase())
             : [];
         const hasMrz = authMethods.some(m => m.includes('MRZ'));
-
+        
         if (env === 'SANDBOX') {
             console.log("SANDBOX mode: Skipping AI verification for front document");
             const mockBbox: IBbox = { minX: 400, minY: 800, width: 2200, height: 1400 };
@@ -69,25 +70,25 @@ export async function frontVerification(
             };
             return mockResponse;
         }
-
+        
         const token = await authentification();
         const detected = await kycService.detectFaceOnId(
             result?.path || '', token, result?.selectedDocumentType || '', env
         ) as ApiVerificationResponse;
-
+        
         if (!detected.result) {
             throw new Error('Aucun visage détecté sur la carte. Veuillez reprendre.');
         }
-
+        
         const cardData = detected.card_obb && Array.isArray(detected.card_obb) && detected.card_obb.length > 0
             ? detected.card_obb[0]
             : null;
-
+            
         let points: number[][] | null = null;
+        console.log(points)
         let isCardInFrame = true;
         let hasCroppedSides = false;
-        console.log(points)
-
+        
         if (cardData) {
             points = cardData.obb;
             if (typeof cardData.card_in_frame !== 'undefined') {
@@ -95,27 +96,45 @@ export async function frontVerification(
                 hasCroppedSides = Array.isArray(cardData.cropped_sides) && cardData.cropped_sides.length > 0;
             }
         }
-
+        
         if (!isCardInFrame || hasCroppedSides) {
             logger.log(`Front Framing failed. Cropped sides detected by backend.`);
             throw new Error('CARD_NOT_FULLY_IN_FRAME');
         }
-
+        
         const obbConfidence = getObbConfidence(detected.card_obb);
         if (obbConfidence !== null && obbConfidence < OBB_CONFIDENCE_THRESHOLD) {
             throw new Error('Carte non entièrement visible. Positionnez toute la carte dans le cadre.');
         }
-
+        
         let croppedBase64: string | undefined;
         let bbox: IBbox | undefined;
         let mrz: any | undefined;
-
+        let documentData: any | undefined;
+        
         try {
             const crop = await cropByObb(result?.path || '', detected.card_obb);
             croppedBase64 = crop.base64;
             bbox = crop.bbox;
         } catch { }
 
+        if (result.code === 'CA') {
+            try {
+                logger.log("Tentative d'extraction OCR (Front) - Canada Only");
+                documentData = await kycService.extractDocumentInformation({
+                    fileUri: result.path || '',
+                    docType: result.selectedDocumentType,
+                    docRegion: result.code,
+                    templatePath: result.templatePath || '',
+                    issuingSubdivision: result.issuingSubdivision, 
+                    token: token,
+                    postfix: result.currentSide || 'front'
+                });
+            } catch (err: any) {
+                logger.log("Front OCR Extraction Error:", err?.message || err);
+            }
+        }
+        
         if (hasMrz) {
             try {
                 logger.log("Tentative d'extraction MRZ (Front)");
@@ -131,11 +150,11 @@ export async function frontVerification(
                     },
                     env
                 );
-
+                
                 mrz = typeof mrzResponse === 'string' ? JSON.parse(mrzResponse) : mrzResponse;
-
+                
                 if (mrz?.parsed_data?.status === 'FAILURE' || mrz?.success === false) {
-                    logger.log("🛑 Front MRZ Extraction Failed:", mrz?.parsed_data?.status_message);
+                    logger.log("Front MRZ Extraction Failed:", mrz?.parsed_data?.status_message);
                     throw new Error(`MRZ illisible: ${mrz?.parsed_data?.status_message || 'Veuillez nettoyer l\'objectif et réessayer'}`);
                 }
             } catch (err: any) {
@@ -143,9 +162,10 @@ export async function frontVerification(
                 throw new Error(err?.message || "Erreur lors de l'extraction MRZ. Veuillez reprendre la photo.");
             }
         }
-
-        return { ...detected, croppedBase64, bbox, ...(mrz ? { mrz } : {}) };
-
+        
+        // Return detected frame, crop, MRZ, AND the new extracted OCR documentData
+        return { ...detected, croppedBase64, bbox, ...(mrz ? { mrz } : {}), ...(documentData ? { documentData } : {}) };
+        
     } catch (e: any) {
         logger.log('Error front verification:', e?.message);
         throw new Error(e?.message || 'Erreur de détection du visage');
@@ -161,22 +181,23 @@ export async function backVerification(
         currentSide: string,
         templatePath?: string,
         mrzType?: string,
-        templateResponse?: ApiVerificationResponse
+        templateResponse?: ApiVerificationResponse,
+        issuingSubdivision?: string, // Capture province/state
+        frontTemplatePath?: string   // Capture the front template to compare against
     },
     env: KycEnvironment = 'PRODUCTION'
 ) {
     try {
         if (!result.path) throw new Error('No path provided');
         logger.log("result.regionMapping", result.regionMapping, result.currentSide, result.code);
-        logger.log('result object', result)
-
+        
         const authMethods = Array.isArray(result.regionMapping?.authMethod)
             ? result.regionMapping.authMethod.map(m => String(m).toUpperCase())
             : [];
-
-        const hasMrz = authMethods.some(m => m.includes('MRZ'))
+            
+        const hasMrz = authMethods.some(m => m.includes('MRZ'));
         const hasBarcode = authMethods.some(m => m.includes('BARCODE') || m.includes('2D'));
-
+        
         if (env === 'SANDBOX') {
             console.log("SANDBOX mode: Skipping AI verification for back document");
             const mockBbox: IBbox = { minX: 400, minY: 800, width: 2200, height: 1400 };
@@ -211,34 +232,34 @@ export async function backVerification(
             }
             return { success: true, bbox: mockBbox, card_obb: mockCardObb };
         }
-
+        
         const token = await authentification();
         logger.log("1. Checking template and framing for back document...");
-
+        
         const templateResponse: ApiVerificationResponse = result.templateResponse ||
             await kycService.checkTemplateType({
                 fileUri: result.path,
                 docType: result.selectedDocumentType as any,
                 docRegion: result.code,
                 postfix: 'back',
-                token: token
+                token: token,
             }, env);
-
+            
         if (templateResponse.success === false || templateResponse.Error) {
             throw new Error('Impossible de lire le document. Veuillez vous rapprocher et stabiliser la caméra.');
         }
-
+        
         const cardData = templateResponse?.card_obb && Array.isArray(templateResponse.card_obb) && templateResponse.card_obb.length > 0
             ? templateResponse.card_obb[0]
             : null;
-
+            
         if (!cardData) throw new Error('CARD_NOT_FULLY_IN_FRAME');
-
+        
         let points: number[][] | null = null;
+        console.log(points)
         let isCardInFrame = false;
         let hasCroppedSides = true;
-        console.log(points)
-
+        
         if (cardData.obb) {
             points = cardData.obb;
             if (typeof cardData.card_in_frame !== 'undefined') {
@@ -250,33 +271,77 @@ export async function backVerification(
             isCardInFrame = true;
             hasCroppedSides = false;
         }
-
+        
         if (!isCardInFrame || hasCroppedSides) {
             logger.log(`Back Framing failed. Backend reported document out of bounds.`);
             throw new Error('CARD_NOT_FULLY_IN_FRAME');
         }
-
+        
         const obbConf = getObbConfidence(templateResponse?.card_obb);
         if (obbConf !== null && obbConf < OBB_CONFIDENCE_THRESHOLD) {
             throw new Error('Carte non entièrement visible. Positionnez toute la carte dans le cadre.');
         }
-
+        
         const activeTemplatePath = templateResponse.template_path || result.templatePath || '';
+        
         if (activeTemplatePath) {
             const expectedCountryName = countryData[result.code]?.name_en || '';
             const hasCodeMatch = activeTemplatePath.includes(`_${result.code}_`);
             const hasNameMatch = expectedCountryName && activeTemplatePath.toLowerCase().includes(expectedCountryName.toLowerCase());
-
+            
             if (!hasCodeMatch && !hasNameMatch) {
                 logger.log(`Template mismatch! Expected: ${result.code} (${expectedCountryName}), Detected: ${activeTemplatePath}`);
                 throw new Error(`Le document ne correspond pas au pays sélectionné (${result.code}).`);
             }
         }
 
-        logger.log("Framing and Country Template verified successfully. Proceeding to Data Extraction.");
-
+        // 🚨 STRICT FRONT VS BACK TEMPLATE VALIDATION 🚨
+        if (result.frontTemplatePath && activeTemplatePath) {
+            const frontPy = result.frontTemplatePath.split("/").pop()?.replace(/\.(jpg|png)$/i, ".py");
+            const backPy = activeTemplatePath.split("/").pop()?.replace(/\.(jpg|png)$/i, ".py");
+            
+            if (frontPy && backPy) {
+                logger.log(`Validating Front (${frontPy}) vs Back (${backPy}) for region ${result.code}`);
+                
+            
+                const matchValidation = await kycService.validateBackTemplate({
+                    region: result.code,
+                    docType: result.selectedDocumentType,
+                    frontTemplateName: frontPy,
+                    backTemplateName: backPy,
+                    subRegion: result.issuingSubdivision || "",
+                    token: token
+                }, env);
+                
+                // If the API succeeds but explicitly returns false, stop immediately.
+                if (!matchValidation || matchValidation.is_match === false) {
+                    logger.log(`Front/Back Mismatch: ${matchValidation?.status_message}`);
+                    throw new Error(`Le verso ne correspond pas au recto fourni. Vous avez scanné un document différent.`);
+                }
+            }
+        }
+        
+        logger.log("Framing, Country, and Match verified successfully. Proceeding to Data Extraction.");
         let extractionResult: any = {};
 
+        if (result.code === 'CA') {
+            try {
+                logger.log("Tentative d'extraction OCR (Back) - Canada Only");
+                const documentData = await kycService.extractDocumentInformation({
+                    fileUri: result.path!,
+                    docType: result.selectedDocumentType,
+                    docRegion: result.code,
+                    templatePath: activeTemplatePath,
+                    issuingSubdivision: result.issuingSubdivision,
+                    token: token,
+                    postfix: result.currentSide || 'back'
+                });
+                extractionResult.documentData = documentData;
+            } catch (err: any) {
+                logger.log("Back OCR Extraction Error:", err?.message || err);
+            }
+        }
+        
         if (hasMrz) {
             try {
                 logger.log("Tentative d'extraction MRZ (Back)");
@@ -289,35 +354,31 @@ export async function backVerification(
                     template_path: activeTemplatePath,
                     mrz_type: result?.mrzType || 'TD1'
                 }, env);
-
+                
                 const mrz = typeof mrzResponse === 'string' ? JSON.parse(mrzResponse) : mrzResponse;
-
+                
                 if (mrz?.parsed_data?.status === 'FAILURE' || mrz?.success === false) {
                     throw new Error(mrz?.parsed_data?.status_message || 'Lecture MRZ échouée');
                 }
-
-                extractionResult.mrz = mrz; // Attaching securely to result object
-
+                extractionResult.mrz = mrz; 
             } catch (mrzError: any) {
                 logger.log(`MRZ échoué: ${mrzError?.message}`);
-                // If MRZ fails, we MUST throw an error so the user is forced to retake it!
                 throw new Error(`Lecture MRZ invalide: ${mrzError?.message || 'Veuillez nettoyer l\'objectif et réessayer'}`);
             }
         }
-
+        
         if (hasBarcode) {
             try {
                 logger.log("Tentative d'extraction barcode");
                 const barcode = await kycService.extractBarcode({ fileUri: result.path!, token: token }, env);
                 extractionResult.barcode = barcode;
             } catch (e: any) {
-                // Only throw barcode error if MRZ wasn't already successfully extracted
                 if (!extractionResult.mrz) {
                     throw new Error(`Lecture Barcode échouée: ${e?.message}`);
                 }
             }
         }
-
+        
         let bbox: IBbox | undefined;
         let croppedBase64: string | undefined;
         try {
@@ -325,7 +386,7 @@ export async function backVerification(
             bbox = crop.bbox;
             croppedBase64 = crop.base64;
         } catch { }
-
+        
         return {
             success: true,
             ...extractionResult,
@@ -333,15 +394,21 @@ export async function backVerification(
             croppedBase64,
             card_obb: templateResponse.card_obb
         };
-
+        
     } catch (e: any) {
-        if (e?.message === 'CARD_NOT_FULLY_IN_FRAME') throw e; 
+        if (e?.message === 'CARD_NOT_FULLY_IN_FRAME') throw e;
         throw new Error(e?.message || 'Erreur de détection des données');
     }
 }
 
 export async function checkTemplateType(
-    result: { path?: string, docType: string, docRegion: string, postfix: string },
+    result: { 
+        path?: string, 
+        docType: string, 
+        docRegion: string, 
+        postfix: string,
+        issuingSubdivision?: string
+    },
     env: KycEnvironment = 'PRODUCTION'
 ) {
     try {
@@ -356,7 +423,7 @@ export async function checkTemplateType(
                 }]
             };
         }
-
+        
         const token = await authentification();
         const templateType = await kycService.checkTemplateType({
             fileUri: result.path || '',
@@ -365,23 +432,23 @@ export async function checkTemplateType(
             postfix: result?.postfix,
             token: token
         }, env);
-
+        
         if (templateType.success === false || templateType.Error) {
             logger.log("Backend returned an error:", templateType.Error);
             throw new Error('Impossible de lire le document. Veuillez vous rapprocher et stabiliser la caméra.');
         }
-
+        
         const cardData = templateType.card_obb && Array.isArray(templateType.card_obb) && templateType.card_obb.length > 0
             ? templateType.card_obb[0]
             : null;
-
+            
         if (!cardData) throw new Error('CARD_NOT_FULLY_IN_FRAME');
-
+        
         let points: number[][] | null = null;
+        console.log(points)
         let isCardInFrame = false;
         let hasCroppedSides = true;
-        console.log(points)
-
+        
         if (cardData.obb) {
             points = cardData.obb;
             if (typeof cardData.card_in_frame !== 'undefined') {
@@ -392,25 +459,25 @@ export async function checkTemplateType(
             points = cardData[0];
             isCardInFrame = true;
             hasCroppedSides = false;
-            // 🚨 ARTIFICIAL CHECK REMOVED HERE
         }
-
+        
         if (!isCardInFrame || hasCroppedSides) {
             logger.log(`Template Framing failed by backend check.`);
             throw new Error('CARD_NOT_FULLY_IN_FRAME');
         }
-
+        
         const LPIPS_THRESHOLD = 0.75;
         if (templateType.lpips_score !== undefined && templateType.lpips_score > LPIPS_THRESHOLD) {
             logger.log(`🛑 Country Mismatch! LPIPS: ${templateType.lpips_score}`);
             throw new Error(`Le document présenté ne correspond pas au pays sélectionné (${result.docRegion}).`);
         }
-
+        
         logger.log("templateType result", JSON.stringify(truncateFields(templateType), null, 2));
         return templateType;
+        
     } catch (e: any) {
-        logger.log('Errorrr checking template type:', JSON.stringify(errorMessage(e), null, 2));
-        if (e?.message === 'CARD_NOT_FULLY_IN_FRAME' || e?.message?.includes('ne correspond pas')) throw e; 
+        logger.log('Error checking template type:', JSON.stringify(errorMessage(e), null, 2));
+        if (e?.message === 'CARD_NOT_FULLY_IN_FRAME' || e?.message?.includes('ne correspond pas')) throw e;
         throw new Error(e?.message || 'Erreur de vérification du template');
     }
 }

package/src/modules/api/KYCService.ts

@@ -281,7 +281,7 @@ export class KYCService {
   }
 
   //check templatetemplate_type
-  async checkTemplateType(params: { fileUri: string; docType: string; docRegion: string; token: string; postfix: string }, env: KycEnvironment = 'PRODUCTION'): Promise<any> {
+  async checkTemplateType(params: { fileUri: string; docType: string; docRegion: string; token: string; postfix: string}, env: KycEnvironment = 'PRODUCTION'): Promise<any> {
     // SANDBOX mode
     if (env === 'SANDBOX') {
       console.log("SANDBOX mode: Skipping AI template type check");
@@ -316,29 +316,75 @@ export class KYCService {
 
   }
 
-  async extractDocumentInformation(params: { fileUri: string; docType: string; docRegion: string; token: string; postfix?: string }): Promise<any> {
-    const { fileUri, docType, docRegion, token, postfix = 'front' } = params;
-    const formData = new FormData();
+  async extractDocumentInformation(params: { 
+    fileUri: string; 
+    docType: string; 
+    docRegion: string; 
+    templatePath: string; // 🚨 Required by API
+    issuingSubdivision?: string; // 🚨 Required for non-passports
+    token: string; 
+    postfix?: string 
+  }): Promise<any> {
+    const { fileUri, docType, docRegion, templatePath, issuingSubdivision, token, postfix = 'front' } = params;
     
-    // ✅ FIX: Dynamic filename
+    // 1. Prepare Form Data
+    const formData = new FormData();
+    // Prefixing with 'front' or 'back' as strictly required by the docs
     await appendFileToFormData(formData, 'file', fileUri, `id_card_${postfix}.jpg`, 'image/jpeg');
 
-    const url = `${this.textExtractionServiceURL}/extract_doc_information/?doc_type=${encodeURIComponent(docType)}&doc_region=${encodeURIComponent(docRegion)}`;
-    const attempt = async () => {
-      const res = await axios.post(url, formData, {
-        headers: { 'Content-Type': 'multipart/form-data', 'Authorization': `Bearer ${token}`, },
+    // 2. Build the URL with ALL required parameters
+    let queryParams = `doc_type=${encodeURIComponent(docType)}&doc_region=${encodeURIComponent(docRegion)}&template_path=${encodeURIComponent(templatePath)}`;
+    if (issuingSubdivision) {
+      queryParams += `&issuing_subdivision=${encodeURIComponent(issuingSubdivision)}`;
+    }
+    
+    const url = `${this.textExtractionServiceURL}/extract_doc_information/?${queryParams}`;
+
+    try {
+      // 3. Start the Job
+      const startRes = await axios.post(url, formData, {
+        headers: { 'Content-Type': 'multipart/form-data', 'Authorization': `Bearer ${token}` },
         timeout: 60000,
       });
-      logger.log('extractDocumentInformation res', JSON.stringify(truncateFields(res)));
+      
+      const jobId = startRes.data?.job_id;
+      if (!jobId) throw new Error("Backend did not return a job_id");
 
-      if (res.data?.detail) throw new Error(res.data.detail);
-      return res.data;
-    };
-    try {
-      return await attempt();
-    } catch (e) {
-      logger.error('Error extracting document information:', JSON.stringify(truncateFields(e)));
-      throw e;
+      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}` }
+        });
+
+        const statusData = statusRes.data;
+
+        if (statusData.status === 'completed') {
+          logger.log('Extraction completed successfully', JSON.stringify(truncateFields(statusData.result)));
+          return statusData.result; // 👈 Returns the actual extracted data
+        }
+
+        if (statusData.status === 'failed') {
+          throw new Error(statusData.error || "Document extraction failed during processing.");
+        }
+
+        // If 'processing', loop continues...
+      }
+
+      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);
+      throw new Error(errorMsg);
     }
   }
 
@@ -412,7 +458,7 @@ export class KYCService {
      };
    }
    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';
@@ -578,41 +624,53 @@ export class KYCService {
   }
 
   async verificationSession(payload: VerificationSessionRequest): Promise<any> {
-    console.log('apiKey in verificationSession', payload.apiKey);
     try {
       const { session_id, step, data, templateId, action, apiKey } = payload;
+      
+      // 1. Safe Auth Resolution
       const token = apiKey ? undefined : await authentification();
+      
+      if (!apiKey && !token) {
+         throw new Error("Authentication failed: No API key or Token available.");
+      }
+
+
       const payloadData = {
         action: action,
         data: {
-          step,
-          templateId,
-          ...(action === "location_permission" ? { permissionGranted: true, } : {}),
-          ...data,
+          ...data, 
+          step: step,
+          templateId: templateId,
+          ...(action === "location_permission" ? { permissionGranted: true } : {}),
         },
-        ...({ session_id: session_id }),
-        timestamp: new Date().toISOString()
-      }
+        session_id: session_id,
+        timestamp: new Date().toISOString(),
+      };
+
       const url = `${KYCConfig.getBackendUrl()}/verification/api/kyc/sessions/${session_id}/steps/${step}/`;
 
+      // 3. Clean Logging
       const logPayload = truncateFields({ payloadData, session_id, step });
-      logger.log('verificationSession payload',
-        JSON.stringify(truncateFields({ logPayload, token: token ?? "-", path: url, apiKey }),
-          null, 2))
-
-      const res = await axios.post<SessionResponse>(url,
-        payloadData,
-        {
+      logger.log('verificationSession payload', JSON.stringify({ 
+          url,
+          apiKey: apiKey ? '***HIDDEN***' : 'None', // Don't log the raw API key!
+          token: token ? '***HIDDEN***' : 'None',
+          payload: logPayload 
+      }, null, 2));
+
+      // 4. API Execution
+      const res = await axios.post<SessionResponse>(url, payloadData, {
           headers: {
             'Content-Type': 'application/json',
             ...(apiKey ? { 'Authorization': `ApiKey ${apiKey}` } : { 'Authorization': `Bearer ${token}` })
           }
-        });
+      });
+      
       logger.log('verificationSession res', JSON.stringify(truncateFields(res.data), null, 2));
       return res.data;
 
     } catch (error) {
-      logger.error('Error validating component:', JSON.stringify(error, null, 2));
+      logger.error('Error validating component:', JSON.stringify(errorMessage(error), null, 2));
       throw new Error(errorMessage(error));
     }
   }
@@ -757,6 +815,54 @@ export class KYCService {
         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;
+  
+  // 🚨 THE FIX: Format the payload as URL Query Parameters
+  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');
+  }
+}
 }
 
 const kycService = new KYCService("", "");
@@ -801,8 +907,6 @@ export const authentification = async (): Promise<string> => {
     activeAuthRequest = (async () => {
       logger.log('Authenticating: Fetching new Keycloak token...');
       
-      // 🚨 FIX: Do NOT use URLSearchParams in React Native with Axios.
-      // Use a raw URL-encoded string to guarantee Keycloak understands the payload.
       const params = 'client_id=kyc_frontend&client_secret=QhgAmvKgmwODzsEp98dnA4PeUEMMaFHd&grant_type=client_credentials';
       
       const res = await axios.post(