@trustchex/react-native-sdk 1.381.0 → 1.464.0

package/src/Shared/Libs/country-display.utils.ts

@@ -0,0 +1,55 @@
+import { ISOCountry } from '../EIDReader/data/isoCountry';
+import { UnicodeCountry } from '../EIDReader/data/unicodeCountry';
+
+const COUNTRY_NAME_OVERRIDES: Record<string, string> = {
+  TUR: 'Türkiye',
+};
+
+const findCountryByAlpha3 = (alpha3Code: string) => {
+  return [...UnicodeCountry.VALUES, ...ISOCountry.VALUES].find(
+    (country) => country.toAlpha3Code() === alpha3Code
+  );
+};
+
+export const getLocalizedCountryName = (
+  alpha3Code?: string | null,
+  _language?: string | null
+): string => {
+  if (!alpha3Code) return '';
+
+  const normalizedCode = alpha3Code.trim().toUpperCase();
+  const overrideName = COUNTRY_NAME_OVERRIDES[normalizedCode];
+
+  if (overrideName) {
+    return overrideName;
+  }
+
+  const country = findCountryByAlpha3(normalizedCode);
+  if (!country) {
+    return normalizedCode;
+  }
+
+  if (
+    typeof Intl !== 'undefined' &&
+    'Locale' in Intl &&
+    typeof Intl.Locale === 'function' &&
+    'DisplayNames' in Intl &&
+    typeof Intl.DisplayNames === 'function'
+  ) {
+    const nativeLanguage = new Intl.Locale(
+      `und-${country.toAlpha2Code()}`
+    ).maximize().language;
+
+    if (nativeLanguage) {
+      const nativeName = new Intl.DisplayNames([nativeLanguage], {
+        type: 'region',
+      }).of(country.toAlpha2Code());
+
+      if (nativeName) {
+        return nativeName;
+      }
+    }
+  }
+
+  return country.getName();
+};

package/src/Shared/Libs/crypto.utils.ts

@@ -9,8 +9,8 @@ const getSessionKey = async (apiUrl: string, sessionId: string) => {
   const clientPrivateKey = secp256k1.utils.randomPrivateKey();
   const clientPublicKey = secp256k1.getPublicKey(clientPrivateKey);
   const serverResponse = await httpClient.post<
-    { serverPublicKey: String },
-    { clientPublicKey: String }
+    { serverPublicKey: string },
+    { clientPublicKey: string }
   >(`${apiUrl}/verification-sessions/${sessionId}/auth`, {
     clientPublicKey: Buffer.from(clientPublicKey).toString('hex'),
   });

package/src/Shared/Libs/deeplink.utils.ts

@@ -10,7 +10,10 @@ const handleDeepLink = ({ url }: { url: string }) => {
   let sessionId = '';
 
   for (let i = 0; i < segments.length; i++) {
-    if (segments[i] === 'verification-session') {
+    if (
+      segments[i] === 'verification-session' ||
+      segments[i] === 'verification-sessions'
+    ) {
       sessionId = segments[i + 1] ?? '';
       debugLog('handleDeepLink', 'Found sessionId:', sessionId);
     } else if (segments[i] === 'app-url') {
@@ -19,6 +22,14 @@ const handleDeepLink = ({ url }: { url: string }) => {
     }
   }
 
+  // If no app-url segment found, derive baseUrl from the URL itself
+  if (!baseUrl && sessionId) {
+    const match = url.match(/^(https?:\/\/[^/]+)/);
+    if (match) {
+      baseUrl = match[1];
+    }
+  }
+
   debugLog('handleDeepLink', 'Returning:', { baseUrl, sessionId });
   return [baseUrl, sessionId];
 };

package/src/Shared/Libs/demo.utils.ts

@@ -36,6 +36,16 @@ const demoSession = {
         },
       },
     },
+    {
+      type: 'VERBAL_CONSENT',
+      required: false,
+      data: {
+        voiceGuidanceActive: true,
+        verbalConsentTitle: 'Verbal Consent',
+        verbalConsentText:
+          'I hereby provide my verbal consent for identity verification purposes. I confirm that all information provided is accurate and complete.',
+      },
+    },
     {
       type: 'IDENTITY_DOCUMENT_SCAN',
       required: false,

package/src/Shared/Libs/http-client.ts

@@ -64,6 +64,14 @@ const request = async <TResponse, TBody>(
   let statusCode = 0;
   let success = false;
 
+  console.log(`[HTTP] ${httpMethod} ${url}`);
+  if (body) {
+    console.log(
+      '[HTTP] Request body:',
+      JSON.stringify(body).substring(0, 200) + '...'
+    );
+  }
+
   try {
     const response = await fetch(url, {
       method: httpMethod,
@@ -75,13 +83,23 @@ const request = async <TResponse, TBody>(
 
     statusCode = response.status;
     success = response.ok;
+    console.log(
+      `[HTTP] Response status: ${statusCode} ${response.ok ? '✓' : '✗'}`
+    );
 
     let responseJson = null;
 
     try {
       responseJson = await response.json();
+      if (responseJson) {
+        console.log(
+          '[HTTP] Response body:',
+          JSON.stringify(responseJson).substring(0, 200) + '...'
+        );
+      }
     } catch (error) {
       // Invalid JSON response
+      console.log('[HTTP] Response body: (non-JSON)');
     }
 
     // Track API call performance (non-blocking)
@@ -204,7 +222,7 @@ const post = <TResponse, TBody>(
 
 const put = <TResponse, TBody>(
   url: string,
-  body?: any,
+  body?: TBody,
   simulatedResponse?: TResponse
 ) => {
   return request<TResponse, TBody>('PUT', url, body, simulatedResponse);

package/src/Shared/Libs/mrz.utils.ts

@@ -114,8 +114,9 @@ const fixMRZ = (rawText: string): string => {
       // Must contain filler characters
       if (!/<+/.test(line)) return false;
 
-      // Prioritize lines starting with I< (document code)
-      if (line.startsWith('I<')) return true;
+      // Lines starting with a valid MRZ document code (ICAO 9303):
+      // I (ID cards), A (residence permits, admin docs), C (crew), P (passport), V (visa)
+      if (/^[IACPV][<A-Z]/.test(line)) return true;
 
       // Or lines with numbers and fillers (second line of TD1: birth date, expiry, etc.)
       if (/\d{5,}/.test(line) && /<{3,}/.test(line)) return true;

package/src/Shared/Libs/promise.utils.ts

@@ -4,17 +4,31 @@ const runWithRetry = async <T>(
   delay: number = 1000
 ): Promise<T> => {
   let retries = 0;
+  let lastError: Error | unknown;
   let result: T;
   while (retries < maxRetries) {
     try {
+      if (retries > 0) {
+        console.log(`[Retry] Attempt ${retries + 1}/${maxRetries}...`);
+      }
       result = await fn();
+      if (retries > 0) {
+        console.log(`[Retry] ✓ Success on attempt ${retries + 1}`);
+      }
       return result;
     } catch (error) {
+      lastError = error;
       retries++;
-      await new Promise((resolve) => setTimeout(resolve, delay * retries));
+      console.error(`[Retry] ✗ Attempt ${retries}/${maxRetries} failed:`, error instanceof Error ? error.message : error);
+      if (retries < maxRetries) {
+        const waitTime = delay * retries;
+        console.log(`[Retry] Waiting ${waitTime}ms before retry...`);
+        await new Promise((resolve) => setTimeout(resolve, waitTime));
+      }
     }
   }
-  throw new Error('Max retries exceeded');
+  console.error('[Retry] ✗ All retries exhausted. Last error:', lastError);
+  throw new Error(`Max retries (${maxRetries}) exceeded. Last error: ${lastError instanceof Error ? lastError.message : String(lastError)}`);
 };
 
 export { runWithRetry };

package/src/Shared/Libs/status-bar.utils.ts

@@ -0,0 +1,21 @@
+import { Platform, StatusBar } from 'react-native';
+import { useEffect } from 'react';
+
+/**
+ * Configure status bar for white background with dark content for better contrast
+ */
+export const configureStatusBarForWhiteBackground = (): void => {
+  StatusBar.setBarStyle('dark-content', true);
+  if (Platform.OS === 'android') {
+    StatusBar.setBackgroundColor('#ffffff', true);
+  }
+};
+
+/**
+ * Hook to configure status bar for white background on mount
+ */
+export const useStatusBarWhiteBackground = (): void => {
+  useEffect(() => {
+    configureStatusBarForWhiteBackground();
+  }, []);
+};

package/src/Shared/Services/DataUploadService.ts

@@ -0,0 +1,395 @@
+import RNFS from 'react-native-fs';
+import { Platform } from 'react-native';
+import type {
+  IdentificationInfo,
+  ScannedIdentityDocument,
+  LivenessDetection,
+} from '../Types/identificationInfo';
+import { getSessionKey, encryptWithAes } from '../Libs/crypto.utils';
+import mrzUtils from '../Libs/mrz.utils';
+import httpClient from '../Libs/http-client';
+import { NotFoundError } from '../Libs/http-client';
+import { runWithRetry } from '../Libs/promise.utils';
+
+/**
+ * Service to upload collected identification data to the backend.
+ * This is used to send data before/during video call so agents can see it.
+ */
+export class DataUploadService {
+  private baseUrl: string;
+  private apiUrl: string;
+
+  constructor(baseUrl: string) {
+    this.baseUrl = baseUrl;
+    this.apiUrl = `${baseUrl}/api/app/mobile`;
+  }
+
+  private async ensureIdentificationExists(
+    identificationId: string
+  ): Promise<void> {
+    console.log(
+      '[DataUploadService] POST',
+      `${this.apiUrl}/identifications/${identificationId}`
+    );
+    await httpClient.post(
+      `${this.apiUrl}/identifications/${identificationId}`,
+      {}
+    );
+    console.log('[DataUploadService] ✓ Identification created/verified');
+  }
+
+  /**
+   * Submit document data to the backend (same approach as ResultScreen)
+   */
+  async submitDocumentData(
+    identificationId: string,
+    scannedDocument: ScannedIdentityDocument,
+    sessionKey: string
+  ): Promise<void> {
+    if (!scannedDocument || scannedDocument.documentType === 'UNKNOWN') {
+      console.log('[DataUploadService] No document data to submit');
+      return;
+    }
+
+    const mrzFields = scannedDocument.mrzFields;
+    if (!mrzFields) {
+      console.log('[DataUploadService] No MRZ fields to submit');
+      return;
+    }
+
+    const identificationDocument = {
+      type: mrzFields.documentCode,
+      name: mrzFields.firstName,
+      surname: mrzFields.lastName,
+      gender: this.getGenderEnumType(mrzFields.sex),
+      number: mrzFields.documentNumber,
+      country: mrzFields.issuingState,
+      barcodeValue: scannedDocument.barcodeValue,
+      personalNumber: mrzFields.personalNumber || mrzFields.optional1,
+      birthDate: mrzUtils.convertMRZDateToISODate(mrzFields.birthDate),
+      expiryDate: mrzUtils.convertMRZDateToISODate(mrzFields.expirationDate),
+      dataSource: scannedDocument.dataSource,
+      mrzText: scannedDocument.mrzText,
+    };
+
+    console.log(
+      '[DataUploadService] Submitting document data:',
+      identificationDocument.type,
+      identificationDocument.number
+    );
+
+    const { encryptedData, nonce } = encryptWithAes(
+      JSON.stringify(identificationDocument),
+      sessionKey
+    );
+
+    console.log(
+      '[DataUploadService] POST',
+      `${this.apiUrl}/identifications/${identificationId}/documents`
+    );
+    await runWithRetry(() =>
+      httpClient.post(
+        `${this.apiUrl}/identifications/${identificationId}/documents`,
+        {
+          encryptedData,
+          nonce,
+        }
+      )
+    );
+
+    console.log('[DataUploadService] ✓ Document data submitted');
+  }
+
+  /**
+   * Upload media files (document images, selfies, etc.)
+   */
+  async uploadMedia(
+    identificationId: string,
+    scannedDocument?: ScannedIdentityDocument,
+    livenessDetection?: LivenessDetection,
+    onProgress?: (progress: number) => void
+  ): Promise<void> {
+    const uploadFileOptions: RNFS.UploadFileOptions = {
+      toUrl: `${this.apiUrl}/identifications/${identificationId}/media`,
+      method: 'POST',
+      headers: {
+        Accept: 'application/json',
+      },
+      files: [],
+      progress: (res) => {
+        const progress = res.totalBytesSent / res.totalBytesExpectedToSend;
+        onProgress?.(progress);
+      },
+    };
+
+    // Add document front image
+    const frontImage = scannedDocument?.frontImage;
+    if (frontImage && frontImage !== '') {
+      const filePath = `${RNFS.TemporaryDirectoryPath}/DOCUMENT_FRONT_IMAGE.jpg`;
+      await RNFS.writeFile(decodeURIComponent(filePath), frontImage, 'base64');
+      uploadFileOptions.files.push({
+        name: 'files',
+        filename: 'DOCUMENT_FRONT_IMAGE.jpg',
+        filepath: decodeURIComponent(filePath),
+        filetype: 'image/jpeg',
+      });
+    }
+
+    // Add document back image
+    const backImage = scannedDocument?.backImage;
+    if (backImage && backImage !== '') {
+      const filePath = `${RNFS.TemporaryDirectoryPath}/DOCUMENT_BACK_IMAGE.jpg`;
+      await RNFS.writeFile(decodeURIComponent(filePath), backImage, 'base64');
+      uploadFileOptions.files.push({
+        name: 'files',
+        filename: 'DOCUMENT_BACK_IMAGE.jpg',
+        filepath: decodeURIComponent(filePath),
+        filetype: 'image/jpeg',
+      });
+    }
+
+    // Add face image from document
+    const faceImage = scannedDocument?.faceImage;
+    if (faceImage && faceImage !== '') {
+      const filePath = `${RNFS.TemporaryDirectoryPath}/FACE_IMAGE.jpg`;
+      await RNFS.writeFile(decodeURIComponent(filePath), faceImage, 'base64');
+      uploadFileOptions.files.push({
+        name: 'files',
+        filename: 'FACE_IMAGE.jpg',
+        filepath: decodeURIComponent(filePath),
+        filetype: 'image/jpeg',
+      });
+    }
+
+    // Add secondary face image from document (optional)
+    const secondaryFaceImage = scannedDocument?.secondaryFaceImage;
+    if (secondaryFaceImage && secondaryFaceImage !== '') {
+      const filePath = `${RNFS.TemporaryDirectoryPath}/DOCUMENT_SECONDARY_FACE_IMAGE.jpg`;
+      await RNFS.writeFile(
+        decodeURIComponent(filePath),
+        secondaryFaceImage,
+        'base64'
+      );
+      uploadFileOptions.files.push({
+        name: 'files',
+        filename: 'DOCUMENT_SECONDARY_FACE_IMAGE.jpg',
+        filepath: decodeURIComponent(filePath),
+        filetype: 'image/jpeg',
+      });
+    }
+
+    // Add hologram image from document (optional)
+    const hologramImage = scannedDocument?.hologramImage;
+    if (hologramImage && hologramImage !== '') {
+      const filePath = `${RNFS.TemporaryDirectoryPath}/DOCUMENT_HOLOGRAM_IMAGE.jpg`;
+      await RNFS.writeFile(
+        decodeURIComponent(filePath),
+        hologramImage,
+        'base64'
+      );
+      uploadFileOptions.files.push({
+        name: 'files',
+        filename: 'DOCUMENT_HOLOGRAM_IMAGE.jpg',
+        filepath: decodeURIComponent(filePath),
+        filetype: 'image/jpeg',
+      });
+    }
+
+    // Add liveness images and selfie from liveness detection
+    if (livenessDetection?.instructions) {
+      for (const instruction of livenessDetection.instructions) {
+        if (instruction?.photo) {
+          const filePath = `${RNFS.TemporaryDirectoryPath}/LIVENESS_${instruction.instruction}_IMAGE.jpg`;
+          await RNFS.writeFile(
+            decodeURIComponent(filePath),
+            instruction.photo,
+            'base64'
+          );
+          uploadFileOptions.files.push({
+            name: 'files',
+            filename: `LIVENESS_${instruction.instruction}_IMAGE.jpg`,
+            filepath: decodeURIComponent(filePath),
+            filetype: 'image/jpeg',
+          });
+
+          if (instruction.instruction === 'LOOK_STRAIGHT_AND_BLINK') {
+            uploadFileOptions.files.push({
+              name: 'files',
+              filename: 'SELFIE_IMAGE.jpg',
+              filepath: decodeURIComponent(filePath),
+              filetype: 'image/jpeg',
+            });
+          }
+        }
+      }
+    }
+
+    // Add liveness video (optional)
+    if (livenessDetection?.videoPath) {
+      let videoFilePath: string;
+      if (Platform.OS === 'ios') {
+        const tempDir = `${RNFS.TemporaryDirectoryPath}/${new Date().getTime()}`;
+        await RNFS.mkdir(tempDir);
+        videoFilePath = `${tempDir}/LIVENESS_VIDEO.mp4`;
+      } else {
+        videoFilePath = `${RNFS.TemporaryDirectoryPath}/LIVENESS_VIDEO.mp4`;
+      }
+
+      await RNFS.copyFile(livenessDetection.videoPath, videoFilePath);
+
+      uploadFileOptions.files.push({
+        name: 'files',
+        filename: 'LIVENESS_VIDEO.mp4',
+        filepath: decodeURIComponent(videoFilePath),
+        filetype: 'video/mp4',
+      });
+    }
+
+    // Skip upload if no files
+    if (uploadFileOptions.files.length === 0) {
+      console.log('[DataUploadService] No media files to upload');
+      return;
+    }
+
+    console.log(
+      '[DataUploadService] Uploading',
+      uploadFileOptions.files.length,
+      'media files to',
+      uploadFileOptions.toUrl
+    );
+    const response = await runWithRetry(
+      () => RNFS.uploadFiles(uploadFileOptions).promise
+    );
+    console.log(
+      '[DataUploadService] Upload response status:',
+      response.statusCode
+    );
+
+    if (![200, 201, 204].includes(response.statusCode)) {
+      console.error(
+        '[DataUploadService] Media upload failed:',
+        response.statusCode,
+        response.body
+      );
+      throw new Error(`Media upload failed: ${response.statusCode}`);
+    }
+
+    console.log('[DataUploadService] ✓ Media uploaded successfully');
+  }
+
+  /**
+   * Upload all collected data (document + media) before video call
+   */
+  async uploadCollectedData(
+    identificationInfo: IdentificationInfo,
+    onProgress?: (progress: number) => void
+  ): Promise<boolean> {
+    const { identificationId, sessionId, scannedDocument, livenessDetection } =
+      identificationInfo;
+    let { authToken } = identificationInfo;
+
+    if (!identificationId) {
+      console.log('[DataUploadService] No identification ID, skipping upload');
+      return false;
+    }
+
+    console.log(
+      '[DataUploadService] ========== UPLOADING COLLECTED DATA =========='
+    );
+    console.log('[DataUploadService] Identification ID:', identificationId);
+    console.log('[DataUploadService] Has document:', !!scannedDocument);
+    console.log('[DataUploadService] Has liveness:', !!livenessDetection);
+    console.log('[DataUploadService] Has auth token:', !!authToken);
+
+    try {
+      await runWithRetry(() =>
+        this.ensureIdentificationExists(identificationId)
+      );
+
+      // Always refresh session key for current session (required for encrypted submission)
+      if (sessionId) {
+        const existingAuthToken = authToken;
+        console.log('[DataUploadService] Getting session key...');
+        try {
+          authToken = await runWithRetry(() =>
+            getSessionKey(this.apiUrl, sessionId)
+          );
+          console.log('[DataUploadService] ✓ Session key obtained');
+        } catch (error) {
+          if (existingAuthToken) {
+            console.warn(
+              '[DataUploadService] Session key refresh failed, using existing token'
+            );
+            authToken = existingAuthToken;
+          } else {
+            throw error;
+          }
+        }
+      }
+
+      if (!authToken) {
+        console.log(
+          '[DataUploadService] No session key available, skipping upload'
+        );
+        return false;
+      }
+
+      // Step 1: Submit document data (using same encryption as ResultScreen)
+      if (scannedDocument) {
+        onProgress?.(0.1);
+        await runWithRetry(() =>
+          this.submitDocumentData(identificationId, scannedDocument, authToken)
+        );
+        onProgress?.(0.3);
+      }
+
+      // Step 2: Upload media files (images only, skip video for now - too slow)
+      onProgress?.(0.4);
+      await runWithRetry(() =>
+        this.uploadMedia(
+          identificationId,
+          scannedDocument,
+          livenessDetection,
+          (p) => {
+            onProgress?.(0.4 + p * 0.5);
+          }
+        )
+      );
+      onProgress?.(1.0);
+
+      console.log('[DataUploadService] ✓ All collected data uploaded');
+
+      // Mark media as uploaded during video call
+      identificationInfo.mediaUploadedDuringVideoCall = true;
+
+      // Store the auth token back for future use
+      identificationInfo.authToken = authToken;
+      return true;
+    } catch (error) {
+      if (error instanceof NotFoundError) {
+        console.warn(
+          '[DataUploadService] Upload skipped: identification is not active anymore'
+        );
+        return false;
+      }
+      console.error(
+        '[DataUploadService] Failed to upload collected data:',
+        error
+      );
+      return false;
+    }
+  }
+
+  private getGenderEnumType(sex: string | undefined): string {
+    switch (sex?.toLowerCase()) {
+      case 'male':
+      case 'm':
+        return 'M';
+      case 'female':
+      case 'f':
+        return 'F';
+      default:
+        return 'X';
+    }
+  }
+}