@trustchex/react-native-sdk 1.475.1 → 1.478.7

package/lib/typescript/src/Shared/Services/VideoSessionService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VideoSessionService.d.ts","sourceRoot":"","sources":["../../../../../src/Shared/Services/VideoSessionService.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,SAAS,GAAG,YAAY,GAAG,QAAQ,GAAG,WAAW,GAAG,QAAQ,CAAC;IACxE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,gBAAgB,CAAC,CAAS;gBAEtB,OAAO,EAAE,MAAM,EAAE,gBAAgB,CAAC,EAAE,MAAM;IAKtD;;OAEG;IACU,iBAAiB,IAAI,OAAO,CAAC,gBAAgB,CAAC;IA+B3D;;OAEG;IACU,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA0BtE;;OAEG;IACU,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAa5D;;OAEG;IACU,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAc3D;;OAEG;IACI,uBAAuB,CAC5B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,EACpC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAC9B,MAAM,IAAI;CAqEd"}
+{"version":3,"file":"VideoSessionService.d.ts","sourceRoot":"","sources":["../../../../../src/Shared/Services/VideoSessionService.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,SAAS,GAAG,YAAY,GAAG,QAAQ,GAAG,WAAW,GAAG,QAAQ,CAAC;IACxE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,gBAAgB,CAAC,CAAS;gBAEtB,OAAO,EAAE,MAAM,EAAE,gBAAgB,CAAC,EAAE,MAAM;IAKtD;;OAEG;IACU,iBAAiB,IAAI,OAAO,CAAC,gBAAgB,CAAC;IA+B3D;;OAEG;IACU,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA0BtE;;OAEG;IACU,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAa5D;;OAEG;IACU,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAc3D;;OAEG;IACI,uBAAuB,CAC5B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,EACpC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAC9B,MAAM,IAAI;CAgFd"}

package/lib/typescript/src/Translation/Resources/en.d.ts

@@ -110,6 +110,7 @@ declare const _default: {
     'identityDocumentCamera.alignIDFrontSide': string;
     'identityDocumentCamera.alignIDBackSide': string;
     'identityDocumentCamera.scanCompleted': string;
+    'identityDocumentCamera.mrzDetected': string;
     'identityDocumentCamera.searchingDocument': string;
     'identityDocumentCamera.faceDetected': string;
     'identityDocumentCamera.readingDocument': string;

package/lib/typescript/src/Translation/Resources/en.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"en.d.ts","sourceRoot":"","sources":["../../../../../src/Translation/Resources/en.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBAyPE"}
+{"version":3,"file":"en.d.ts","sourceRoot":"","sources":["../../../../../src/Translation/Resources/en.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBA0PE"}

package/lib/typescript/src/Translation/Resources/tr.d.ts

@@ -110,6 +110,7 @@ declare const _default: {
     'identityDocumentCamera.alignIDFrontSide': string;
     'identityDocumentCamera.alignIDBackSide': string;
     'identityDocumentCamera.scanCompleted': string;
+    'identityDocumentCamera.mrzDetected': string;
     'identityDocumentCamera.searchingDocument': string;
     'identityDocumentCamera.faceDetected': string;
     'identityDocumentCamera.readingDocument': string;

package/lib/typescript/src/Translation/Resources/tr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tr.d.ts","sourceRoot":"","sources":["../../../../../src/Translation/Resources/tr.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBA4PE"}
+{"version":3,"file":"tr.d.ts","sourceRoot":"","sources":["../../../../../src/Translation/Resources/tr.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBA6PE"}

package/lib/typescript/src/version.d.ts

@@ -1,2 +1,2 @@
-export declare const SDK_VERSION = "1.475.1";
+export declare const SDK_VERSION = "1.478.7";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trustchex/react-native-sdk",
-  "version": "1.475.1",
+  "version": "1.478.7",
   "description": "Trustchex mobile app react native SDK for android or ios devices",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -61,7 +61,7 @@
     "@react-navigation/native": "7.1.18",
     "@react-navigation/native-stack": "7.3.27",
     "@react-navigation/elements": "2.6.5",
-    "lodash": "4.17.23",
+    "lodash": "4.18.0",
     "brace-expansion": "1.1.13",
     "minimatch": "3.1.4",
     "qs": "6.15.2",
@@ -70,7 +70,16 @@
     "yaml": "2.8.3",
     "fast-uri": "3.1.2",
     "flatted": "3.4.2",
-    "react-native-screens": "4.18.0"
+    "react-native-screens": "4.18.0",
+    "shell-quote": "1.8.4",
+    "handlebars": "4.7.9",
+    "node-forge": "1.4.0",
+    "@xmldom/xmldom": "0.8.13",
+    "basic-ftp": "5.3.1",
+    "tmp": "0.2.6",
+    "ws": "8.20.1",
+    "picomatch": "2.3.2",
+    "fast-xml-parser": "5.7.0"
   },
   "scripts": {
     "example": "yarn workspace @trustchex/react-native-sdk-example",
@@ -135,6 +144,7 @@
   "dependencies": {
     "@noble/ciphers": "^1.3.0",
     "@noble/curves": "^1.9.4",
+    "@noble/hashes": "^1.8.0",
     "buffer": "^6.0.3",
     "crypto-js": "^4.2.0",
     "elliptic": "^6.6.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';
@@ -285,11 +285,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 +303,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 +479,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,

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={{