@transfergratis/react-native-sdk 0.1.24 → 0.1.26

package/src/i18n/en/index.ts

@@ -15,6 +15,19 @@ export const en = {
     success: 'Success',
     warning: 'Warning',
     info: 'Information',
+    invalidCode: 'Invalid code',
+    resendCode: 'Resend code',
+    verify: 'Verify',
+    sendCode: 'Send code',
+    resend: 'Resend',
+    email: 'Email',
+    otp: 'OTP',
+    verificationCode: 'Verification code',
+    changeEmail: 'Change Email',
+    processing: "Processing",
+    codeResent: 'Code Resent',
+    codeResentMessage: 'Code resent to %{email}',
+    phone: 'Phone number with country code',
   },
 
   // KYC Flow
@@ -22,7 +35,22 @@ export const en = {
     title: 'Identity Verification',
     subtitle: 'Complete your identity verification to continue',
     step: 'Step %{current} of %{total}',
-    
+    enterCodeSent: "Enter code sent",
+
+    additionalDocs: {
+      title: 'Additional Documents',
+      add: "Press to select file",
+      subtitle: 'Upload additional documents to complete your identity verification',
+      uploadButton: 'Upload',
+      uploadButtonText: 'Upload',
+      uploadSubtext: 'Upload a clear photo of your document',
+      supportedFormats: 'Supported formats: JPG, PNG, PDF',
+      maxSize: 'Max file size: 10MB',
+      processing: 'Processing file...',
+      success: 'File uploaded successfully',
+      error: 'Failed to upload file. Please try again.'
+    },
+
     // Initialization
     initialization: {
       title: 'Welcome to Identity Verification',
@@ -43,7 +71,8 @@ export const en = {
       privacyPolicy: 'I agree to the Privacy Policy',
       termsOfService: 'I agree to the Terms of Service',
       marketingConsent: 'I agree to receive marketing communications',
-      readMore: 'Read more'
+      readMore: 'Read more',
+      getStarted: 'Get Started'
     },
 
     // Location Capture
@@ -98,6 +127,10 @@ export const en = {
       success: 'ID captured successfully',
       error: 'Failed to capture ID. Please try again.',
       captureTitle: '%{side} side of your government document',
+      cardNotFullyInFrame: 'The ID is not fully in frame. Position the entire card within the frame.',
+      continueOnPhone: 'Continue on Phone',
+      continueOnMobile: 'Continue on Mobile',
+      scanQrCode: 'Scan this QR code with your phone to continue the verification process.',
     },
 
     // Selfie Capture
@@ -214,7 +247,17 @@ export const en = {
     cameraError: 'Camera error. Please try again.',
     fileError: 'File error. Please try again.',
     timeoutError: 'Request timeout. Please try again.',
-    unknownError: 'An unknown error occurred. Please try again.'
+    unknownError: 'An unknown error occurred. Please try again.',
+    wrongCode: "Wrong code",
+    invalidCode: "Invalid code",
+    invalidEmail: "Invalid email",
+    invalidPhone: "Invalid phone",
+    invalidDate: "Invalid date",
+    minLength: "Min length",
+    maxLength: "Max length",
+    invalidFormat: "Invalid format",
+    fileTooLarge: "File too large",
+    fileTypeNotSupported: "File type not supported",
   },
 
   // Validation messages

package/src/i18n/fr/index.ts

@@ -15,6 +15,20 @@ export const fr = {
     success: 'Succès',
     warning: 'Avertissement',
     info: 'Information',
+    invalidCode: 'Code invalide',
+    resendCode: 'Renvoyer le code',
+    verify: 'Vérifier',
+    sendCode: 'Envoyer le code',
+    resend: 'Renvoyer',
+    email: 'Email',
+    otp: 'OTP',
+    verificationCode: 'Code de vérification',
+    changeEmail: 'Changer d\'email',
+    processing: "Traitement",
+    codeResent: 'Code Renvoyé',
+    codeResentMessage: 'Code renvoyé à %{email}',
+    phone: 'Numéro de téléphone avec code pays',
+
   },
 
   // KYC Flow
@@ -42,7 +56,8 @@ export const fr = {
       privacyPolicy: 'J\'accepte la Politique de Confidentialité',
       termsOfService: 'J\'accepte les Conditions d\'Utilisation',
       marketingConsent: 'J\'accepte de recevoir des communications marketing',
-      readMore: 'Lire plus'
+      readMore: 'Lire plus',
+      getStarted: 'Commencer'
     },
 
     // Location Capture
@@ -97,6 +112,10 @@ export const fr = {
       success: 'Document d\'identité capturé avec succès',
       error: 'Échec de la capture du document. Veuillez réessayer.',
       captureTitle: '%{side} de votre document d\'identité',
+      cardNotFullyInFrame: 'La carte n\'est pas entièrement visible. Positionnez toute la carte dans le cadre.',
+      continueOnPhone: 'Continuer sur mobile',
+      continueOnMobile: 'Continuer sur mobile',
+      scanQrCode: 'Scannez ce code QR avec votre téléphone pour continuer la vérification.',
     },
 
     // Selfie Capture
@@ -213,7 +232,17 @@ export const fr = {
     cameraError: 'Erreur caméra. Veuillez réessayer.',
     fileError: 'Erreur fichier. Veuillez réessayer.',
     timeoutError: 'Délai d\'attente dépassé. Veuillez réessayer.',
-    unknownError: 'Une erreur inconnue s\'est produite. Veuillez réessayer.'
+    unknownError: 'Une erreur inconnue s\'est produite. Veuillez réessayer.',
+    wrongCode: "Wrong code",
+    invalidCode: "Invalid code",
+    invalidEmail: "Invalid email",
+    invalidPhone: "Invalid phone",
+    invalidDate: "Invalid date",
+    minLength: "Min length",
+    maxLength: "Max length",
+    invalidFormat: "Invalid format",
+    fileTooLarge: "File too large",
+    fileTypeNotSupported: "File type not supported",
   },
 
   validation: {

package/src/i18n/types.ts

@@ -53,6 +53,8 @@ export interface KYCTranslations {
     processing: string;
     success: string;
     error: string;
+    captureTitle?: string;
+    cardNotFullyInFrame?: string;
   };
   
   selfieCapture: {

package/src/index.ts

@@ -4,6 +4,9 @@ export * from './TransfergratisSdk.types';
 // Export KYC types
 export * from './types/KYC.types';
 
+// Export Environment types
+export * from './types/env.types';
+
 
 export { TemplateKYCExample as LauchTransferGratisKYC } from './components/TemplateKYCExample';
 

package/src/modules/api/CardAuthentification.ts

@@ -1,20 +1,51 @@
 import kycService, { authentification, errorMessage, truncateFields } from "./KYCService";
-import { cropByObb } from "../../utils/cropByObb";
+import { cropByObb, getObbConfidence, OBB_CONFIDENCE_THRESHOLD } from "../../utils/cropByObb";
 import { GovernmentDocumentType, IBbox } from "../../types/KYC.types";
+import { KycEnvironment } from "../../types/env.types";
 import { logger } from "../../utils/logger";
 
-export async function frontVerification(result: { path?: string, regionMapping: { authMethod: string[], mrzTypes: string[] }, selectedDocumentType: string, code: string, currentSide: string, templatePath?: string, mrzType?: string }) {
+export async function frontVerification(result: { path?: string, regionMapping: { authMethod: string[], mrzTypes: string[] }, selectedDocumentType: string, code: string, currentSide: string, templatePath?: string, mrzType?: string }, env: KycEnvironment = 'PRODUCTION') {
     try {
         console.log("Front verification START", JSON.stringify({ result }, null, 2));
         logger.log("Front verification", JSON.stringify({ result }, null, 2));
+        
+        // SANDBOX mode: skip AI verification and return mock response
+        if (env === 'SANDBOX') {
+            console.log("SANDBOX mode: Skipping AI verification for front document");
+            logger.log("SANDBOX mode: Returning mock front verification response");
+            const mockBbox: IBbox = { minX: 50, minY: 50, width: 200, height: 200 };
+            const mockResponse = {
+                result: true,
+                detail: [{ confidence: 0.95 }],
+                card_obb: { x: 50, y: 50, width: 200, height: 200 },
+                bbox: mockBbox,
+                ...(result.regionMapping.authMethod.includes('MRZ') ? {
+                    mrz: {
+                        success: true,
+                        parsed_data: {
+                            status: 'success',
+                            document_type: result.selectedDocumentType,
+                            mrz_type: result.mrzType || 'TD1'
+                        }
+                    }
+                } : {})
+            };
+            return mockResponse;
+        }
+        
         const token = await authentification();
-        const detected = await kycService.detectFaceOnId(result?.path || '', token, result?.selectedDocumentType || '')
+        const detected = await kycService.detectFaceOnId(result?.path || '', token, result?.selectedDocumentType || '', env)
 
         if (!detected.result) {
             throw new Error('Aucun visage détecté sur la carte. Veuillez reprendre.');
         }
 
-        // Optional: crop image using card_obb for better MRZ/barcode extraction
+        const obbConfidence = getObbConfidence((detected as any).card_obb);
+        if (obbConfidence !== null && obbConfidence < OBB_CONFIDENCE_THRESHOLD) {
+            throw new Error('Carte non entièrement visible. Positionnez toute la carte dans le cadre.');
+        }
+
+        // Optional: crop image using card_obb for better MRZ/barcode extraction (only when confidence >= threshold)
         let croppedBase64: string | undefined;
         let bbox: IBbox | undefined;
         let mrz: any | undefined;
@@ -36,7 +67,8 @@ export async function frontVerification(result: { path?: string, regionMapping:
                     token: token,
                     template_path: result?.templatePath || '',
                     mrz_type: result?.mrzType || ''
-                })
+                },
+                env)
 
         }
 
@@ -47,10 +79,38 @@ export async function frontVerification(result: { path?: string, regionMapping:
     }
 }
 
-export async function backVerification(result: { path?: string, regionMapping: { authMethod: string[], mrzTypes: string[] }, selectedDocumentType: string, code: string, currentSide: string, templatePath?: string, mrzType?: string }) {
+export async function backVerification(result: { path?: string, regionMapping: { authMethod: string[], mrzTypes: string[] }, selectedDocumentType: string, code: string, currentSide: string, templatePath?: string, mrzType?: string }, env: KycEnvironment = 'PRODUCTION') {
     try {
         if (!result.path) throw new Error('No path provided');
         logger.log("result.regionMapping", result.regionMapping, result.currentSide, result.code);
+        
+        // SANDBOX mode: skip AI verification and return mock response
+        if (env === 'SANDBOX') {
+            console.log("SANDBOX mode: Skipping AI verification for back document");
+            logger.log("SANDBOX mode: Returning mock back verification response");
+            const mockBbox: IBbox = { minX: 50, minY: 50, width: 200, height: 200 };
+            
+            if (result.regionMapping.authMethod.includes('MRZ')) {
+                return {
+                    success: true,
+                    parsed_data: {
+                        status: 'success',
+                        document_type: result.selectedDocumentType,
+                        mrz_type: result.mrzType || 'TD1'
+                    },
+                    bbox: mockBbox,
+                    card_obb: { x: 50, y: 50, width: 200, height: 200 }
+                };
+            } else if (result.regionMapping.authMethod.includes('2D_barcode')) {
+                return {
+                    barcode_data: 'SANDBOX_MOCK_BARCODE',
+                    bbox: mockBbox,
+                    card_obb: { x: 50, y: 50, width: 200, height: 200 }
+                };
+            }
+            return { bbox: mockBbox };
+        }
+        
         const token = await authentification();
 
 
@@ -68,7 +128,11 @@ export async function backVerification(result: { path?: string, regionMapping: {
                     token: token,
                     template_path: result?.templatePath || '',
                     mrz_type: result?.mrzType || ''
-                });
+                }, env);
+                const mrzObbConf = getObbConfidence((mrz as any).card_obb);
+                if (mrzObbConf !== null && mrzObbConf < OBB_CONFIDENCE_THRESHOLD) {
+                    throw new Error('Carte non entièrement visible. Positionnez toute la carte dans le cadre.');
+                }
                 let bbox: IBbox | undefined;
                 let croppedBase64: string | undefined;
 
@@ -82,7 +146,11 @@ export async function backVerification(result: { path?: string, regionMapping: {
             } catch (mrzError: any) {
                 logger.log("MRZ échoué, tentative d'extraction barcode");
                 try {
-                    const barcode = await kycService.extractBarcode({ fileUri: result.path!, token: token });
+                    const barcode = await kycService.extractBarcode({ fileUri: result.path!, token: token }, env);
+                    const barcodeObbConf = getObbConfidence((barcode as any).card_obb);
+                    if (barcodeObbConf !== null && barcodeObbConf < OBB_CONFIDENCE_THRESHOLD) {
+                        throw new Error('Carte non entièrement visible. Positionnez toute la carte dans le cadre.');
+                    }
                     return barcode;
                 } catch (barcodeError: any) {
                     throw new Error(`MRZ et barcode ont échoué. MRZ: ${mrzError?.message}, Barcode: ${barcodeError?.message}`);
@@ -108,7 +176,11 @@ export async function backVerification(result: { path?: string, regionMapping: {
                     token: token,
                     template_path: result?.templatePath || '',
                     mrz_type: result?.mrzType || ''
-                });
+                }, env);
+                const mrzObbConf = getObbConfidence((mrz as any).card_obb);
+                if (mrzObbConf !== null && mrzObbConf < OBB_CONFIDENCE_THRESHOLD) {
+                    throw new Error('Carte non entièrement visible. Positionnez toute la carte dans le cadre.');
+                }
                 let bbox: IBbox | undefined;
                 try {
                     const crop = await cropByObb(result?.path || '', (mrz as any).card_obb);
@@ -123,7 +195,11 @@ export async function backVerification(result: { path?: string, regionMapping: {
         if (result.regionMapping.authMethod.length > 0 && result.regionMapping.authMethod.includes('2D_barcode')) {
             try {
                 logger.log("Tentative d'extraction barcode");
-                const barcode = await kycService.extractBarcode({ fileUri: result.path!, token: token });
+                const barcode = await kycService.extractBarcode({ fileUri: result.path!, token: token }, env);
+                const barcodeObbConf = getObbConfidence((barcode as any).card_obb);
+                if (barcodeObbConf !== null && barcodeObbConf < OBB_CONFIDENCE_THRESHOLD) {
+                    throw new Error('Carte non entièrement visible. Positionnez toute la carte dans le cadre.');
+                }
                 let bbox: IBbox | undefined;
                 try {
                     const crop = await cropByObb(result?.path || '', (barcode as any).card_obb);
@@ -145,10 +221,20 @@ export async function backVerification(result: { path?: string, regionMapping: {
  * @param result 
  * @returns 
  */
-export async function checkTemplateType(result: { path?: string, docType: string, docRegion: string, postfix: string }) {
+export async function checkTemplateType(result: { path?: string, docType: string, docRegion: string, postfix: string }, env: KycEnvironment = 'PRODUCTION') {
     try {
+        // SANDBOX mode: skip AI verification and return mock response
+        if (env === 'SANDBOX') {
+            console.log("SANDBOX mode: Skipping AI template type check");
+            logger.log("SANDBOX mode: Returning mock template type response");
+            return {
+                template_path: `templates/${result.docType}_${result.docRegion}_${result.postfix}.jpg`,
+                card_obb: { x: 50, y: 50, width: 200, height: 200 }
+            };
+        }
+        
         const token = await authentification();
-        const templateType = await kycService.checkTemplateType({ fileUri: result.path || '', docType: result?.docType as GovernmentDocumentType, docRegion: result?.docRegion || "", postfix: result?.postfix, token: token });
+        const templateType = await kycService.checkTemplateType({ fileUri: result.path || '', docType: result?.docType as GovernmentDocumentType, docRegion: result?.docRegion || "", postfix: result?.postfix, token: token }, env);
 
         logger.log("templateType result", JSON.stringify(truncateFields(templateType), null, 2));
         return templateType;

package/src/modules/api/KYCService.ts

@@ -2,7 +2,21 @@ import axios from 'axios';
 import { GovernmentDocumentType, GovernmentDocumentTypeShorted, OrientationVideoResponse } from '../../types/KYC.types';
 import { CheckTemplateTypeResponse, ExtractMrzTextResponse } from '../../components/OverLay/type';
 import { SessionResponse, VerificationResult, VerificationSessionRequest } from './types';
+import { KycEnvironment } from '../../types/env.types';
 import { logger } from '../../utils/logger';
+import { Platform } from 'react-native';
+import KYCConfig from '../../config/KYCConfig';
+
+const appendFileToFormData = async (formData: FormData, key: string, uri: string, name: string = 'file.jpg', type: string = 'image/jpeg') => {
+  if (Platform.OS === 'web') {
+    const response = await fetch(uri);
+    const blob = await response.blob();
+    formData.append(key, blob, name);
+  } else {
+    formData.append(key, { uri, type, name } as any);
+  }
+};
+
 
 export interface KYCRequest {
   userId: string;
@@ -48,7 +62,6 @@ export class KYCService {
   private mrzServiceURL = 'https://kyc-engine.transfergratis.net:8002';
   private barcodeServiceURL = 'https://kyc-engine.transfergratis.net:8000';
   private orientationServiceURL = 'http://18.188.180.154:8080';
-  private backendServiceURL = 'https://service.sanctumkey.com/api/v1';
 
   constructor(baseURL: string, apiKey: string) {
     this.baseURL = baseURL;
@@ -120,12 +133,8 @@ export class KYCService {
   async processSelfieOrientationPicture(videoFile: string, token: string): Promise<SelfieVideoResponse[]> {
     try {
       const formData = new FormData();
-      const rnFile: any = {
-        uri: videoFile,
-        type: 'image/jpeg',
-        name: 'selfie_picture.jpg',
-      };
-      formData.append('file', rnFile);
+      await appendFileToFormData(formData, 'file', videoFile, 'selfie_picture.jpg', 'image/jpeg');
+
       const response = await axios.post<SelfieVideoResponse[]>(
         `${this.faceServiceURL}/detect_face_orientation/`,
         formData,
@@ -141,17 +150,27 @@ export class KYCService {
     }
   }
 
-  async processOrientationVideo(videoFile: string): Promise<OrientationVideoResponse> {
+  async processOrientationVideo(videoFile: string, env: KycEnvironment = 'PRODUCTION'): Promise<OrientationVideoResponse> {
     try {
+      // SANDBOX mode: skip AI verification and return mock response
+      if (env === 'SANDBOX') {
+        console.log("SANDBOX mode: Skipping AI orientation video processing");
+        logger.log("SANDBOX mode: Returning mock orientation video response");
+        return {
+          success: true,
+          data: {
+            center: { captured: true, frame: 10 },
+            left: { captured: true, frame: 30 },
+            right: { captured: true, frame: 50 }
+          },
+          message: 'SANDBOX: Orientation video processed successfully (mocked)'
+        };
+      }
+
       // Create FormData for multipart/form-data request
       const formData = new FormData();
-      // In React Native, prefer the { uri, type, name } pattern rather than Blob
-      const rnFile: any = {
-        uri: videoFile,
-        type: 'video/mp4',
-        name: 'orientation_video.mp4',
-      };
-      formData.append('file', rnFile);
+      await appendFileToFormData(formData, 'file', videoFile, 'orientation_video.mp4', 'video/mp4');
+
 
       const response = await axios.post(
         `${this.orientationServiceURL}/process_orientation_video_stream/`,
@@ -196,10 +215,21 @@ export class KYCService {
   }
 
   // STEP 1 - ID CARD VALIDATION
-  async detectFaceOnId(idCardImageUri: string, token: string, docType: string): Promise<{ result: boolean, detail: any[] }> {
+  async detectFaceOnId(idCardImageUri: string, token: string, docType: string, env: KycEnvironment = 'PRODUCTION'): Promise<{ result: boolean, detail: any[] }> {
+    // SANDBOX mode: skip AI verification and return mock response
+    if (env === 'SANDBOX') {
+      console.log("SANDBOX mode: Skipping AI face detection on ID");
+      logger.log("SANDBOX mode: Returning mock face detection response");
+      return {
+        result: true,
+        detail: [{ confidence: 0.95, bbox: [50, 50, 200, 200] }],
+        card_obb: { x: 50, y: 50, width: 200, height: 200 }
+      } as any;
+    }
+
     const formData = new FormData();
-    const rnFile: any = { uri: idCardImageUri, type: 'image/jpeg', name: 'id_card_photo.jpg' };
-    formData.append('file', rnFile);
+    await appendFileToFormData(formData, 'file', idCardImageUri, 'id_card_photo.jpg', 'image/jpeg');
+
     logger.log('detectFaceOnId formData', JSON.stringify(formData, null, 2));
 
     const docTypeShorted = GovernmentDocumentTypeShorted[docType as GovernmentDocumentType];
@@ -221,11 +251,22 @@ export class KYCService {
   }
 
   //check templatetemplate_type
-  async checkTemplateType(params: { fileUri: string; docType: string; docRegion: string; token: string; postfix: string }): Promise<any> {
+  async checkTemplateType(params: { fileUri: string; docType: string; docRegion: string; token: string; postfix: string }, env: KycEnvironment = 'PRODUCTION'): Promise<any> {
+    // SANDBOX mode: skip AI verification and return mock response
+    if (env === 'SANDBOX') {
+      console.log("SANDBOX mode: Skipping AI template type check");
+      logger.log("SANDBOX mode: Returning mock template type response");
+      const { docType, docRegion, postfix } = params;
+      return {
+        template_path: `templates/${docType}_${docRegion}_${postfix}.jpg`,
+        card_obb: { x: 50, y: 50, width: 200, height: 200 }
+      };
+    }
+
     const { fileUri, docType, docRegion, token, postfix } = params;
     const formData = new FormData();
-    const rnFile: any = { uri: fileUri, type: 'image/jpeg', name: 'id_card_front.jpg' };
-    formData.append('file', rnFile);
+    await appendFileToFormData(formData, 'file', fileUri, 'id_card_front.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}`;
 
@@ -247,8 +288,8 @@ export class KYCService {
   async extractDocumentInformation(params: { fileUri: string; docType: string; docRegion: string; token: string }): Promise<any> {
     const { fileUri, docType, docRegion, token } = params;
     const formData = new FormData();
-    const rnFile: any = { uri: fileUri, type: 'image/jpeg', name: 'id_card_front.jpg' };
-    formData.append('file', rnFile);
+    await appendFileToFormData(formData, 'file', fileUri, 'id_card_front.jpg', 'image/jpeg');
+
 
     const url = `${this.textExtractionServiceURL}/extract_doc_information/?doc_type=${encodeURIComponent(docType)}&doc_region=${encodeURIComponent(docRegion)}`;
     const attempt = async () => {
@@ -271,11 +312,21 @@ export class KYCService {
     }
   }
   // STEP 2 - barcode extraction
-  async extractBarcode(params: { fileUri: string; token: string }): Promise<any> {
+  async extractBarcode(params: { fileUri: string; token: string }, env: KycEnvironment = 'PRODUCTION'): Promise<any> {
+    // SANDBOX mode: skip AI verification and return mock response
+    if (env === 'SANDBOX') {
+      console.log("SANDBOX mode: Skipping AI barcode extraction");
+      logger.log("SANDBOX mode: Returning mock barcode response");
+      return {
+        barcode_data: 'SANDBOX_MOCK_BARCODE_DATA',
+        card_obb: { x: 50, y: 50, width: 200, height: 200 }
+      };
+    }
+
     const { fileUri, token } = params;
     const formData = new FormData();
-    const rnFile: any = { uri: fileUri, type: 'image/jpeg', name: 'id_card_back.jpg' };
-    formData.append('file', rnFile);
+    await appendFileToFormData(formData, 'file', fileUri, 'id_card_back.jpg', 'image/jpeg');
+
 
     const url = `${this.barcodeServiceURL}/decode_barcode/`;
     const attempt = async () => {
@@ -300,11 +351,29 @@ export class KYCService {
     }
   }
   // STEP 3 - MRZ TEXT EXTRACTION
-  async extractMrzText(params: { fileUri: string; docType: string; docRegion: string; postfix?: string; token: string; template_path: string; mrz_type: string }): Promise<any> {
+  async extractMrzText(params: { fileUri: string; docType: string; docRegion: string; postfix?: string; token: string; template_path: string; mrz_type: string }, env: KycEnvironment = 'PRODUCTION'): Promise<any> {
+    // SANDBOX mode: skip AI verification and return mock response
+    if (env === 'SANDBOX') {
+      console.log("SANDBOX mode: Skipping AI MRZ extraction");
+      logger.log("SANDBOX mode: Returning mock MRZ response");
+      const { docType, docRegion, postfix = 'back', mrz_type } = params;
+      return {
+        success: true,
+        parsed_data: {
+          status: 'success',
+          document_type: docType,
+          mrz_type: mrz_type || 'TD1',
+          doc_region: docRegion,
+          postfix: postfix
+        },
+        card_obb: { x: 50, y: 50, width: 200, height: 200 }
+      };
+    }
+
     const { fileUri, docType, docRegion, postfix = 'back', token, template_path, mrz_type } = params;
     const formData = new FormData();
-    const rnFile: any = { uri: fileUri, type: 'image/jpeg', name: 'id_card_back.jpg' };
-    formData.append('file', rnFile);
+    await appendFileToFormData(formData, 'file', fileUri, 'id_card_back.jpg', 'image/jpeg');
+
     const docTypeShorted = GovernmentDocumentTypeShorted[docType as GovernmentDocumentType];
     logger.log("docTypeShorted", docTypeShorted, docRegion, postfix);
 
@@ -335,13 +404,24 @@ export class KYCService {
   }
 
   // STEP 2 - SELFIE VALIDATION
-  async recognizeFace(params: { idPhotoUri: string; selfiePhotoUri: string }): Promise<{ is_match: boolean; similarity: number; id_bbox?: number[]; selfie_bbox?: number[] }> {
+  async recognizeFace(params: { idPhotoUri: string; selfiePhotoUri: string }, env: KycEnvironment = 'PRODUCTION'): Promise<{ is_match: boolean; similarity: number; id_bbox?: number[]; selfie_bbox?: number[] }> {
+    // SANDBOX mode: skip AI verification and return mock response
+    if (env === 'SANDBOX') {
+      console.log("SANDBOX mode: Skipping AI face recognition");
+      logger.log("SANDBOX mode: Returning mock face recognition response");
+      return {
+        is_match: true,
+        similarity: 0.95,
+        id_bbox: [50, 50, 200, 200],
+        selfie_bbox: [50, 50, 200, 200]
+      };
+    }
+
     const { idPhotoUri, selfiePhotoUri } = params;
     const formData = new FormData();
-    const idFile: any = { uri: idPhotoUri, type: 'image/jpeg', name: 'id_card_photo.jpg' };
-    const selfieFile: any = { uri: selfiePhotoUri, type: 'image/jpeg', name: 'selfie_final.jpg' };
-    formData.append('id_photo', idFile);
-    formData.append('selfie_photo', selfieFile);
+    await appendFileToFormData(formData, 'id_photo', idPhotoUri, 'id_card_photo.jpg', 'image/jpeg');
+    await appendFileToFormData(formData, 'selfie_photo', selfiePhotoUri, 'selfie_final.jpg', 'image/jpeg');
+
 
     const res = await axios.post(`${this.faceServiceURL}/recognize_face/`, formData, { timeout: 45000 });
     if (res.data?.detail) throw new Error(res.data.detail);
@@ -375,7 +455,7 @@ export class KYCService {
         "status": "PENDING",
         "metadata": {},
       }
-      const res = await axios.post<SessionResponse>(`${this.backendServiceURL}/verification/sessions/`,
+      const res = await axios.post<SessionResponse>(`${KYCConfig.getBackendUrl()}/verification/sessions/`,
         data, {
         headers: {
           'Content-Type': 'application/json',
@@ -419,7 +499,7 @@ export class KYCService {
         ...({ session_id: session_id }),
         timestamp: new Date().toISOString()
       }
-      const url = `${this.backendServiceURL}/verification/api/kyc/sessions/${session_id}/steps/${step}/`;
+      const url = `${KYCConfig.getBackendUrl()}/verification/api/kyc/sessions/${session_id}/steps/${step}/`;
 
 
       const logPayload = truncateFields({ payloadData, session_id, step });
@@ -444,11 +524,52 @@ export class KYCService {
       throw new Error(errorMessage(error));
     }
   }
+
+  /** Send email verification code. POST /api/v1/accounts/email/send/ */
+  async sendEmailVerificationCode(
+    email: string,
+    auth?: { apiKey?: string; token?: string }
+  ): Promise<unknown> {
+    const url = `${KYCConfig.getBackendUrl()}/accounts/email/send/`;
+    const token = auth?.apiKey ? undefined : (auth?.token ?? await authentification());
+    const res = await axios.post(
+      url,
+      { email },
+      {
+        headers: {
+          'Content-Type': 'application/json',
+          ...(auth?.apiKey ? { 'Authorization': `ApiKey ${auth.apiKey}` } : { 'Authorization': `Bearer ${token}` }),
+        },
+      }
+    );
+    return res.data;
+  }
+
+  /** Verify email with OTP. POST /api/v1/accounts/email/verify/ */
+  async verifyEmailCode(
+    otp: string,
+    auth?: { apiKey?: string; token?: string }
+  ): Promise<unknown> {
+    const url = `${KYCConfig.getBackendUrl()}/accounts/email/verify/`;
+    const token = auth?.apiKey ? undefined : (auth?.token ?? await authentification());
+    const res = await axios.post(
+      url,
+      { otp },
+      {
+        headers: {
+          'Content-Type': 'application/json',
+          ...(auth?.apiKey ? { 'Authorization': `ApiKey ${auth.apiKey}` } : { 'Authorization': `Bearer ${token}` }),
+        },
+      }
+    );
+    return res.data;
+  }
+
   // reultat de la verification
   async getVerificationResult(session_id: string): Promise<VerificationResult> {
     try {
       const token = await authentification();
-      const url = `${this.backendServiceURL}/verification/api/kyc/result/?session_id=${session_id}`;
+      const url = `${KYCConfig.getBackendUrl()}/verification/api/kyc/result/?session_id=${session_id}`;
       const res = await axios.get<VerificationResult>(url,
         { headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${token}` } });
       logger.log('getVerificationResult res', JSON.stringify(truncateFields(res.data), null, 2));