@trustchex/react-native-sdk 1.475.1 → 1.481.1

package/src/Screens/Dynamic/LivenessDetectionScreen.tsx

@@ -35,6 +35,7 @@ import { useTranslation } from 'react-i18next';
 import StyledButton from '../../Shared/Components/StyledButton';
 import LottieView from 'lottie-react-native';
 import { speak, resetLastMessage } from '../../Shared/Libs/tts.utils';
+import { secureShuffle } from '../../Shared/Libs/shuffle.utils';
 import { useStatusBarWhiteBackground } from '../../Shared/Libs/status-bar.utils';
 import {
   trackFunnelStep,
@@ -202,8 +203,8 @@ const LivenessDetectionScreen = () => {
   }, [hasGuideShown]);
 
   useEffect(() => {
-    const il = Object.keys(instructions)
-      .filter(
+    const il = secureShuffle(
+      Object.keys(instructions).filter(
         (instruction) =>
           !['START', 'FINISH'].includes(instruction) &&
           // Look straight and blink is always included
@@ -216,7 +217,7 @@ const LivenessDetectionScreen = () => {
               instruction as any
             ))
       )
-      .sort(() => Math.random() - 0.5);
+    );
     il.unshift('START');
     il.push('FINISH');
     setInitialState({

package/src/Screens/Static/QrCodeScanningScreen.tsx

@@ -4,7 +4,8 @@ import { SafeAreaView, StyleSheet } from 'react-native';
 import AppContext from '../../Shared/Contexts/AppContext';
 import QrCodeScannerCamera from '../../Shared/Components/QrCodeScannerCamera';
 import { useNavigation } from '@react-navigation/native';
-import { handleDeepLink } from '../../Shared/Libs/deeplink.utils';
+import { handleDeepLink, getUrlHost } from '../../Shared/Libs/deeplink.utils';
+import { logWarn } from '../../Shared/Libs/debug.utils';
 import { useKeepAwake } from '../../Shared/Libs/native-keep-awake.utils';
 import { useStatusBarWhiteBackground } from '../../Shared/Libs/status-bar.utils';
 
@@ -17,7 +18,23 @@ const QrCodeScanningScreen = () => {
   useStatusBarWhiteBackground();
 
   const onQrCodeScanned = (data: string) => {
-    const [bUrl, sId] = handleDeepLink({ url: data });
+    let [bUrl, sId] = handleDeepLink({ url: data });
+
+    // A scanned QR may not repoint an already-configured backend to another
+    // host — uploads carry identity documents and biometrics. Keep the
+    // configured baseUrl and only take the session id from the QR.
+    const configuredBaseUrl = appContext.baseUrl;
+    if (
+      bUrl &&
+      configuredBaseUrl &&
+      getUrlHost(bUrl) !== getUrlHost(configuredBaseUrl)
+    ) {
+      logWarn(
+        'QrCodeScanningScreen',
+        'Ignoring QR-provided baseUrl with mismatched host'
+      );
+      bUrl = configuredBaseUrl;
+    }
 
     if (bUrl && sId) {
       if (appContext.setBaseUrl) {

package/src/Screens/Static/ResultScreen.tsx

@@ -17,7 +17,7 @@ import {
 } from 'react-native';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
 import AppContext from '../../Shared/Contexts/AppContext';
-import httpClient from '../../Shared/Libs/http-client';
+import httpClient, { getSessionToken } from '../../Shared/Libs/http-client';
 import RNFS from 'react-native-fs';
 import NativeProgressBar from '../../Shared/Components/NativeProgressBar';
 import LottieView from 'lottie-react-native';
@@ -39,7 +39,32 @@ import { Video as VideoCompressor } from 'react-native-compressor';
 import { encryptWithAes, getSessionKey } from '../../Shared/Libs/crypto.utils';
 import Video from 'react-native-video';
 import StyledButton from '../../Shared/Components/StyledButton';
+import DiagnosticReportButton from '../../Shared/Components/DiagnosticReportButton';
+import type { DiagnosticImage } from '../../Shared/Libs/sendDiagnosticReport';
 import NativeDeviceInfo from '../../Shared/Libs/native-device-info.utils';
+
+/**
+ * Collect the captured document/face images (base64) as attachments for a
+ * diagnostic report. On an ID card the BACK image is the MRZ side; on a passport
+ * the front carries the MRZ. The NFC chip face arrives as `faceImage` with its
+ * own mime type, which may be png.
+ */
+const collectDiagnosticImages = (
+  doc?: ScannedIdentityDocument
+): DiagnosticImage[] => {
+  if (!doc) return [];
+  const out: DiagnosticImage[] = [];
+  const push = (name: string, b64?: string, mime: 'jpg' | 'png' = 'jpg') => {
+    if (b64 && b64 !== '') out.push({ name, base64: b64, mime });
+  };
+  push('mrz-side', doc.backImage);
+  push('front', doc.frontImage);
+  const faceMime = doc.faceImageMimeType === 'image/png' ? 'png' : 'jpg';
+  push('face', doc.faceImage, faceMime);
+  push('secondary-face', doc.secondaryFaceImage);
+  push('hologram', doc.hologramImage);
+  return out;
+};
 import {
   trackError,
   trackFunnelStep,
@@ -285,11 +310,15 @@ const ResultScreen = () => {
         return;
       }
 
+      const uploadSessionToken = getSessionToken();
       const uploadFileOptions: RNFS.UploadFileOptions = {
         toUrl: `${apiUrl}/identifications/${identificationId}/media`,
         method: 'POST',
         headers: {
           Accept: 'application/json',
+          ...(uploadSessionToken
+            ? { 'X-Session-Token': uploadSessionToken }
+            : {}),
         },
         files: [],
         progress: (res) => {
@@ -299,186 +328,143 @@ const ResultScreen = () => {
         },
       } satisfies RNFS.UploadFileOptions;
 
-      const frontImage = scannedIdentityDocument?.frontImage;
-      if (frontImage && frontImage !== '') {
-        await RNFS.writeFile(
-          decodeURIComponent(
-            `${RNFS.TemporaryDirectoryPath}/DOCUMENT_FRONT_IMAGE.jpg`
-          ),
-          frontImage,
-          'base64'
+      // Plaintext identity images/video staged on disk for the multipart
+      // upload; everything tracked here is deleted in the finally below.
+      const tempPaths: string[] = [];
+
+      const writeTempImage = async (
+        fileName: string,
+        base64Data: string,
+        filetype: string = 'image/jpeg'
+      ) => {
+        const filePath = decodeURIComponent(
+          `${RNFS.TemporaryDirectoryPath}/${fileName}`
         );
+        await RNFS.writeFile(filePath, base64Data, 'base64');
+        tempPaths.push(filePath);
         uploadFileOptions.files.push({
           name: 'files',
-          filename: 'DOCUMENT_FRONT_IMAGE.jpg',
-          filepath: decodeURIComponent(
-            `${RNFS.TemporaryDirectoryPath}/DOCUMENT_FRONT_IMAGE.jpg`
-          ),
-          filetype: 'image/jpeg',
+          filename: fileName,
+          filepath: filePath,
+          filetype,
         });
-      }
+        return filePath;
+      };
 
-      const backImage = scannedIdentityDocument?.backImage;
-      if (backImage && backImage !== '') {
-        await RNFS.writeFile(
-          decodeURIComponent(
-            `${RNFS.TemporaryDirectoryPath}/DOCUMENT_BACK_IMAGE.jpg`
-          ),
-          backImage,
-          'base64'
-        );
-        uploadFileOptions.files.push({
-          name: 'files',
-          filename: 'DOCUMENT_BACK_IMAGE.jpg',
-          filepath: decodeURIComponent(
-            `${RNFS.TemporaryDirectoryPath}/DOCUMENT_BACK_IMAGE.jpg`
-          ),
-          filetype: 'image/jpeg',
-        });
-      }
+      try {
+        const frontImage = scannedIdentityDocument?.frontImage;
+        if (frontImage && frontImage !== '') {
+          await writeTempImage('DOCUMENT_FRONT_IMAGE.jpg', frontImage);
+        }
 
-      const faceImage = scannedIdentityDocument?.faceImage;
-      if (faceImage && faceImage !== '') {
-        scannedIdentityDocument.faceImageMimeType ||= 'image/jpeg';
-        const extension =
-          scannedIdentityDocument.faceImageMimeType === 'image/jp2'
-            ? 'jp2'
-            : scannedIdentityDocument.faceImageMimeType === 'image/png'
-              ? 'png'
-              : 'jpg';
-        await RNFS.writeFile(
-          decodeURIComponent(
-            `${RNFS.TemporaryDirectoryPath}/FACE_IMAGE.${extension}`
-          ),
-          faceImage,
-          'base64'
-        );
-        uploadFileOptions.files.push({
-          name: 'files',
-          filename: `FACE_IMAGE.${extension}`,
-          filepath: decodeURIComponent(
-            `${RNFS.TemporaryDirectoryPath}/FACE_IMAGE.${extension}`
-          ),
-          filetype: scannedIdentityDocument.faceImageMimeType,
-        });
-      }
+        const backImage = scannedIdentityDocument?.backImage;
+        if (backImage && backImage !== '') {
+          await writeTempImage('DOCUMENT_BACK_IMAGE.jpg', backImage);
+        }
 
-      const secondaryFaceImage = scannedIdentityDocument?.secondaryFaceImage;
-      if (secondaryFaceImage && secondaryFaceImage !== '') {
-        await RNFS.writeFile(
-          decodeURIComponent(
-            `${RNFS.TemporaryDirectoryPath}/DOCUMENT_SECONDARY_FACE_IMAGE.jpg`
-          ),
-          secondaryFaceImage,
-          'base64'
-        );
-        uploadFileOptions.files.push({
-          name: 'files',
-          filename: 'DOCUMENT_SECONDARY_FACE_IMAGE.jpg',
-          filepath: decodeURIComponent(
-            `${RNFS.TemporaryDirectoryPath}/DOCUMENT_SECONDARY_FACE_IMAGE.jpg`
-          ),
-          filetype: 'image/jpeg',
-        });
-      }
+        const faceImage = scannedIdentityDocument?.faceImage;
+        if (faceImage && faceImage !== '') {
+          scannedIdentityDocument.faceImageMimeType ||= 'image/jpeg';
+          const extension =
+            scannedIdentityDocument.faceImageMimeType === 'image/jp2'
+              ? 'jp2'
+              : scannedIdentityDocument.faceImageMimeType === 'image/png'
+                ? 'png'
+                : 'jpg';
+          await writeTempImage(
+            `FACE_IMAGE.${extension}`,
+            faceImage,
+            scannedIdentityDocument.faceImageMimeType
+          );
+        }
 
-      const hologramImage = scannedIdentityDocument?.hologramImage;
-      if (hologramImage && hologramImage !== '') {
-        await RNFS.writeFile(
-          decodeURIComponent(
-            `${RNFS.TemporaryDirectoryPath}/DOCUMENT_HOLOGRAM_IMAGE.jpg`
-          ),
-          hologramImage,
-          'base64'
-        );
-        uploadFileOptions.files.push({
-          name: 'files',
-          filename: 'DOCUMENT_HOLOGRAM_IMAGE.jpg',
-          filepath: decodeURIComponent(
-            `${RNFS.TemporaryDirectoryPath}/DOCUMENT_HOLOGRAM_IMAGE.jpg`
-          ),
-          filetype: 'image/jpeg',
-        });
-      }
+        const secondaryFaceImage = scannedIdentityDocument?.secondaryFaceImage;
+        if (secondaryFaceImage && secondaryFaceImage !== '') {
+          await writeTempImage(
+            'DOCUMENT_SECONDARY_FACE_IMAGE.jpg',
+            secondaryFaceImage
+          );
+        }
 
-      if (livenessDetection) {
-        for (const instruction of livenessDetection.instructions) {
-          if (instruction.photo !== '') {
-            await RNFS.writeFile(
-              decodeURIComponent(
-                `${RNFS.TemporaryDirectoryPath}/LIVENESS_${instruction.instruction}_IMAGE.jpg`
-              ),
-              instruction.photo,
-              'base64'
-            );
-            uploadFileOptions.files.push({
-              name: 'files',
-              filename: `LIVENESS_${instruction.instruction}_IMAGE.jpg`,
-              filepath: decodeURIComponent(
-                `${RNFS.TemporaryDirectoryPath}/LIVENESS_${instruction.instruction}_IMAGE.jpg`
-              ),
-              filetype: 'image/jpeg',
-            });
-            if (instruction.instruction === 'LOOK_STRAIGHT_AND_BLINK') {
-              uploadFileOptions.files.push({
-                name: 'files',
-                filename: 'SELFIE_IMAGE.jpg',
-                filepath: decodeURIComponent(
-                  `${RNFS.TemporaryDirectoryPath}/LIVENESS_${instruction.instruction}_IMAGE.jpg`
-                ),
-                filetype: 'image/jpeg',
-              });
-            }
-          }
+        const hologramImage = scannedIdentityDocument?.hologramImage;
+        if (hologramImage && hologramImage !== '') {
+          await writeTempImage('DOCUMENT_HOLOGRAM_IMAGE.jpg', hologramImage);
         }
 
-        const livenessVideoPath = livenessDetection.videoPath;
-        if (livenessVideoPath) {
-          let videoFilePath: string;
-          if (Platform.OS === 'ios') {
-            const tmpTimestamp = new Date().getTime();
-            await RNFS.mkdir(`${RNFS.TemporaryDirectoryPath}/${tmpTimestamp}`);
-            videoFilePath = `${RNFS.TemporaryDirectoryPath}/${tmpTimestamp}/LIVENESS_VIDEO.mp4`;
-          } else {
-            videoFilePath = `${RNFS.TemporaryDirectoryPath}/LIVENESS_VIDEO.mp4`;
+        if (livenessDetection) {
+          for (const instruction of livenessDetection.instructions) {
+            if (instruction.photo !== '') {
+              const filePath = await writeTempImage(
+                `LIVENESS_${instruction.instruction}_IMAGE.jpg`,
+                instruction.photo
+              );
+              if (instruction.instruction === 'LOOK_STRAIGHT_AND_BLINK') {
+                uploadFileOptions.files.push({
+                  name: 'files',
+                  filename: 'SELFIE_IMAGE.jpg',
+                  filepath: filePath,
+                  filetype: 'image/jpeg',
+                });
+              }
+            }
           }
-          await RNFS.copyFile(livenessVideoPath, videoFilePath);
 
-          // Compress video with maximum compression settings
-          const compressedVideoPath = await VideoCompressor.compress(
-            videoFilePath,
-            {
-              compressionMethod: 'manual',
-              bitrate: 500000, // 500 kbps
-              maxSize: 1280, // HD 720p
-              minimumFileSizeForCompress: 0, // Always compress
-            },
-            (compressionProgress) => {
-              // Map compression progress (0-1) to main progress (40-60%)
-              setProgress(40 + compressionProgress * 20);
+          const livenessVideoPath = livenessDetection.videoPath;
+          if (livenessVideoPath) {
+            let videoFilePath: string;
+            if (Platform.OS === 'ios') {
+              const tmpTimestamp = new Date().getTime();
+              const tempDir = `${RNFS.TemporaryDirectoryPath}/${tmpTimestamp}`;
+              await RNFS.mkdir(tempDir);
+              tempPaths.push(tempDir);
+              videoFilePath = `${tempDir}/LIVENESS_VIDEO.mp4`;
+            } else {
+              videoFilePath = `${RNFS.TemporaryDirectoryPath}/LIVENESS_VIDEO.mp4`;
+              tempPaths.push(videoFilePath);
             }
-          );
+            await RNFS.copyFile(livenessVideoPath, videoFilePath);
+
+            // Compress video with maximum compression settings
+            const compressedVideoPath = await VideoCompressor.compress(
+              videoFilePath,
+              {
+                compressionMethod: 'manual',
+                bitrate: 500000, // 500 kbps
+                maxSize: 1280, // HD 720p
+                minimumFileSizeForCompress: 0, // Always compress
+              },
+              (compressionProgress) => {
+                // Map compression progress (0-1) to main progress (40-60%)
+                setProgress(40 + compressionProgress * 20);
+              }
+            );
 
-          // Convert file:// URI to regular path for RNFS upload
-          const normalizedPath = compressedVideoPath.replace('file://', '');
+            // Convert file:// URI to regular path for RNFS upload
+            const normalizedPath = compressedVideoPath.replace('file://', '');
+            tempPaths.push(normalizedPath);
 
-          uploadFileOptions.files.push({
-            name: 'files',
-            filename: 'LIVENESS_VIDEO.mp4',
-            filepath: normalizedPath,
-            filetype: 'video/mp4',
-          });
+            uploadFileOptions.files.push({
+              name: 'files',
+              filename: 'LIVENESS_VIDEO.mp4',
+              filepath: normalizedPath,
+              filetype: 'video/mp4',
+            });
+          }
         }
-      }
 
-      if (uploadFileOptions.files.length === 0) {
-        return;
-      }
+        if (uploadFileOptions.files.length === 0) {
+          return;
+        }
 
-      const response = await RNFS.uploadFiles(uploadFileOptions).promise;
+        const response = await RNFS.uploadFiles(uploadFileOptions).promise;
 
-      if (![200, 201, 204].includes(response.statusCode)) {
-        throw new Error('Media upload failed');
+        if (![200, 201, 204].includes(response.statusCode)) {
+          throw new Error('Media upload failed');
+        }
+      } finally {
+        await Promise.all(
+          tempPaths.map((path) => RNFS.unlink(path).catch(() => {}))
+        );
       }
     },
     [apiUrl]
@@ -518,11 +504,15 @@ const ResultScreen = () => {
           ''
         );
 
+        const consentSessionToken = getSessionToken();
         const response = await RNFS.uploadFiles({
           toUrl: `${apiUrl}/identifications/${identificationId}/media`,
           method: 'POST',
           headers: {
             Accept: 'application/json',
+            ...(consentSessionToken
+              ? { 'X-Session-Token': consentSessionToken }
+              : {}),
           },
           fields: {
             consentTitle: consentVideo.title,
@@ -1080,7 +1070,7 @@ const ResultScreen = () => {
                 )}
               </View>
             </ScrollView>
-            <View style={{ paddingBottom: insets.bottom }}>
+            <View style={[styles.footer, { paddingBottom: insets.bottom + 20 }]}>
               <StyledButton
                 mode="contained"
                 onPress={() => {
@@ -1090,6 +1080,26 @@ const ResultScreen = () => {
               >
                 {t('resultScreen.demoStartOver')}
               </StyledButton>
+              <DiagnosticReportButton
+                sessionId={appContext.identificationInfo?.sessionId}
+                scan={{
+                  documentType:
+                    appContext.identificationInfo?.scannedDocument
+                      ?.documentType,
+                  dataSource:
+                    appContext.identificationInfo?.scannedDocument?.dataSource,
+                  mrzText:
+                    appContext.identificationInfo?.scannedDocument?.mrzText,
+                  mrzFields:
+                    appContext.identificationInfo?.scannedDocument?.mrzFields,
+                  barcodeValue:
+                    appContext.identificationInfo?.scannedDocument
+                      ?.barcodeValue,
+                }}
+                images={collectDiagnosticImages(
+                  appContext.identificationInfo?.scannedDocument
+                )}
+              />
             </View>
           </>
         ) : (

package/src/Shared/Components/DebugOverlay.tsx

@@ -625,14 +625,17 @@ export const TestModePanel = React.memo(function TestModePanel({
         <View style={{ padding: 10 }}>
           <TextView
             style={{
-              color: '#FFA500',
+              // Green "GO" header: the panel only ever receives a STABLE + valid
+              // consensus MRZ (the caller withholds it until then), so showing it
+              // here IS the reliable-detection signal.
+              color: '#4CAF50',
               fontSize: 12,
               fontWeight: 'bold',
               marginBottom: 8,
               textAlign: 'center',
             }}
           >
-            MRZ Text Read
+            ✓ MRZ STABLE — GO
           </TextView>
           <TextView
             style={{

package/src/Shared/Components/DiagnosticReportButton.tsx

@@ -0,0 +1,77 @@
+import React, { useState } from 'react';
+import { Alert } from 'react-native';
+import { useTranslation } from 'react-i18next';
+import StyledButton from './StyledButton';
+import {
+  sendDiagnosticReport,
+  isDiagnosticSharingAvailable,
+  type DiagnosticImage,
+} from '../Libs/sendDiagnosticReport';
+import type { ScanDataForReport } from '../Libs/diagnosticReport';
+import { SDK_VERSION } from '../../version';
+
+export interface DiagnosticReportButtonProps {
+  scan: ScanDataForReport;
+  sessionId?: string;
+  images?: DiagnosticImage[];
+}
+
+/**
+ * "Report a scanning issue" button for the result screen.
+ *
+ * Shows a brief notice describing what will be shared (the draft itself is the
+ * user's review/consent step), then opens the OS share sheet — the user picks
+ * email / WhatsApp / Drive / etc. and sends the diagnostic bundle to support.
+ * Self-contained so the result screen only needs to render it with the scan
+ * data + captured images.
+ */
+const DiagnosticReportButton: React.FC<DiagnosticReportButtonProps> = ({
+  scan,
+  sessionId,
+  images,
+}) => {
+  const { t } = useTranslation();
+  const [sending, setSending] = useState(false);
+
+  // `react-native-share` is optional — hide the button entirely when the host
+  // app hasn't installed it, so apps that don't want diagnostics see no UI.
+  if (!isDiagnosticSharingAvailable()) {
+    return null;
+  }
+
+  const onPress = () => {
+    if (sending) return;
+    // Brief notice — the share draft is the actual review/consent step.
+    Alert.alert(
+      t('diagnosticReport.noticeTitle'),
+      t('diagnosticReport.noticeBody'),
+      [
+        { text: t('diagnosticReport.cancel'), style: 'cancel' },
+        {
+          text: t('diagnosticReport.continue'),
+          onPress: async () => {
+            setSending(true);
+            try {
+              await sendDiagnosticReport({
+                scan,
+                sdkVersion: SDK_VERSION,
+                sessionId,
+                images,
+              });
+            } finally {
+              setSending(false);
+            }
+          },
+        },
+      ]
+    );
+  };
+
+  return (
+    <StyledButton mode="outlined" onPress={onPress} disabled={sending}>
+      {t('diagnosticReport.button')}
+    </StyledButton>
+  );
+};
+
+export default DiagnosticReportButton;