@transfergratis/react-native-sdk 0.1.23 → 0.1.25

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',
@@ -36,6 +64,16 @@ export const en = {
       ]
     },
 
+    welcome: {
+      requirements: 'What you\'ll need:',
+      estimatedTime: 'Estimated time:',
+      consent: 'Please accept the following:',
+      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'
+    },
+
     // Location Capture
     locationCapture: {
       title: 'Secure Your Verification',
@@ -88,6 +126,9 @@ export const en = {
       success: 'ID captured successfully',
       error: 'Failed to capture ID. Please try again.',
       captureTitle: '%{side} side of your government document',
+      continueOnPhone: 'Continue on Phone',
+      continueOnMobile: 'Continue on Mobile',
+      scanQrCode: 'Scan this QR code with your phone to continue the verification process.',
     },
 
     // Selfie Capture
@@ -204,7 +245,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
@@ -35,6 +49,15 @@ export const fr = {
         'Une connexion internet stable'
       ]
     },
+    welcome: {
+      requirements: 'Ce dont vous aurez besoin :',
+      estimatedTime: 'Temps estimé :',
+      consent: 'Veuillez accepter les suivants :',
+      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'
+    },
 
     // Location Capture
     locationCapture: {
@@ -88,6 +111,9 @@ 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é',
+      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
@@ -204,7 +230,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/index.ts

@@ -4,8 +4,22 @@ 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';
 
+// Export Template Flow Components
+export { TemplateKYCFlow } from './components/TemplateKYCFlowRefactored';
+
+// Export Template Service and Utilities
+export { default as templateService } from './modules/api/TemplateService';
+export { transformBackendTemplateToSDK, validateTransformedTemplate } from './utils/template-transformer';
+export { useTemplateLoader } from './hooks/useTemplateLoader';
+
+// Export Template Components
+export { WelcomeTemplate } from './components/KYCElements/WelcomeTemplate';
+
 // Export Web KYC Components
 export { WebKYCEntry } from './web';

package/src/modules/api/CardAuthentification.ts

@@ -1,14 +1,40 @@
 import kycService, { authentification, errorMessage, truncateFields } from "./KYCService";
 import { cropByObb } 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.');
@@ -36,7 +62,8 @@ export async function frontVerification(result: { path?: string, regionMapping:
                     token: token,
                     template_path: result?.templatePath || '',
                     mrz_type: result?.mrzType || ''
-                })
+                },
+                env)
 
         }
 
@@ -47,10 +74,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 +123,7 @@ export async function backVerification(result: { path?: string, regionMapping: {
                     token: token,
                     template_path: result?.templatePath || '',
                     mrz_type: result?.mrzType || ''
-                });
+                }, env);
                 let bbox: IBbox | undefined;
                 let croppedBase64: string | undefined;
 
@@ -82,7 +137,7 @@ 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);
                     return barcode;
                 } catch (barcodeError: any) {
                     throw new Error(`MRZ et barcode ont échoué. MRZ: ${mrzError?.message}, Barcode: ${barcodeError?.message}`);
@@ -108,7 +163,7 @@ export async function backVerification(result: { path?: string, regionMapping: {
                     token: token,
                     template_path: result?.templatePath || '',
                     mrz_type: result?.mrzType || ''
-                });
+                }, env);
                 let bbox: IBbox | undefined;
                 try {
                     const crop = await cropByObb(result?.path || '', (mrz as any).card_obb);
@@ -123,7 +178,7 @@ 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);
                 let bbox: IBbox | undefined;
                 try {
                     const crop = await cropByObb(result?.path || '', (barcode as any).card_obb);
@@ -145,10 +200,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,13 +215,25 @@ 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');
 
-    const docTypeShorted = GovernmentDocumentTypeShorted[docType as GovernmentDocumentType];
+    logger.log('detectFaceOnId formData', JSON.stringify(formData, null, 2));
 
+    const docTypeShorted = GovernmentDocumentTypeShorted[docType as GovernmentDocumentType];
+    logger.log('detectFaceOnId docTypeShorted', docTypeShorted);
     try {
       const res = await axios.post(`${this.faceServiceURL}/detect_face/?doc_type=${docTypeShorted}`, formData,
         {
@@ -220,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}`;
 
@@ -246,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 () => {
@@ -270,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 () => {
@@ -299,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);
 
@@ -334,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);
@@ -374,12 +455,12 @@ 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',
-            ...(apiKey ? { 'Authorization': `ApiKey ${apiKey}` } : { 'Authorization': `Bearer ${token}` })
-          }
+        headers: {
+          'Content-Type': 'application/json',
+          ...(apiKey ? { 'Authorization': `ApiKey ${apiKey}` } : { 'Authorization': `Bearer ${token}` })
+        }
       });
       return res.data;
     } catch (error: any) {
@@ -418,19 +499,21 @@ 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 });
       logger.log('verificationSession payload',
-        JSON.stringify(truncateFields({ logPayload, token:token??"-", path: url, apiKey }),
+        JSON.stringify(truncateFields({ logPayload, token: token ?? "-", path: url, apiKey }),
           null, 2))
 
       const res = await axios.post<SessionResponse>(url,
         payloadData,
         {
-          headers: { 'Content-Type': 'application/json', 
-            ...(apiKey ? { 'Authorization': `ApiKey ${apiKey}` } : { 'Authorization': `Bearer ${token}` }) }
+          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;
@@ -445,7 +528,7 @@ export class KYCService {
   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));
@@ -482,6 +565,7 @@ export function truncateFields(obj: any, maxLength = 420): any {
 }
 export const authentification = async () => {
   try {
+    logger.log('authentification params', 'kyc_frontend', 'ZCW4mGaJXWR0UuI40lM1pHNQmYLw2xvX');
     const params = new URLSearchParams();
     params.append('client_id', 'kyc_frontend');
     params.append('client_secret', 'ZCW4mGaJXWR0UuI40lM1pHNQmYLw2xvX');

package/src/modules/api/SelfieVerification.ts

@@ -1,11 +1,33 @@
-import kycService, { authentification } from "./KYCService";
+import kycService, { authentification, SelfieVideoResponse } from "./KYCService";
 
-const selfieVerification = async (selfieImage: string) => {
-    const token = await authentification();
+import { KycEnvironment } from "../../types/env.types";
+
+const selfieVerification = async (selfieImage: string, env: KycEnvironment = 'PRODUCTION'): Promise<SelfieVideoResponse[]> => {
+    // In SANDBOX mode, skip AI verification and return a mock success response
+    if (env === 'SANDBOX') {
+        console.log("SANDBOX mode: Skipping AI verification for selfie");
+        // Return a mock response that simulates successful verification
+        // This allows the flow to continue without actual AI processing
+        
+        const mockResponse: SelfieVideoResponse[] = [{
+            orientation_direction: "center",
+            turn_score: 1.0,
+            bbox: [0, 0, 100, 100],
+            capture: true,
+            instruction: "SANDBOX: AI verification skipped",
+            error: ""
+        }];
+        return mockResponse;
+    }
 
+    // PRODUCTION mode: perform actual AI verification
+    const token = await authentification();
     const response = await kycService.processSelfieOrientationPicture(selfieImage, token);
     console.log("selfieVerification response", JSON.stringify(response, null, 2));
     return response;
 }
 
+
+
+
 export default selfieVerification;