@trustchex/react-native-sdk 1.493.0 → 1.493.2

package/lib/module/Shared/Components/DiagnosticReportButton.js

@@ -1,19 +1,20 @@
 "use strict";
 
-import React, { useState } from 'react';
-import { Alert } from 'react-native';
+import React, { useRef, useState } from 'react';
+import { ActivityIndicator, Alert, Modal, StyleSheet, Text, TouchableOpacity, View } from 'react-native';
 import { useTranslation } from 'react-i18next';
 import StyledButton from "./StyledButton.js";
 import { sendDiagnosticReport } from "../Libs/sendDiagnosticReport.js";
 import { SDK_VERSION } from "../../version.js";
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 /**
  * "Report a scanning issue" button for the result screen.
  *
- * Shows a brief notice describing what will be shared (acting as the user's
- * consent step), then uploads the diagnostic bundle (technical signals +
- * scanned data + captured images) to the backend, encrypted in transit and at
- * rest. Operators view and download the reports from the dashboard.
+ * Uploads the diagnostic bundle to the backend (proof-of-work authenticated,
+ * encrypted in transit + at rest). The PoW solve is the only slow step, so while
+ * sending we show a NON-DISMISSIBLE modal overlay with progress — the user can't
+ * dismiss it accidentally (tap-outside / Android-back do nothing), but can
+ * explicitly Cancel, which aborts the solve. A thank-you shows on success.
  *
  * Hidden when there's no session/baseUrl to upload to (e.g. before init).
  */
@@ -27,9 +28,36 @@ const DiagnosticReportButton = ({
     t
   } = useTranslation();
   const [sending, setSending] = useState(false);
+  const [progress, setProgress] = useState(0);
+  // Ref so the running solve sees cancellation immediately (no stale closure).
+  const cancelledRef = useRef(false);
   if (!baseUrl || !sessionId) {
     return null;
   }
+  const doSend = async () => {
+    cancelledRef.current = false;
+    setProgress(0);
+    setSending(true);
+    try {
+      const {
+        uploaded,
+        cancelled
+      } = await sendDiagnosticReport({
+        baseUrl,
+        sessionId,
+        scan,
+        sdkVersion: SDK_VERSION,
+        images,
+        onPowProgress: setProgress,
+        shouldCancel: () => cancelledRef.current
+      });
+      setSending(false);
+      if (cancelled) return; // user cancelled — no alert
+      Alert.alert(uploaded ? t('diagnosticReport.sentTitle') : t('diagnosticReport.failedTitle'), uploaded ? t('diagnosticReport.sentBody') : t('diagnosticReport.failedBody'));
+    } catch {
+      setSending(false);
+    }
+  };
   const onPress = () => {
     if (sending) return;
     Alert.alert(t('diagnosticReport.noticeTitle'), t('diagnosticReport.noticeBody'), [{
@@ -37,30 +65,91 @@ const DiagnosticReportButton = ({
       style: 'cancel'
     }, {
       text: t('diagnosticReport.continue'),
-      onPress: async () => {
-        setSending(true);
-        try {
-          const {
-            uploaded
-          } = await sendDiagnosticReport({
-            baseUrl,
-            sessionId,
-            scan,
-            sdkVersion: SDK_VERSION,
-            images
-          });
-          Alert.alert(uploaded ? t('diagnosticReport.sentTitle') : t('diagnosticReport.failedTitle'), uploaded ? t('diagnosticReport.sentBody') : t('diagnosticReport.failedBody'));
-        } finally {
-          setSending(false);
-        }
-      }
+      onPress: doSend
     }]);
   };
-  return /*#__PURE__*/_jsx(StyledButton, {
-    mode: "outlined",
-    onPress: onPress,
-    disabled: sending,
-    children: t('diagnosticReport.button')
+  const pct = Math.round(progress * 100);
+  return /*#__PURE__*/_jsxs(_Fragment, {
+    children: [/*#__PURE__*/_jsx(StyledButton, {
+      mode: "outlined",
+      onPress: onPress,
+      children: t('diagnosticReport.button')
+    }), /*#__PURE__*/_jsx(Modal, {
+      visible: sending,
+      transparent: true,
+      animationType: "fade"
+      // Block accidental dismissal: Android hardware-back does nothing while
+      // sending. There is no tap-outside-to-close (we render our own backdrop).
+      ,
+      onRequestClose: () => {},
+      children: /*#__PURE__*/_jsx(View, {
+        style: styles.backdrop,
+        children: /*#__PURE__*/_jsxs(View, {
+          style: styles.card,
+          children: [/*#__PURE__*/_jsx(ActivityIndicator, {
+            size: "large"
+          }), /*#__PURE__*/_jsx(Text, {
+            style: styles.title,
+            children: t('diagnosticReport.sending')
+          }), /*#__PURE__*/_jsx(Text, {
+            style: styles.progress,
+            children: pct > 0 ? t('diagnosticReport.sendingProgress', {
+              pct
+            }) : t('diagnosticReport.sendingPreparing')
+          }), /*#__PURE__*/_jsx(TouchableOpacity, {
+            accessibilityRole: "button",
+            style: styles.cancelBtn,
+            onPress: () => {
+              cancelledRef.current = true;
+            },
+            children: /*#__PURE__*/_jsx(Text, {
+              style: styles.cancelText,
+              children: t('diagnosticReport.cancel')
+            })
+          })]
+        })
+      })
+    })]
   });
 };
+const styles = StyleSheet.create({
+  backdrop: {
+    flex: 1,
+    backgroundColor: 'rgba(0,0,0,0.45)',
+    alignItems: 'center',
+    justifyContent: 'center',
+    padding: 24
+  },
+  card: {
+    width: '100%',
+    maxWidth: 320,
+    backgroundColor: 'white',
+    borderRadius: 16,
+    paddingVertical: 24,
+    paddingHorizontal: 20,
+    alignItems: 'center',
+    gap: 12
+  },
+  title: {
+    fontSize: 16,
+    fontWeight: '600',
+    color: '#111827',
+    textAlign: 'center'
+  },
+  progress: {
+    fontSize: 14,
+    color: '#6B7280',
+    textAlign: 'center'
+  },
+  cancelBtn: {
+    marginTop: 8,
+    paddingVertical: 10,
+    paddingHorizontal: 24
+  },
+  cancelText: {
+    fontSize: 15,
+    fontWeight: '600',
+    color: '#DC2626'
+  }
+});
 export default DiagnosticReportButton;

package/lib/module/Shared/Libs/diagnosticPow.js

@@ -29,9 +29,11 @@ const leadingZeroBits = bytes => {
 };
 
 /**
- * Solve the PoW for a challenge. Returns the solution nonce as a string.
- * Bounded by `maxIterations` so a pathological difficulty can't hang the app;
- * returns null if unsolved within the bound.
+ * Solve the PoW for a challenge (synchronous). Returns the solution nonce as a
+ * string. Bounded by `maxIterations` so a pathological difficulty can't hang the
+ * app; returns null if unsolved within the bound.
+ *
+ * Prefer `solvePowAsync` on the UI thread — this blocks until solved.
  */
 export const solvePow = (challenge, difficulty, maxIterations = 8_000_000) => {
   for (let i = 0; i < maxIterations; i++) {
@@ -42,4 +44,55 @@ export const solvePow = (challenge, difficulty, maxIterations = 8_000_000) => {
     }
   }
   return null;
+};
+
+/** Thrown by solvePowAsync / sendDiagnosticReport when the user cancels. */
+export class PowCancelledError extends Error {
+  constructor() {
+    super('Proof-of-work cancelled');
+    this.name = 'PowCancelledError';
+  }
+}
+/**
+ * Async, UI-friendly PoW solver. Hashes in small chunks and yields to the event
+ * loop between chunks so the JS thread (and the UI) stays responsive instead of
+ * freezing during the solve. Reports coarse progress (0..1, best-effort against
+ * the expected work for the difficulty) via `onProgress`, and aborts (throwing
+ * PowCancelledError) when `shouldCancel` returns true.
+ *
+ * Returns the solution nonce, or null if unsolved within `maxIterations`.
+ */
+export const solvePowAsync = async (challenge, difficulty, options = {}) => {
+  const {
+    onProgress,
+    shouldCancel,
+    maxIterations = 8_000_000,
+    // Hash a large chunk between yields: the per-yield setTimeout(0) round-trip
+    // on Hermes costs ~ms, so yielding every 2k hashes dominated wall-clock.
+    // 25k keeps the UI responsive + cancel snappy (a chunk is a few tens of ms)
+    // while spending almost all time hashing, not bouncing through the event loop.
+    chunkSize = 25_000
+  } = options;
+  // Expected hashes ≈ 2^difficulty; used only to render a smooth-ish bar.
+  const expected = Math.max(1, Math.pow(2, difficulty));
+  // Encode the fixed "challenge." prefix once; per iteration we only encode the
+  // small varying nonce and concat, instead of re-UTF-8-encoding the whole
+  // string (the challenge is 32+ chars) on every hash.
+  const prefix = Buffer.from(`${challenge}.`, 'utf-8');
+  for (let i = 0; i < maxIterations; i++) {
+    const digest = sha256(Buffer.concat([prefix, Buffer.from(i.toString(), 'utf-8')]));
+    if (leadingZeroBits(digest) >= difficulty) {
+      onProgress?.(1);
+      return i.toString();
+    }
+    if (i % chunkSize === chunkSize - 1) {
+      if (shouldCancel?.()) {
+        throw new PowCancelledError();
+      }
+      onProgress?.(Math.min(0.99, i / expected));
+      // Yield so React can paint the progress and the UI stays responsive.
+      await new Promise(resolve => setTimeout(resolve, 0));
+    }
+  }
+  return null;
 };

package/lib/module/Shared/Libs/sendDiagnosticReport.js

@@ -22,7 +22,7 @@
 import { diagnostics } from "./diagnostics.js";
 import { gatherDeviceDetails } from "./native-device-info.utils.js";
 import { buildDiagnosticReport } from "./diagnosticReport.js";
-import { solvePow } from "./diagnosticPow.js";
+import { solvePowAsync, PowCancelledError } from "./diagnosticPow.js";
 import { logError } from "./debug.utils.js";
 const mimeToType = mime => mime === 'png' ? 'image/png' : 'image/jpeg';
 
@@ -37,7 +37,9 @@ export const sendDiagnosticReport = async params => {
     sessionId,
     scan,
     sdkVersion,
-    images = []
+    images = [],
+    onPowProgress,
+    shouldCancel
   } = params;
   if (!baseUrl) {
     return {
@@ -95,12 +97,21 @@ export const sendDiagnosticReport = async params => {
       };
     }
     const challenge = await challengeRes.json();
-    const solution = solvePow(challenge.challenge, challenge.difficulty);
+    const solution = await solvePowAsync(challenge.challenge, challenge.difficulty, {
+      onProgress: onPowProgress,
+      shouldCancel
+    });
     if (!solution) {
       return {
         uploaded: false
       };
     }
+    if (shouldCancel?.()) {
+      return {
+        uploaded: false,
+        cancelled: true
+      };
+    }
     const response = await fetch(`${baseUrl}/api/app/mobile/diagnostics`, {
       method: 'POST',
       headers: {
@@ -114,6 +125,12 @@ export const sendDiagnosticReport = async params => {
       uploaded: response.ok
     };
   } catch (e) {
+    if (e instanceof PowCancelledError) {
+      return {
+        uploaded: false,
+        cancelled: true
+      };
+    }
     logError('Diagnostics', 'Failed to upload diagnostic report', e instanceof Error ? e.message : String(e));
     return {
       uploaded: false

package/lib/module/Translation/Resources/en.js

@@ -50,8 +50,11 @@ export default {
   'diagnosticReport.noticeBody': 'This sends your scan data, document images and technical details to support so they can help resolve a scanning issue.',
   'diagnosticReport.continue': 'Continue',
   'diagnosticReport.cancel': 'Cancel',
-  'diagnosticReport.sentTitle': 'Report sent',
-  'diagnosticReport.sentBody': 'Your diagnostic report was sent to support. Thank you.',
+  'diagnosticReport.sending': 'Sending diagnostic report',
+  'diagnosticReport.sendingPreparing': 'Preparing…',
+  'diagnosticReport.sendingProgress': 'Preparing… {{pct}}%',
+  'diagnosticReport.sentTitle': 'Thank you!',
+  'diagnosticReport.sentBody': 'Thanks for sending your diagnostic data — it helps us improve scanning. Our team will look into the issue.',
   'diagnosticReport.failedTitle': "Couldn't send the report",
   'diagnosticReport.failedBody': 'Please try again later.',
   'livenessDetectionScreen.guideHeader': 'Face Verification',

package/lib/module/Translation/Resources/tr.js

@@ -50,8 +50,11 @@ export default {
   'diagnosticReport.noticeBody': 'Bu işlem; tarama verilerinizi, belge görüntülerinizi ve teknik ayrıntıları destek ekibine gönderir; böylece tarama sorununu çözebilirler.',
   'diagnosticReport.continue': 'Devam et',
   'diagnosticReport.cancel': 'İptal',
-  'diagnosticReport.sentTitle': 'Rapor gönderildi',
-  'diagnosticReport.sentBody': 'Tanılama raporunuz destek ekibine gönderildi. Teşekkürler.',
+  'diagnosticReport.sending': 'Tanılama raporu gönderiliyor',
+  'diagnosticReport.sendingPreparing': 'Hazırlanıyor…',
+  'diagnosticReport.sendingProgress': 'Hazırlanıyor… %{{pct}}',
+  'diagnosticReport.sentTitle': 'Teşekkürler!',
+  'diagnosticReport.sentBody': 'Tanılama verilerinizi gönderdiğiniz için teşekkürler — taramayı iyileştirmemize yardımcı oluyor. Ekibimiz sorunu inceleyecek.',
   'diagnosticReport.failedTitle': 'Rapor gönderilemedi',
   'diagnosticReport.failedBody': 'Lütfen daha sonra tekrar deneyin.',
   'livenessDetectionScreen.guideHeader': 'Yüz Doğrulaması',

package/lib/module/version.js

@@ -2,4 +2,4 @@
 
 // This file is auto-generated. Do not edit manually.
 // Version is synced from package.json during build.
-export const SDK_VERSION = '1.493.0';
+export const SDK_VERSION = '1.493.2';

package/lib/typescript/src/Shared/Components/DiagnosticReportButton.d.ts

@@ -11,10 +11,11 @@ export interface DiagnosticReportButtonProps {
 /**
  * "Report a scanning issue" button for the result screen.
  *
- * Shows a brief notice describing what will be shared (acting as the user's
- * consent step), then uploads the diagnostic bundle (technical signals +
- * scanned data + captured images) to the backend, encrypted in transit and at
- * rest. Operators view and download the reports from the dashboard.
+ * Uploads the diagnostic bundle to the backend (proof-of-work authenticated,
+ * encrypted in transit + at rest). The PoW solve is the only slow step, so while
+ * sending we show a NON-DISMISSIBLE modal overlay with progress — the user can't
+ * dismiss it accidentally (tap-outside / Android-back do nothing), but can
+ * explicitly Cancel, which aborts the solve. A thank-you shows on success.
  *
  * Hidden when there's no session/baseUrl to upload to (e.g. before init).
  */

package/lib/typescript/src/Shared/Components/DiagnosticReportButton.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DiagnosticReportButton.d.ts","sourceRoot":"","sources":["../../../../../src/Shared/Components/DiagnosticReportButton.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAmB,MAAM,OAAO,CAAC;AAIxC,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAGlE,MAAM,WAAW,2BAA2B;IAC1C,qDAAqD;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,iBAAiB,CAAC;IACxB,MAAM,CAAC,EAAE,eAAe,EAAE,CAAC;CAC5B;AAED;;;;;;;;;GASG;AACH,QAAA,MAAM,sBAAsB,EAAE,KAAK,CAAC,EAAE,CAAC,2BAA2B,CAsDjE,CAAC;AAEF,eAAe,sBAAsB,CAAC"}
+{"version":3,"file":"DiagnosticReportButton.d.ts","sourceRoot":"","sources":["../../../../../src/Shared/Components/DiagnosticReportButton.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA2B,MAAM,OAAO,CAAC;AAYhD,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAGlE,MAAM,WAAW,2BAA2B;IAC1C,qDAAqD;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,iBAAiB,CAAC;IACxB,MAAM,CAAC,EAAE,eAAe,EAAE,CAAC;CAC5B;AAED;;;;;;;;;;GAUG;AACH,QAAA,MAAM,sBAAsB,EAAE,KAAK,CAAC,EAAE,CAAC,2BAA2B,CAkGjE,CAAC;AA2CF,eAAe,sBAAsB,CAAC"}

package/lib/typescript/src/Shared/Libs/diagnosticPow.d.ts

@@ -14,9 +14,32 @@ export interface PowChallenge {
     expiresAt: number;
 }
 /**
- * Solve the PoW for a challenge. Returns the solution nonce as a string.
- * Bounded by `maxIterations` so a pathological difficulty can't hang the app;
- * returns null if unsolved within the bound.
+ * Solve the PoW for a challenge (synchronous). Returns the solution nonce as a
+ * string. Bounded by `maxIterations` so a pathological difficulty can't hang the
+ * app; returns null if unsolved within the bound.
+ *
+ * Prefer `solvePowAsync` on the UI thread — this blocks until solved.
  */
 export declare const solvePow: (challenge: string, difficulty: number, maxIterations?: number) => string | null;
+/** Thrown by solvePowAsync / sendDiagnosticReport when the user cancels. */
+export declare class PowCancelledError extends Error {
+    constructor();
+}
+export interface SolvePowAsyncOptions {
+    onProgress?: (fraction: number) => void;
+    /** Polled between chunks; return true to abort. Throws PowCancelledError. */
+    shouldCancel?: () => boolean;
+    maxIterations?: number;
+    chunkSize?: number;
+}
+/**
+ * Async, UI-friendly PoW solver. Hashes in small chunks and yields to the event
+ * loop between chunks so the JS thread (and the UI) stays responsive instead of
+ * freezing during the solve. Reports coarse progress (0..1, best-effort against
+ * the expected work for the difficulty) via `onProgress`, and aborts (throwing
+ * PowCancelledError) when `shouldCancel` returns true.
+ *
+ * Returns the solution nonce, or null if unsolved within `maxIterations`.
+ */
+export declare const solvePowAsync: (challenge: string, difficulty: number, options?: SolvePowAsyncOptions) => Promise<string | null>;
 //# sourceMappingURL=diagnosticPow.d.ts.map

package/lib/typescript/src/Shared/Libs/diagnosticPow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"diagnosticPow.d.ts","sourceRoot":"","sources":["../../../../../src/Shared/Libs/diagnosticPow.ts"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AAEH,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB;AAiBD;;;;GAIG;AACH,eAAO,MAAM,QAAQ,GACnB,WAAW,MAAM,EACjB,YAAY,MAAM,EAClB,sBAAyB,KACxB,MAAM,GAAG,IASX,CAAC"}
+{"version":3,"file":"diagnosticPow.d.ts","sourceRoot":"","sources":["../../../../../src/Shared/Libs/diagnosticPow.ts"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AAEH,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB;AAiBD;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GACnB,WAAW,MAAM,EACjB,YAAY,MAAM,EAClB,sBAAyB,KACxB,MAAM,GAAG,IASX,CAAC;AAEF,4EAA4E;AAC5E,qBAAa,iBAAkB,SAAQ,KAAK;;CAK3C;AAED,MAAM,WAAW,oBAAoB;IACnC,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,6EAA6E;IAC7E,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,GACxB,WAAW,MAAM,EACjB,YAAY,MAAM,EAClB,UAAS,oBAAyB,KACjC,OAAO,CAAC,MAAM,GAAG,IAAI,CAmCvB,CAAC"}

package/lib/typescript/src/Shared/Libs/sendDiagnosticReport.d.ts

@@ -14,10 +14,19 @@ export interface SendDiagnosticParams {
     sdkVersion: string;
     /** base64 images to attach (MRZ side / front / face / NFC chip face). */
     images?: DiagnosticImage[];
+    /**
+     * Progress callback for the proof-of-work step (0..1). The PoW solve is the
+     * only slow part; the UI uses this to show a progress bar instead of freezing.
+     */
+    onPowProgress?: (fraction: number) => void;
+    /** Polled during the solve; return true to cancel. */
+    shouldCancel?: () => boolean;
 }
 export interface SendResult {
     /** True when the report was uploaded and stored. */
     uploaded: boolean;
+    /** True when the user cancelled before completion. */
+    cancelled?: boolean;
 }
 /**
  * Build the report and upload it (over HTTPS) to the demo-diagnostics endpoint.

package/lib/typescript/src/Shared/Libs/sendDiagnosticReport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sendDiagnosticReport.d.ts","sourceRoot":"","sources":["../../../../../src/Shared/Libs/sendDiagnosticReport.ts"],"names":[],"mappings":"AAqBA,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,oBAAoB,CAAC;AAI5B,MAAM,WAAW,eAAe;IAC9B,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,KAAK,GAAG,KAAK,CAAC;CACrB;AAED,MAAM,WAAW,oBAAoB;IACnC,kEAAkE;IAClE,OAAO,EAAE,MAAM,CAAC;IAChB,wEAAwE;IACxE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,iBAAiB,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,yEAAyE;IACzE,MAAM,CAAC,EAAE,eAAe,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,UAAU;IACzB,oDAAoD;IACpD,QAAQ,EAAE,OAAO,CAAC;CACnB;AAKD;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAC/B,QAAQ,oBAAoB,KAC3B,OAAO,CAAC,UAAU,CAsFpB,CAAC"}
+{"version":3,"file":"sendDiagnosticReport.d.ts","sourceRoot":"","sources":["../../../../../src/Shared/Libs/sendDiagnosticReport.ts"],"names":[],"mappings":"AAqBA,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,oBAAoB,CAAC;AAQ5B,MAAM,WAAW,eAAe;IAC9B,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,KAAK,GAAG,KAAK,CAAC;CACrB;AAED,MAAM,WAAW,oBAAoB;IACnC,kEAAkE;IAClE,OAAO,EAAE,MAAM,CAAC;IAChB,wEAAwE;IACxE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,iBAAiB,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,yEAAyE;IACzE,MAAM,CAAC,EAAE,eAAe,EAAE,CAAC;IAC3B;;;OAGG;IACH,aAAa,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3C,sDAAsD;IACtD,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC;CAC9B;AAED,MAAM,WAAW,UAAU;IACzB,oDAAoD;IACpD,QAAQ,EAAE,OAAO,CAAC;IAClB,sDAAsD;IACtD,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAKD;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAC/B,QAAQ,oBAAoB,KAC3B,OAAO,CAAC,UAAU,CA2GpB,CAAC"}

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

@@ -48,6 +48,9 @@ declare const _default: {
     'diagnosticReport.noticeBody': string;
     'diagnosticReport.continue': string;
     'diagnosticReport.cancel': string;
+    'diagnosticReport.sending': string;
+    'diagnosticReport.sendingPreparing': string;
+    'diagnosticReport.sendingProgress': string;
     'diagnosticReport.sentTitle': string;
     'diagnosticReport.sentBody': string;
     'diagnosticReport.failedTitle': 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,wBAgRE"}
+{"version":3,"file":"en.d.ts","sourceRoot":"","sources":["../../../../../src/Translation/Resources/en.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBAoRE"}

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

@@ -48,6 +48,9 @@ declare const _default: {
     'diagnosticReport.noticeBody': string;
     'diagnosticReport.continue': string;
     'diagnosticReport.cancel': string;
+    'diagnosticReport.sending': string;
+    'diagnosticReport.sendingPreparing': string;
+    'diagnosticReport.sendingProgress': string;
     'diagnosticReport.sentTitle': string;
     'diagnosticReport.sentBody': string;
     'diagnosticReport.failedTitle': 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,wBAmRE"}
+{"version":3,"file":"tr.d.ts","sourceRoot":"","sources":["../../../../../src/Translation/Resources/tr.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBAuRE"}

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trustchex/react-native-sdk",
-  "version": "1.493.0",
+  "version": "1.493.2",
   "description": "Trustchex mobile app react native SDK for android or ios devices",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/Shared/Components/DiagnosticReportButton.tsx

@@ -1,5 +1,13 @@
-import React, { useState } from 'react';
-import { Alert } from 'react-native';
+import React, { useRef, useState } from 'react';
+import {
+  ActivityIndicator,
+  Alert,
+  Modal,
+  StyleSheet,
+  Text,
+  TouchableOpacity,
+  View,
+} from 'react-native';
 import { useTranslation } from 'react-i18next';
 import StyledButton from './StyledButton';
 import {
@@ -20,10 +28,11 @@ export interface DiagnosticReportButtonProps {
 /**
  * "Report a scanning issue" button for the result screen.
  *
- * Shows a brief notice describing what will be shared (acting as the user's
- * consent step), then uploads the diagnostic bundle (technical signals +
- * scanned data + captured images) to the backend, encrypted in transit and at
- * rest. Operators view and download the reports from the dashboard.
+ * Uploads the diagnostic bundle to the backend (proof-of-work authenticated,
+ * encrypted in transit + at rest). The PoW solve is the only slow step, so while
+ * sending we show a NON-DISMISSIBLE modal overlay with progress — the user can't
+ * dismiss it accidentally (tap-outside / Android-back do nothing), but can
+ * explicitly Cancel, which aborts the solve. A thank-you shows on success.
  *
  * Hidden when there's no session/baseUrl to upload to (e.g. before init).
  */
@@ -35,11 +44,43 @@ const DiagnosticReportButton: React.FC<DiagnosticReportButtonProps> = ({
 }) => {
   const { t } = useTranslation();
   const [sending, setSending] = useState(false);
+  const [progress, setProgress] = useState(0);
+  // Ref so the running solve sees cancellation immediately (no stale closure).
+  const cancelledRef = useRef(false);
 
   if (!baseUrl || !sessionId) {
     return null;
   }
 
+  const doSend = async () => {
+    cancelledRef.current = false;
+    setProgress(0);
+    setSending(true);
+    try {
+      const { uploaded, cancelled } = await sendDiagnosticReport({
+        baseUrl,
+        sessionId,
+        scan,
+        sdkVersion: SDK_VERSION,
+        images,
+        onPowProgress: setProgress,
+        shouldCancel: () => cancelledRef.current,
+      });
+      setSending(false);
+      if (cancelled) return; // user cancelled — no alert
+      Alert.alert(
+        uploaded
+          ? t('diagnosticReport.sentTitle')
+          : t('diagnosticReport.failedTitle'),
+        uploaded
+          ? t('diagnosticReport.sentBody')
+          : t('diagnosticReport.failedBody')
+      );
+    } catch {
+      setSending(false);
+    }
+  };
+
   const onPress = () => {
     if (sending) return;
     Alert.alert(
@@ -47,40 +88,93 @@ const DiagnosticReportButton: React.FC<DiagnosticReportButtonProps> = ({
       t('diagnosticReport.noticeBody'),
       [
         { text: t('diagnosticReport.cancel'), style: 'cancel' },
-        {
-          text: t('diagnosticReport.continue'),
-          onPress: async () => {
-            setSending(true);
-            try {
-              const { uploaded } = await sendDiagnosticReport({
-                baseUrl,
-                sessionId,
-                scan,
-                sdkVersion: SDK_VERSION,
-                images,
-              });
-              Alert.alert(
-                uploaded
-                  ? t('diagnosticReport.sentTitle')
-                  : t('diagnosticReport.failedTitle'),
-                uploaded
-                  ? t('diagnosticReport.sentBody')
-                  : t('diagnosticReport.failedBody')
-              );
-            } finally {
-              setSending(false);
-            }
-          },
-        },
+        { text: t('diagnosticReport.continue'), onPress: doSend },
       ]
     );
   };
 
+  const pct = Math.round(progress * 100);
+
   return (
-    <StyledButton mode="outlined" onPress={onPress} disabled={sending}>
-      {t('diagnosticReport.button')}
-    </StyledButton>
+    <>
+      <StyledButton mode="outlined" onPress={onPress}>
+        {t('diagnosticReport.button')}
+      </StyledButton>
+
+      <Modal
+        visible={sending}
+        transparent
+        animationType="fade"
+        // Block accidental dismissal: Android hardware-back does nothing while
+        // sending. There is no tap-outside-to-close (we render our own backdrop).
+        onRequestClose={() => {}}
+      >
+        <View style={styles.backdrop}>
+          <View style={styles.card}>
+            <ActivityIndicator size="large" />
+            <Text style={styles.title}>{t('diagnosticReport.sending')}</Text>
+            <Text style={styles.progress}>
+              {pct > 0
+                ? t('diagnosticReport.sendingProgress', { pct })
+                : t('diagnosticReport.sendingPreparing')}
+            </Text>
+            <TouchableOpacity
+              accessibilityRole="button"
+              style={styles.cancelBtn}
+              onPress={() => {
+                cancelledRef.current = true;
+              }}
+            >
+              <Text style={styles.cancelText}>
+                {t('diagnosticReport.cancel')}
+              </Text>
+            </TouchableOpacity>
+          </View>
+        </View>
+      </Modal>
+    </>
   );
 };
 
+const styles = StyleSheet.create({
+  backdrop: {
+    flex: 1,
+    backgroundColor: 'rgba(0,0,0,0.45)',
+    alignItems: 'center',
+    justifyContent: 'center',
+    padding: 24,
+  },
+  card: {
+    width: '100%',
+    maxWidth: 320,
+    backgroundColor: 'white',
+    borderRadius: 16,
+    paddingVertical: 24,
+    paddingHorizontal: 20,
+    alignItems: 'center',
+    gap: 12,
+  },
+  title: {
+    fontSize: 16,
+    fontWeight: '600',
+    color: '#111827',
+    textAlign: 'center',
+  },
+  progress: {
+    fontSize: 14,
+    color: '#6B7280',
+    textAlign: 'center',
+  },
+  cancelBtn: {
+    marginTop: 8,
+    paddingVertical: 10,
+    paddingHorizontal: 24,
+  },
+  cancelText: {
+    fontSize: 15,
+    fontWeight: '600',
+    color: '#DC2626',
+  },
+});
+
 export default DiagnosticReportButton;

package/src/Shared/Libs/diagnosticPow.ts

@@ -34,9 +34,11 @@ const leadingZeroBits = (bytes: Uint8Array): number => {
 };
 
 /**
- * Solve the PoW for a challenge. Returns the solution nonce as a string.
- * Bounded by `maxIterations` so a pathological difficulty can't hang the app;
- * returns null if unsolved within the bound.
+ * Solve the PoW for a challenge (synchronous). Returns the solution nonce as a
+ * string. Bounded by `maxIterations` so a pathological difficulty can't hang the
+ * app; returns null if unsolved within the bound.
+ *
+ * Prefer `solvePowAsync` on the UI thread — this blocks until solved.
  */
 export const solvePow = (
   challenge: string,
@@ -52,3 +54,69 @@ export const solvePow = (
   }
   return null;
 };
+
+/** Thrown by solvePowAsync / sendDiagnosticReport when the user cancels. */
+export class PowCancelledError extends Error {
+  constructor() {
+    super('Proof-of-work cancelled');
+    this.name = 'PowCancelledError';
+  }
+}
+
+export interface SolvePowAsyncOptions {
+  onProgress?: (fraction: number) => void;
+  /** Polled between chunks; return true to abort. Throws PowCancelledError. */
+  shouldCancel?: () => boolean;
+  maxIterations?: number;
+  chunkSize?: number;
+}
+
+/**
+ * Async, UI-friendly PoW solver. Hashes in small chunks and yields to the event
+ * loop between chunks so the JS thread (and the UI) stays responsive instead of
+ * freezing during the solve. Reports coarse progress (0..1, best-effort against
+ * the expected work for the difficulty) via `onProgress`, and aborts (throwing
+ * PowCancelledError) when `shouldCancel` returns true.
+ *
+ * Returns the solution nonce, or null if unsolved within `maxIterations`.
+ */
+export const solvePowAsync = async (
+  challenge: string,
+  difficulty: number,
+  options: SolvePowAsyncOptions = {}
+): Promise<string | null> => {
+  const {
+    onProgress,
+    shouldCancel,
+    maxIterations = 8_000_000,
+    // Hash a large chunk between yields: the per-yield setTimeout(0) round-trip
+    // on Hermes costs ~ms, so yielding every 2k hashes dominated wall-clock.
+    // 25k keeps the UI responsive + cancel snappy (a chunk is a few tens of ms)
+    // while spending almost all time hashing, not bouncing through the event loop.
+    chunkSize = 25_000,
+  } = options;
+  // Expected hashes ≈ 2^difficulty; used only to render a smooth-ish bar.
+  const expected = Math.max(1, Math.pow(2, difficulty));
+  // Encode the fixed "challenge." prefix once; per iteration we only encode the
+  // small varying nonce and concat, instead of re-UTF-8-encoding the whole
+  // string (the challenge is 32+ chars) on every hash.
+  const prefix = Buffer.from(`${challenge}.`, 'utf-8');
+  for (let i = 0; i < maxIterations; i++) {
+    const digest = sha256(
+      Buffer.concat([prefix, Buffer.from(i.toString(), 'utf-8')])
+    );
+    if (leadingZeroBits(digest) >= difficulty) {
+      onProgress?.(1);
+      return i.toString();
+    }
+    if (i % chunkSize === chunkSize - 1) {
+      if (shouldCancel?.()) {
+        throw new PowCancelledError();
+      }
+      onProgress?.(Math.min(0.99, i / expected));
+      // Yield so React can paint the progress and the UI stays responsive.
+      await new Promise<void>((resolve) => setTimeout(resolve, 0));
+    }
+  }
+  return null;
+};

package/src/Shared/Libs/sendDiagnosticReport.ts

@@ -23,7 +23,11 @@ import {
   buildDiagnosticReport,
   type ScanDataForReport,
 } from './diagnosticReport';
-import { solvePow, type PowChallenge } from './diagnosticPow';
+import {
+  solvePowAsync,
+  PowCancelledError,
+  type PowChallenge,
+} from './diagnosticPow';
 import { logError } from './debug.utils';
 
 export interface DiagnosticImage {
@@ -42,11 +46,20 @@ export interface SendDiagnosticParams {
   sdkVersion: string;
   /** base64 images to attach (MRZ side / front / face / NFC chip face). */
   images?: DiagnosticImage[];
+  /**
+   * Progress callback for the proof-of-work step (0..1). The PoW solve is the
+   * only slow part; the UI uses this to show a progress bar instead of freezing.
+   */
+  onPowProgress?: (fraction: number) => void;
+  /** Polled during the solve; return true to cancel. */
+  shouldCancel?: () => boolean;
 }
 
 export interface SendResult {
   /** True when the report was uploaded and stored. */
   uploaded: boolean;
+  /** True when the user cancelled before completion. */
+  cancelled?: boolean;
 }
 
 const mimeToType = (mime: 'jpg' | 'png'): string =>
@@ -60,7 +73,15 @@ const mimeToType = (mime: 'jpg' | 'png'): string =>
 export const sendDiagnosticReport = async (
   params: SendDiagnosticParams
 ): Promise<SendResult> => {
-  const { baseUrl, sessionId, scan, sdkVersion, images = [] } = params;
+  const {
+    baseUrl,
+    sessionId,
+    scan,
+    sdkVersion,
+    images = [],
+    onPowProgress,
+    shouldCancel,
+  } = params;
   if (!baseUrl) {
     return { uploaded: false };
   }
@@ -121,10 +142,20 @@ export const sendDiagnosticReport = async (
       return { uploaded: false };
     }
     const challenge = (await challengeRes.json()) as PowChallenge;
-    const solution = solvePow(challenge.challenge, challenge.difficulty);
+    const solution = await solvePowAsync(
+      challenge.challenge,
+      challenge.difficulty,
+      {
+        onProgress: onPowProgress,
+        shouldCancel,
+      }
+    );
     if (!solution) {
       return { uploaded: false };
     }
+    if (shouldCancel?.()) {
+      return { uploaded: false, cancelled: true };
+    }
 
     const response = await fetch(`${baseUrl}/api/app/mobile/diagnostics`, {
       method: 'POST',
@@ -138,6 +169,9 @@ export const sendDiagnosticReport = async (
 
     return { uploaded: response.ok };
   } catch (e) {
+    if (e instanceof PowCancelledError) {
+      return { uploaded: false, cancelled: true };
+    }
     logError(
       'Diagnostics',
       'Failed to upload diagnostic report',

package/src/Translation/Resources/en.ts

@@ -59,8 +59,12 @@ export default {
     'This sends your scan data, document images and technical details to support so they can help resolve a scanning issue.',
   'diagnosticReport.continue': 'Continue',
   'diagnosticReport.cancel': 'Cancel',
-  'diagnosticReport.sentTitle': 'Report sent',
-  'diagnosticReport.sentBody': 'Your diagnostic report was sent to support. Thank you.',
+  'diagnosticReport.sending': 'Sending diagnostic report',
+  'diagnosticReport.sendingPreparing': 'Preparing…',
+  'diagnosticReport.sendingProgress': 'Preparing… {{pct}}%',
+  'diagnosticReport.sentTitle': 'Thank you!',
+  'diagnosticReport.sentBody':
+    'Thanks for sending your diagnostic data — it helps us improve scanning. Our team will look into the issue.',
   'diagnosticReport.failedTitle': "Couldn't send the report",
   'diagnosticReport.failedBody': 'Please try again later.',
   'livenessDetectionScreen.guideHeader': 'Face Verification',

package/src/Translation/Resources/tr.ts

@@ -59,8 +59,12 @@ export default {
     'Bu işlem; tarama verilerinizi, belge görüntülerinizi ve teknik ayrıntıları destek ekibine gönderir; böylece tarama sorununu çözebilirler.',
   'diagnosticReport.continue': 'Devam et',
   'diagnosticReport.cancel': 'İptal',
-  'diagnosticReport.sentTitle': 'Rapor gönderildi',
-  'diagnosticReport.sentBody': 'Tanılama raporunuz destek ekibine gönderildi. Teşekkürler.',
+  'diagnosticReport.sending': 'Tanılama raporu gönderiliyor',
+  'diagnosticReport.sendingPreparing': 'Hazırlanıyor…',
+  'diagnosticReport.sendingProgress': 'Hazırlanıyor… %{{pct}}',
+  'diagnosticReport.sentTitle': 'Teşekkürler!',
+  'diagnosticReport.sentBody':
+    'Tanılama verilerinizi gönderdiğiniz için teşekkürler — taramayı iyileştirmemize yardımcı oluyor. Ekibimiz sorunu inceleyecek.',
   'diagnosticReport.failedTitle': 'Rapor gönderilemedi',
   'diagnosticReport.failedBody': 'Lütfen daha sonra tekrar deneyin.',
   'livenessDetectionScreen.guideHeader': 'Yüz Doğrulaması',

package/src/version.ts

@@ -1,3 +1,3 @@
 // This file is auto-generated. Do not edit manually.
 // Version is synced from package.json during build.
-export const SDK_VERSION = '1.493.0';
+export const SDK_VERSION = '1.493.2';