@trustchex/react-native-sdk 1.409.0 → 1.472.0

package/src/Shared/Libs/contains.ts

@@ -4,56 +4,3 @@ export interface Rect {
   width: number;
   height: number;
 }
-
-interface Contains {
-  outside: Rect;
-  inside: Rect;
-}
-
-export function contains({ outside, inside }: Contains) {
-  const outsideMaxX = outside.minX + outside.width;
-  const insideMaxX = inside.minX + inside.width;
-
-  const outsideMaxY = outside.minY + outside.height;
-  const insideMaxY = inside.minY + inside.height;
-
-  if (inside.minX < outside.minX) {
-    return false;
-  }
-  if (insideMaxX > outsideMaxX) {
-    return false;
-  }
-  if (inside.minY < outside.minY) {
-    return false;
-  }
-  if (insideMaxY > outsideMaxY) {
-    return false;
-  }
-
-  return true;
-}
-
-export function contains2({ outside, inside }: Contains) {
-  const outsideMaxX = outside.minX + outside.width;
-  const insideMaxX = inside.minX + inside.width;
-
-  const outsideMaxY = outside.minY + outside.height;
-  const insideMaxY = inside.minY + inside.height;
-
-  const xIntersect = Math.max(
-    0,
-    Math.min(insideMaxX, outsideMaxX) - Math.max(inside.minX, outside.minX)
-  );
-  const yIntersect = Math.max(
-    0,
-    Math.min(insideMaxY, outsideMaxY) - Math.max(inside.minY, outside.minY)
-  );
-  const intersectArea = xIntersect * yIntersect;
-
-  const insideArea = inside.width * inside.height;
-  const outsideArea = outside.width * outside.height;
-
-  const unionArea = insideArea + outsideArea - intersectArea;
-
-  return unionArea === outsideArea;
-}

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/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

@@ -66,7 +66,10 @@ const request = async <TResponse, TBody>(
 
   console.log(`[HTTP] ${httpMethod} ${url}`);
   if (body) {
-    console.log('[HTTP] Request body:', JSON.stringify(body).substring(0, 200) + '...');
+    console.log(
+      '[HTTP] Request body:',
+      JSON.stringify(body).substring(0, 200) + '...'
+    );
   }
 
   try {
@@ -80,14 +83,19 @@ const request = async <TResponse, TBody>(
 
     statusCode = response.status;
     success = response.ok;
-    console.log(`[HTTP] Response status: ${statusCode} ${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) + '...');
+        console.log(
+          '[HTTP] Response body:',
+          JSON.stringify(responseJson).substring(0, 200) + '...'
+        );
       }
     } catch (error) {
       // Invalid JSON response
@@ -214,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/index.ts

@@ -0,0 +1,63 @@
+// Export utility modules with validated symbols only.
+export { default as PermissionManager } from './permissions.utils';
+export type { PermissionType } from './permissions.utils';
+export { SignalingClient } from './SignalingClient';
+
+export {
+  setDebugMode,
+  setLogLevel,
+  isDebugEnabled,
+  getLogLevel,
+  traceLog,
+  debugLog,
+  infoLog,
+  debugWarn,
+  debugError,
+  logError,
+  logWarn,
+} from './debug.utils';
+
+export {
+  default as HTTPClient,
+  HttpClientError,
+  UnauthorizedError,
+  ForbiddenError,
+  NotFoundError,
+  BadRequestError,
+  TooManyRequestsError,
+  InternalServerError,
+} from './http-client';
+
+export * from './analytics.utils';
+export type { Rect } from './contains';
+export { getLocalizedCountryName } from './country-display.utils';
+export { getSessionKey, encryptWithAes, decryptWithAes } from './crypto.utils';
+export { default as debounce } from './debounce.utils';
+export { handleDeepLink } from './deeplink.utils';
+export { getSimulatedDemoData, isDemoSession } from './demo.utils';
+export { default as MRZUtils } from './mrz.utils';
+export { NativeDeviceInfo } from './native-device-info.utils';
+export { default as getDeviceInfo } from './native-device-info.utils';
+
+export {
+  useKeepAwake,
+  enableKeepAwake,
+  disableKeepAwake,
+  isKeepAwakeCurrentlyActive,
+  getKeepAwakeStats,
+} from './native-keep-awake.utils';
+
+export { runWithRetry } from './promise.utils';
+
+export {
+  configureStatusBarForWhiteBackground,
+  useStatusBarWhiteBackground,
+} from './status-bar.utils';
+
+export {
+  speak,
+  speakWithDebounce,
+  stopSpeaking,
+  resetLastMessage,
+  initializeTTS,
+} from './tts.utils';

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/permissions.utils.ts

@@ -0,0 +1,251 @@
+import {
+  Platform,
+  NativeModules,
+  PermissionsAndroid,
+  type Permission,
+} from 'react-native';
+import { debugLog, debugError, debugWarn } from './debug.utils';
+
+const { PermissionModule } = NativeModules;
+
+export type PermissionType = 'camera' | 'microphone' | 'nfc';
+
+class PermissionManager {
+  private static permissionCache: Map<PermissionType, boolean> = new Map();
+
+  /**
+   * Request a single permission
+   */
+  static async requestPermission(permission: PermissionType): Promise<boolean> {
+    try {
+      if (Platform.OS === 'android') {
+        return await this.requestAndroidPermission(permission);
+      } else {
+        return await this.requestIOSPermission(permission);
+      }
+    } catch (error) {
+      debugError(
+        'PermissionManager',
+        `Failed to request ${permission}:`,
+        error
+      );
+      return false;
+    }
+  }
+
+  /**
+   * Request multiple permissions at once
+   */
+  static async requestPermissions(
+    permissions: PermissionType[]
+  ): Promise<Map<PermissionType, boolean>> {
+    const results = new Map<PermissionType, boolean>();
+
+    if (Platform.OS === 'android') {
+      const androidPermissions = permissions.map((p) =>
+        this.permissionTypeToAndroid(p)
+      );
+      const granted =
+        await PermissionsAndroid.requestMultiple(androidPermissions);
+
+      permissions.forEach((p, i) => {
+        const isGranted =
+          granted[androidPermissions[i]] === PermissionsAndroid.RESULTS.GRANTED;
+        results.set(p, isGranted);
+      });
+    } else {
+      for (const permission of permissions) {
+        const isGranted = await this.requestIOSPermission(permission);
+        results.set(permission, isGranted);
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Check if a permission is granted (without requesting)
+   */
+  static async checkPermission(permission: PermissionType): Promise<boolean> {
+    try {
+      if (Platform.OS === 'android') {
+        const androidPerm = this.permissionTypeToAndroid(permission);
+        const result = await PermissionsAndroid.check(androidPerm);
+        return result;
+      } else {
+        return await this.checkIOSPermission(permission);
+      }
+    } catch (error) {
+      debugError(
+        'PermissionManager',
+        `Failed to check ${permission} permission:`,
+        error
+      );
+      return false;
+    }
+  }
+
+  /**
+   * Request permission with user-friendly error handling
+   */
+  static async requestWithFallback(
+    permission: PermissionType,
+    onDenied?: () => void
+  ): Promise<boolean> {
+    const isGranted = await this.requestPermission(permission);
+
+    if (!isGranted) {
+      debugLog('PermissionManager', `${permission} permission denied`);
+      onDenied?.();
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Convenience method: Request camera and microphone together (for video recording)
+   */
+  static async requestCameraAndMicrophone(): Promise<boolean> {
+    const permissions = await this.requestPermissions(['camera', 'microphone']);
+
+    const hasCamera = permissions.get('camera') ?? false;
+    const hasMicrophone = permissions.get('microphone') ?? false;
+
+    return hasCamera && hasMicrophone;
+  }
+
+  /**
+   * Convenience method: Request camera only
+   */
+  static async requestCamera(): Promise<boolean> {
+    return this.requestPermission('camera');
+  }
+
+  /**
+   * Convenience method: Request microphone only
+   */
+  static async requestMicrophone(): Promise<boolean> {
+    return this.requestPermission('microphone');
+  }
+
+  /**
+   * Convenience method: Request NFC only
+   */
+  static async requestNFC(): Promise<boolean> {
+    return this.requestPermission('nfc');
+  }
+
+  /**
+   * Check if camera and microphone are both accessible
+   */
+  static async hasCameraAndMicrophone(): Promise<boolean> {
+    const camera = await this.checkPermission('camera');
+    const microphone = await this.checkPermission('microphone');
+    return camera && microphone;
+  }
+
+  /**
+   * Check if camera is accessible
+   */
+  static async hasCamera(): Promise<boolean> {
+    return this.checkPermission('camera');
+  }
+
+  /**
+   * Check if microphone is accessible
+   */
+  static async hasMicrophone(): Promise<boolean> {
+    return this.checkPermission('microphone');
+  }
+
+  /**
+   * Check if NFC is accessible
+   */
+  static async hasNFC(): Promise<boolean> {
+    return this.checkPermission('nfc');
+  }
+
+  // Private helper methods
+
+  private static permissionTypeToAndroid(permission: PermissionType): Permission {
+    const map: Record<PermissionType, Permission> = {
+      camera: PermissionsAndroid.PERMISSIONS.CAMERA,
+      microphone: PermissionsAndroid.PERMISSIONS.RECORD_AUDIO,
+      nfc: 'android.permission.NFC' as Permission,
+    };
+    return map[permission];
+  }
+
+  private static async requestAndroidPermission(
+    permission: PermissionType
+  ): Promise<boolean> {
+    const androidPerm = this.permissionTypeToAndroid(permission);
+    const result = await PermissionsAndroid.request(androidPerm);
+    return result === PermissionsAndroid.RESULTS.GRANTED;
+  }
+
+  private static async requestIOSPermission(
+    permission: PermissionType
+  ): Promise<boolean> {
+    if (!PermissionModule) {
+      debugLog(
+        'PermissionManager',
+        'PermissionModule not available, assuming permission granted'
+      );
+      return true;
+    }
+
+    try {
+      switch (permission) {
+        case 'camera':
+          return await PermissionModule.requestCameraPermission();
+        case 'microphone':
+          return await PermissionModule.requestMicrophonePermission();
+        case 'nfc':
+          // NFC permission on iOS is automatically handled when NFCManager is initialized
+          // No explicit permission request needed
+          return true;
+        default:
+          return false;
+      }
+    } catch (error) {
+      debugError(
+        'PermissionManager',
+        `iOS permission request failed for ${permission}:`,
+        error
+      );
+      return false;
+    }
+  }
+
+  private static async checkIOSPermission(
+    permission: PermissionType
+  ): Promise<boolean> {
+    if (!PermissionModule) {
+      return true;
+    }
+
+    try {
+      switch (permission) {
+        case 'camera':
+          return await PermissionModule.checkCameraPermission?.();
+        case 'microphone':
+          return await PermissionModule.checkMicrophonePermission?.();
+        case 'nfc':
+          return true;
+        default:
+          return false;
+      }
+    } catch (error) {
+      debugWarn(
+        'PermissionManager',
+        `iOS permission check failed for ${permission}`,
+        error
+      );
+      return false;
+    }
+  }
+}
+
+export default PermissionManager;

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

@@ -1,4 +1,4 @@
-import { StatusBar } from 'react-native';
+import { Platform, StatusBar } from 'react-native';
 import { useEffect } from 'react';
 
 /**
@@ -6,7 +6,9 @@ import { useEffect } from 'react';
  */
 export const configureStatusBarForWhiteBackground = (): void => {
   StatusBar.setBarStyle('dark-content', true);
-  StatusBar.setBackgroundColor('#ffffff', true);
+  if (Platform.OS === 'android') {
+    StatusBar.setBackgroundColor('#ffffff', true);
+  }
 };
 
 /**

package/src/Shared/Services/VideoSessionService.ts

@@ -127,7 +127,7 @@ export class VideoSessionService {
       console.log('[VideoSessionService] Creating SSE connection to:', url);
 
       const es = new EventSource(url);
-      let heartbeatInterval: NodeJS.Timeout | null = null;
+      let heartbeatInterval: ReturnType<typeof setInterval> | null = null;
 
       es.addEventListener('open', () => {
         console.log('[VideoSessionService] Queue SSE connected');

package/src/Shared/Types/analytics.types.ts

@@ -82,6 +82,8 @@ export enum AnalyticsEventName {
   IDENTITY_DOCUMENT_EID_SCAN_COMPLETED = 'identity_document_eid_scan_completed',
   LIVENESS_CHECK_STARTED = 'liveness_check_started',
   LIVENESS_CHECK_COMPLETED = 'liveness_check_completed',
+  VERBAL_CONSENT_VIDEO_STARTED = 'verbal_consent_video_started',
+  VERBAL_CONSENT_VIDEO_COMPLETED = 'verbal_consent_video_completed',
   VIDEO_CALL_STARTED = 'video_call_started',
   VIDEO_CALL_COMPLETED = 'video_call_completed',
 

package/src/Shared/Types/identificationInfo.ts

@@ -14,6 +14,14 @@ export interface IdentificationInfo {
   authToken?: string;
   videoSessionId?: string;
   mediaUploadedDuringVideoCall?: boolean;
+  verbalConsentVideos?: VerbalConsentVideo[];
+}
+
+export interface VerbalConsentVideo {
+  title: string;
+  text: string;
+  videoPath: string;
+  recordedSeconds?: number;
 }
 
 export interface ScannedIdentityDocument {
@@ -42,6 +50,7 @@ export interface WorkflowStep {
     | 'IDENTITY_DOCUMENT_SCAN'
     | 'IDENTITY_DOCUMENT_EID_SCAN'
     | 'LIVENESS_CHECK'
+    | 'VERBAL_CONSENT'
     | 'AML_CHECK'
     | 'VIDEO_CALL';
   data?: {
@@ -61,6 +70,8 @@ export interface WorkflowStep {
     allowedCountries?: 'TUR'[] | null;
     allowedLivenessInstructionTypes?: LivenessInstructionType[] | null;
     voiceGuidanceActive?: boolean;
+    verbalConsentTitle?: string | null;
+    verbalConsentText?: string | null;
   };
   required: boolean;
 }

package/src/Translation/Resources/en.ts

@@ -49,6 +49,9 @@ export default {
   'resultScreen.demoImageHologram': 'Hologram',
   'resultScreen.demoLivenessDetection': 'Liveness Detection',
   'resultScreen.demoVideo': 'Video',
+  'resultScreen.demoVerbalConsent': 'Verbal Consent',
+  'resultScreen.demoVerbalConsentTitle': 'Title',
+  'resultScreen.demoVerbalConsentText': 'Text',
   'resultScreen.demoStartOver': 'Start Over',
   'livenessDetectionScreen.guideHeader': 'Face Verification',
   'livenessDetectionScreen.guideText':
@@ -83,10 +86,8 @@ export default {
     'When prompted, hold your document flat against the back of your device near the NFC antenna.',
   'eidScannerScreen.invalidMRZFields':
     'Document information could not be read. Please try again.',
-  'eidScannerScreen.imageCannotBeShown':
-    'Photo data found but cannot be displayed.',
   'eidScannerScreen.faceImageNotFound': 'Photo data not found on document.',
-  'eidScannerScreen.documentCode': 'Document Code',
+  'eidScannerScreen.documentCode': 'Document Type',
   'eidScannerScreen.nationality': 'Nationality',
   'eidScannerScreen.personalNumber': 'Personal Number',
   'eidScannerScreen.documentNumber': 'Document Number',
@@ -94,7 +95,15 @@ export default {
   'eidScannerScreen.surname': 'Surname',
   'eidScannerScreen.birthDate': 'Date of Birth',
   'eidScannerScreen.gender': 'Gender',
+  'eidScannerScreen.genderMale': 'Male',
+  'eidScannerScreen.genderFemale': 'Female',
+  'eidScannerScreen.genderUnspecified': 'Unspecified',
+  'eidScannerScreen.docTypePassport': 'Passport',
+  'eidScannerScreen.docTypeID': 'ID Card',
+  'eidScannerScreen.docTypeResidence': 'Residence Permit',
+  'eidScannerScreen.docTypeVisa': 'Visa',
   'eidScannerScreen.expirationDate': 'Expiration Date',
+  'eidScannerScreen.issuingState': 'Issuing State',
   'eidScannerScreen.mrzText': 'MRZ Text',
   'eidScannerScreen.nfcNotSupported':
     'This device does not support NFC functionality.',
@@ -183,6 +192,58 @@ export default {
   'videoCallScreen.agentInstructions': 'Instructions from Agent',
   'videoCallScreen.callNotCompleted':
     'Video call was not completed. This step is required to proceed.',
+  'verbalConsentVideoScreen.title': 'Verbal Consent',
+  'verbalConsentVideoScreen.description':
+    'Read the text below clearly while recording your video.',
+  'verbalConsentVideoScreen.guideHeader':
+    'Prepare for verbal consent recording',
+  'verbalConsentVideoScreen.guideText':
+    'Before you start recording, please ensure the following:',
+  'verbalConsentVideoScreen.guidePoint1':
+    'Stay in a quiet environment with minimal background noise',
+  'verbalConsentVideoScreen.guidePoint2':
+    'Keep your full face visible in good lighting',
+  'verbalConsentVideoScreen.guidePoint3':
+    'Read the consent text clearly and without rushing',
+  'verbalConsentVideoScreen.guidePoint4':
+    'Keep your phone steady until recording completes',
+  'verbalConsentVideoScreen.defaultConsentText':
+    'I confirm my identity and give my explicit consent to the processing of my personal data for digital identity verification. I acknowledge that my biometric data will be used solely for this purpose. I understand that I can withdraw this consent at any time.',
+  'verbalConsentVideoScreen.startRecording': 'Start Recording',
+  'verbalConsentVideoScreen.stopRecording': 'Stop Recording',
+  'verbalConsentVideoScreen.recordAgain': 'Record Again',
+  'verbalConsentVideoScreen.tryAgain': 'Try Again',
+  'verbalConsentVideoScreen.submit': 'Continue',
+  'verbalConsentVideoScreen.recordingProgress': 'Recording: {{current}}s',
+  'verbalConsentVideoScreen.readNowPrompt':
+    'Read the text aloud — touch screen to pause.',
+  'verbalConsentVideoScreen.scrollReadStopHint':
+    'Scroll to the end to enable Stop Recording.',
+  'verbalConsentVideoScreen.scrollCompletedStopHint':
+    'Great. You reached the end. You can stop recording after finishing the full text.',
+  'verbalConsentVideoScreen.recordingIndicator': 'Recording',
+  'verbalConsentVideoScreen.recordingStartedBanner':
+    'Recording started. Read the full text and scroll to the end.',
+  'verbalConsentVideoScreen.keepHeadInCirclePrompt':
+    'Place your head inside the circle and keep it there until recording is complete.',
+  'verbalConsentVideoScreen.readThenStopPrompt':
+    'Read the text shown on screen, then stop recording.',
+  'verbalConsentVideoScreen.readProgress':
+    'Read progress (estimated): {{current}}/{{target}}s',
+  'verbalConsentVideoScreen.stopHintPending':
+    'Keep reading the full text before stopping.',
+  'verbalConsentVideoScreen.stopHintReady':
+    'Looks complete. You can stop recording now.',
+  'verbalConsentVideoScreen.faceAligned':
+    'Face aligned. You can start recording.',
+  'verbalConsentVideoScreen.previewTitle':
+    'Review your recording and make sure the text is clear before continuing.',
+  'verbalConsentVideoScreen.analytics.recordingFailed':
+    'Video recording failed',
+  'verbalConsentVideoScreen.analytics.identificationIdMissing':
+    'Identification ID is missing before upload',
+  'verbalConsentVideoScreen.analytics.uploadFailed':
+    'Consent video upload failed',
   'navigationManager.skipStepWarning':
     'Completing this step is recommended for successful verification. Skip anyway?',
   'navigationManager.skipStepLabel': 'Skip This Step',