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

package/src/components/KYCElements/IDCardCapture.tsx

@@ -141,19 +141,24 @@ export const IDCardCapture: React.FC<IDCardCaptureProps> = ({ component, value =
   const getCurrentSideVerification = (currentSide: string, countryKey: string) => {
     const rawDocType = countrySelectionData?.documentType;
     if (!rawDocType || !countryKey) { return { authMethod: [], mrzTypes: [], regionMapping: null, key: 'root' }; }
+    
     const rawCountryName = ISO_TO_COUNTRY_NAME[countryData?.code || ''] || countryData?.code || countryKey;
     const baseMapping = (REGION_MAPPING as any).regionMapping || REGION_MAPPING;
+    
     let countryMapping = baseMapping[rawCountryName];
     if (!countryMapping) {
       const foundKey = Object.keys(baseMapping).find(k => k.toLowerCase() === rawCountryName.toLowerCase() || k.toLowerCase() === countryKey.toLowerCase());
       if (foundKey) countryMapping = baseMapping[foundKey];
     }
     if (!countryMapping) { return { authMethod: [], mrzTypes: [], regionMapping: null, key: 'root' }; }
+    
     const regionMapping = countryMapping[rawDocType];
     if (!regionMapping) { return { authMethod: [], mrzTypes: [], regionMapping: null, key: 'root' }; }
+    
     const authMethod: string[] = [];
     const mrzTypes: string[] = [];
     const key = countrySelectionData.region?.trim()?.length > 0 ? countrySelectionData.region.trim() : 'root';
+    
     if (regionMapping?.[key] && Array.isArray(regionMapping[key])) {
       regionMapping[key].forEach((item: any) => {
         if (item[currentSide]) {
@@ -163,25 +168,25 @@ export const IDCardCapture: React.FC<IDCardCaptureProps> = ({ component, value =
       });
     }
     return { authMethod: removeDuplicates(authMethod), mrzTypes: removeDuplicates(mrzTypes), regionMapping, key };
-  }
+  };
 
-  const getCorrespondingMrzType = (templatePath: string, mapping: any, selectedDocumentType: string = "root") => {
-    if (!mapping || !mapping[selectedDocumentType]) return null;
-    const fileName = templatePath.split("/").pop()?.replace(".jpg", "").replace(".png", "");
+  const getCorrespondingMrzType = (templatePath: string, mapping: any, regionKey: string = "root") => {
+    if (!mapping || !mapping[regionKey]) return null;
+    const fileName = templatePath.split("/").pop()?.replace(/\.(jpg|jpeg|png|py)$/i, "");
     if (!fileName) return null;
     const pyName = `${fileName}.py`;
-    const found = mapping[selectedDocumentType].find((item: any) => item.py_file === pyName);
+    const found = mapping[regionKey].find((item: any) => item.py_file === pyName);
     return found?.mrz_type || null;
-  }
+  };
 
-  const getCorrespondingAuthMethod = (templatePath: string, mapping: any, selectedDocumentType: string = "root", side: 'front' | 'back') => {
-    if (!mapping || !mapping[selectedDocumentType]) return null;
-    const fileName = templatePath.split("/").pop()?.replace(".jpg", "").replace(".png", "");
+  const getCorrespondingAuthMethod = (templatePath: string, mapping: any, regionKey: string = "root", side: 'front' | 'back') => {
+    if (!mapping || !mapping[regionKey]) return null;
+    const fileName = templatePath.split("/").pop()?.replace(/\.(jpg|jpeg|png|py)$/i, "");
     if (!fileName) return null;
     const pyName = `${fileName}.py`;
-    const found = mapping[selectedDocumentType].find((item: any) => item.py_file === pyName);
+    const found = mapping[regionKey].find((item: any) => item.py_file === pyName);
     return found?.[side] || null;
-  }
+  };
 
   const autoCapture = async (capturePath: string, verified: ISilentCaptureResult & { region?: string }) => {
     if (isProcessingCapture) return;
@@ -214,7 +219,7 @@ export const IDCardCapture: React.FC<IDCardCaptureProps> = ({ component, value =
           ...newImages,
           country: verified.country,
           documentType: GovernmentDocumentTypeBackend[verified.documentType as keyof typeof GovernmentDocumentTypeBackend] || '',
-          ...(verified.region ? { region: verified.region } : {}) 
+          ...(verified.region ? { region: verified.region } : {})
         });
       }
 
@@ -287,7 +292,10 @@ export const IDCardCapture: React.FC<IDCardCaptureProps> = ({ component, value =
           
           verificationRes = await frontVerification({ 
             path: result.path, 
-            regionMapping: { authMethod: matchedAuthMethod ? [matchedAuthMethod] : regionMappings.authMethod, mrzTypes: regionMappings.mrzTypes }, 
+            regionMapping: { 
+              authMethod: matchedAuthMethod ? [matchedAuthMethod] : [], 
+              mrzTypes: mrzType ? [mrzType] : [] 
+            }, 
             selectedDocumentType: GovernmentDocumentTypeShorted[selectedDocumentType?.type as keyof typeof GovernmentDocumentTypeShorted] || '', 
             code: countryData?.code || '', 
             currentSide, 
@@ -296,16 +304,16 @@ export const IDCardCapture: React.FC<IDCardCaptureProps> = ({ component, value =
             issuingSubdivision: issuingSubdivision 
           }, env);
         } else {
-          let matchedBackAuthMethod = getCorrespondingAuthMethod(templatePath, regionMappings.regionMapping, regionMappings.key || '', 'back');
-          if (!matchedBackAuthMethod && currentSide === 'back') { matchedBackAuthMethod = 'MRZ'; }
+          const matchedBackAuthMethod = getCorrespondingAuthMethod(templatePath, regionMappings.regionMapping, regionMappings.key || '', 'back');
           const backMrzType = getCorrespondingMrzType(templatePath, regionMappings.regionMapping, regionMappings.key || '') || '';
-          
-          // 🚨 EXTRACT FRONT TEMPLATE TO VALIDATE AGAINST BACK TEMPLATE
           const frontTemplatePath = capturedImages['front']?.templatePath || '';
 
           verificationRes = await backVerification({ 
             path: result.path, 
-            regionMapping: { authMethod: matchedBackAuthMethod ? [matchedBackAuthMethod] : regionMappings.authMethod, mrzTypes: regionMappings.mrzTypes }, 
+            regionMapping: { 
+              authMethod: matchedBackAuthMethod ? [matchedBackAuthMethod] : [], 
+              mrzTypes: backMrzType ? [backMrzType] : [] 
+            }, 
             selectedDocumentType: GovernmentDocumentTypeShorted[selectedDocumentType.type as keyof typeof GovernmentDocumentTypeShorted] || '', 
             code: countryData?.code || '', 
             currentSide, 
@@ -313,7 +321,7 @@ export const IDCardCapture: React.FC<IDCardCaptureProps> = ({ component, value =
             mrzType: backMrzType, 
             templateResponse,
             issuingSubdivision: issuingSubdivision,
-            frontTemplatePath: frontTemplatePath // 🚨 PASSED DOWN TO TRIGGER VALIDATION
+            frontTemplatePath: frontTemplatePath 
           }, env);
         }
 
@@ -348,7 +356,7 @@ export const IDCardCapture: React.FC<IDCardCaptureProps> = ({ component, value =
           userFriendlyMessage = 'The document does not match your selected country.';
         } else if (rawMessage.includes('card_not_fully_in_frame')) {
           userFriendlyMessage = 'Move closer to the document and ensure all corners are visible.';
-        } else if (rawMessage.includes('ne correspond pas au recto')) { // 🚨 New Security Error Handler
+        } else if (rawMessage.includes('ne correspond pas au recto')) { 
           userFriendlyMessage = 'The back of the document does not match the front. You must scan the same ID.';
         }
         

package/src/components/KYCElements/VerificationProgressTemplate.tsx

@@ -25,7 +25,6 @@ export const VerificationProgressTemplate: React.FC<VerificationProgressTemplate
   const isSuccess = verification.status === 'success';
   const isFailed = verification.status === 'failed';
 
-  // Fonction pour récupérer le résultat de vérification avec retry
   const getVerificationResult = async (currentRetryCount = 0, maxRetries = 40) => {
     try {
       logger.log(`Starting verification check (attempt ${currentRetryCount + 1}/${maxRetries + 1})`);
@@ -42,20 +41,23 @@ export const VerificationProgressTemplate: React.FC<VerificationProgressTemplate
           } as any
         });
         setIsRetrying(false);
-        return; // Break out of the function so it DOES NOT RETRY
+        return; 
       }
 
-      // Check standard nested payload format
-      const responseData = result?.data;
-      const verificationResult = responseData?.[state.session.session_id]?.data;
+      let verificationResult = result?.data;
+      
+      if (verificationResult && !verificationResult.verification_status && verificationResult[state.session.session_id]) {
+         const nestedData = verificationResult[state.session.session_id]?.data;
+         verificationResult = typeof nestedData === 'string' ? JSON.parse(nestedData) : nestedData;
+      }
 
       if (!verificationResult) {
-        // If we still didn't get data and the status wasn't failed, throw to trigger a retry
         throw new Error('Verification payload missing for current session');
       }
 
-      // Vérifier le statut de vérification
-      if (verificationResult.verification_status === null || verificationResult.verification_status === "processing" || verificationResult.verification_status === "pending") {
+      const currentStatus = verificationResult.verification_status;
+
+      if (currentStatus === null || currentStatus === "processing" || currentStatus === "pending") {
         if (currentRetryCount < maxRetries) {
           const nextRetryCount = currentRetryCount + 1;
           setRetryCount(nextRetryCount);
@@ -69,7 +71,7 @@ export const VerificationProgressTemplate: React.FC<VerificationProgressTemplate
           }, 10000);
           
           setTimeoutId(newTimeoutId as any);
-          return; 
+          return;
         } else {
           logger.error('Max retries reached, verification still processing');
           setIsRetrying(false);
@@ -77,13 +79,15 @@ export const VerificationProgressTemplate: React.FC<VerificationProgressTemplate
         }
       }
 
-      // Traiter le résultat final (success, failed, etc.)
-      if (verificationResult.verification_status === "completed" || verificationResult.verification_status === "approved") {
+      if (currentStatus === "completed" || currentStatus === "approved") {
         actions.setVerificationState({
           status: 'success',
-          result: result
+          result: {
+             ...result,
+             referenceId: verificationResult.verification_id || verificationResult.session_id
+          } as any
         });
-      } else if (verificationResult.verification_status === "failed" || verificationResult.verification_status === "rejected") {
+      } else if (currentStatus === "failed" || currentStatus === "rejected") {
         actions.setVerificationState({
           status: 'failed',
           result: {
@@ -130,6 +134,24 @@ export const VerificationProgressTemplate: React.FC<VerificationProgressTemplate
     };
   }, [timeoutId]);
 
+  // 🚨 THE FIX: Automatically trigger the webhook/completion flow on success
+  useEffect(() => {
+    let autoSubmitTimer: ReturnType<typeof setTimeout>;
+    
+    if (isSuccess) {
+      logger.log("Verification successful. Initiating auto-submit countdown...");
+      // Wait 3 seconds so the user can see the "Complete" screen, then automatically push the data
+      autoSubmitTimer = setTimeout(() => {
+        actions.submitVerification();
+      }, 3000);
+    }
+
+    // Cleanup the timer if the user clicks the button manually before 3 seconds are up
+    return () => {
+      if (autoSubmitTimer) clearTimeout(autoSubmitTimer);
+    };
+  }, [isSuccess, actions]);
+
   if (isSuccess) {
     return (
       <View style={styles.container}>
@@ -157,7 +179,6 @@ export const VerificationProgressTemplate: React.FC<VerificationProgressTemplate
           ))}
         </View>
 
-        {/* 🚨 FIX 2: Give the user actionable options to End or Restart */}
         <TouchableOpacity style={[styles.button, styles.primary]} onPress={() => actions.submitVerification()}>
           <Text style={styles.buttonText}>
             {state.currentLanguage === 'en' ? 'OK / Finish' : 'Terminer'}

package/src/config/region_mapping.ts

@@ -1,6 +1,7 @@
 import { ICountryMapping } from "../types/KYC.types";
 
-export const countryMapping: Record<string, Record<string, Record<string, ICountryMapping[]>>> = {
+export const countryMapping: Record<string, Record<string, Record<string, ICountryMapping[]>>> = 
+{
     "BE": {
         "passport": {
             "root": [

package/src/modules/api/CardAuthentification.ts

@@ -31,7 +31,7 @@ export async function frontVerification(
         currentSide: string,
         templatePath?: string,
         mrzType?: string,
-        issuingSubdivision?: string 
+        issuingSubdivision?: string
     },
     env: KycEnvironment = 'PRODUCTION'
 ) {
@@ -42,7 +42,9 @@ export async function frontVerification(
         const authMethods = Array.isArray(result.regionMapping?.authMethod)
             ? result.regionMapping.authMethod.map(m => String(m).toUpperCase())
             : [];
+            
         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 front document");
@@ -60,12 +62,11 @@ export async function frontVerification(
                 ...(hasMrz ? {
                     mrz: {
                         success: true,
-                        parsed_data: {
-                            status: 'SUCCESS',
-                            document_type: result.selectedDocumentType,
-                            mrz_type: result.mrzType || 'TD1'
-                        }
+                        parsed_data: { status: 'SUCCESS', document_type: result.selectedDocumentType, mrz_type: result.mrzType || 'TD1' }
                     }
+                } : {}),
+                ...(hasBarcode ? {
+                    barcode: { barcode_data: 'SANDBOX_MOCK_BARCODE' }
                 } : {})
             };
             return mockResponse;
@@ -110,6 +111,7 @@ export async function frontVerification(
         let croppedBase64: string | undefined;
         let bbox: IBbox | undefined;
         let mrz: any | undefined;
+        let barcode: any | undefined;
         let documentData: any | undefined;
         
         try {
@@ -126,7 +128,7 @@ export async function frontVerification(
                     docType: result.selectedDocumentType,
                     docRegion: result.code,
                     templatePath: result.templatePath || '',
-                    issuingSubdivision: result.issuingSubdivision, 
+                    issuingSubdivision: result.issuingSubdivision,
                     token: token,
                     postfix: result.currentSide || 'front'
                 });
@@ -162,9 +164,28 @@ export async function frontVerification(
                 throw new Error(err?.message || "Erreur lors de l'extraction MRZ. Veuillez reprendre la photo.");
             }
         }
+
+        if (hasBarcode) {
+            try {
+                logger.log("Tentative d'extraction barcode (Front)");
+                barcode = await kycService.extractBarcode({ fileUri: result.path || '', token: token }, env);
+            } catch (e: any) {
+                logger.log("Front Barcode Extraction Error:", e?.message);
+                // If it exclusively has a barcode (no MRZ) and barcode fails, throw.
+                if (!mrz) {
+                    throw new Error(`Lecture Barcode échouée: ${e?.message || 'Veuillez réessayer'}`);
+                }
+            }
+        }
         
-        // Return detected frame, crop, MRZ, AND the new extracted OCR documentData
-        return { ...detected, croppedBase64, bbox, ...(mrz ? { mrz } : {}), ...(documentData ? { documentData } : {}) };
+        return { 
+            ...detected, 
+            croppedBase64, 
+            bbox, 
+            ...(mrz ? { mrz } : {}), 
+            ...(barcode ? { barcode } : {}),
+            ...(documentData ? { documentData } : {}) 
+        };
         
     } catch (e: any) {
         logger.log('Error front verification:', e?.message);
@@ -182,8 +203,8 @@ export async function backVerification(
         templatePath?: string,
         mrzType?: string,
         templateResponse?: ApiVerificationResponse,
-        issuingSubdivision?: string, // Capture province/state
-        frontTemplatePath?: string   // Capture the front template to compare against
+        issuingSubdivision?: string, 
+        frontTemplatePath?: string
     },
     env: KycEnvironment = 'PRODUCTION'
 ) {
@@ -213,11 +234,7 @@ export async function backVerification(
                     success: true,
                     mrz: {
                         success: true,
-                        parsed_data: {
-                            status: 'SUCCESS',
-                            document_type: result.selectedDocumentType,
-                            mrz_type: result.mrzType || 'TD1'
-                        }
+                        parsed_data: { status: 'SUCCESS', document_type: result.selectedDocumentType, mrz_type: result.mrzType || 'TD1' }
                     },
                     bbox: mockBbox,
                     card_obb: mockCardObb
@@ -295,29 +312,34 @@ export async function backVerification(
             }
         }
 
-        // 🚨 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);
+            try {
+                const frontPy = result.frontTemplatePath.split("/").pop()?.replace(/\.(jpg|png)$/i, ".py");
+                const backPy = activeTemplatePath.split("/").pop()?.replace(/\.(jpg|png)$/i, ".py");
                 
-                // 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.`);
+                if (frontPy && backPy) {
+                    logger.log(`Validating Front (${frontPy}) vs Back (${backPy}) for region ${result.code}`);
+                    
+                    const isCanadianSubRegionDoc = result.code === 'CA' && ['hic'].includes(result.selectedDocumentType);
+                    const safeSubRegion = isCanadianSubRegionDoc ? (result.issuingSubdivision || "") : "";
+
+                    const matchValidation = await kycService.validateBackTemplate({
+                        region: result.code,
+                        docType: result.selectedDocumentType,
+                        frontTemplateName: frontPy,
+                        backTemplateName: backPy,
+                        subRegion: safeSubRegion,
+                        token: token
+                    }, env);
+                    
+                    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.`);
+                    }
                 }
+            } catch (err: any) {
+                if (err?.message?.includes('ne correspond pas')) throw err;
+                logger.log("Template matching validation skipped/failed internally:", err?.message);
             }
         }
         
@@ -369,10 +391,11 @@ export async function backVerification(
         
         if (hasBarcode) {
             try {
-                logger.log("Tentative d'extraction barcode");
+                logger.log("Tentative d'extraction barcode (Back)");
                 const barcode = await kycService.extractBarcode({ fileUri: result.path!, token: token }, env);
                 extractionResult.barcode = barcode;
             } catch (e: any) {
+                // If it explicitly expects a barcode (and not an MRZ) and fails, throw to user
                 if (!extractionResult.mrz) {
                     throw new Error(`Lecture Barcode échouée: ${e?.message}`);
                 }
@@ -403,11 +426,11 @@ export async function backVerification(
 
 export async function checkTemplateType(
     result: { 
-        path?: string, 
-        docType: string, 
-        docRegion: string, 
-        postfix: string,
-        issuingSubdivision?: string
+         path?: string, 
+         docType: string, 
+         docRegion: string, 
+         postfix: string,
+         issuingSubdivision?: string 
     },
     env: KycEnvironment = 'PRODUCTION'
 ) {
@@ -425,12 +448,15 @@ export async function checkTemplateType(
         }
         
         const token = await authentification();
+        const isCanada = result.docRegion?.toUpperCase() === 'CA';
+        
         const templateType = await kycService.checkTemplateType({
             fileUri: result.path || '',
             docType: result?.docType as GovernmentDocumentType,
             docRegion: result?.docRegion || "",
             postfix: result?.postfix,
-            token: token
+            token: token,
+            issuingSubdivision: isCanada ? result.issuingSubdivision : undefined
         }, env);
         
         if (templateType.success === false || templateType.Error) {
@@ -468,7 +494,7 @@ export async function checkTemplateType(
         
         const LPIPS_THRESHOLD = 0.75;
         if (templateType.lpips_score !== undefined && templateType.lpips_score > LPIPS_THRESHOLD) {
-            logger.log(`🛑 Country Mismatch! LPIPS: ${templateType.lpips_score}`);
+            logger.log(`Country Mismatch! LPIPS: ${templateType.lpips_score}`);
             throw new Error(`Le document présenté ne correspond pas au pays sélectionné (${result.docRegion}).`);
         }
         

package/src/modules/api/KYCService.ts

@@ -281,7 +281,18 @@ 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;
+      issuingSubdivision?: string; // 🚨 Added parameter
+    }, 
+    env: KycEnvironment = 'PRODUCTION'
+  ): Promise<any> {
+    
     // SANDBOX mode
     if (env === 'SANDBOX') {
       console.log("SANDBOX mode: Skipping AI template type check");
@@ -293,15 +304,24 @@ export class KYCService {
       };
     }
 
-    const { fileUri, docType, docRegion, token, postfix } = params;
+    // 🚨 Destructure issuingSubdivision
+    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];
-    const url = `${this.mrzServiceURL}/get_template_version/?doc_type=${encodeURIComponent(docTypeShorted)}&doc_region=${encodeURIComponent(docRegion)}&postfix=${postfix}`;
+    
+    // Build the base URL
+    let url = `${this.mrzServiceURL}/get_template_version/?doc_type=${encodeURIComponent(docTypeShorted)}&doc_region=${encodeURIComponent(docRegion)}&postfix=${postfix}`;
+
+    // 🚨 Append the subdivision strictly for Canada/regional docs
+    if (issuingSubdivision) {
+      url += `&issuing_subdivision=${encodeURIComponent(issuingSubdivision)}`;
+    }
 
-    logger.log('checkTemplateType params', this.mrzServiceURL, JSON.stringify({ fileUri, docTypeShorted, docRegion, token, postfix, url }, null, 2));
+    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}`, },
@@ -310,10 +330,9 @@ export class KYCService {
       logger.log('checkTemplateType res', JSON.stringify(res.data, null, 2));
       return res.data;
     } catch (e: any) {
-      logger.error('Error checkingg template type:', JSON.stringify(e));
+      logger.error('Error checking template type:', JSON.stringify(e));
       throw e;
     }
-
   }
 
   async extractDocumentInformation(params: {