@trustchex/react-native-sdk 1.475.1 → 1.481.1

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

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

package/src/Shared/Libs/sendDiagnosticReport.ts

@@ -0,0 +1,165 @@
+/**
+ * Assembles and shares the support diagnostic report.
+ *
+ * `react-native-share` is an OPTIONAL dependency: the host app opts into the
+ * diagnostic feature by installing it. When it's present we open the OS share
+ * sheet with the full report (the user picks email / WhatsApp / Drive / etc. and
+ * reviews before sending); when it's absent the feature is silently unavailable
+ * — `isDiagnosticSharingAvailable()` returns false and the result-screen button
+ * renders nothing, so apps that don't want it incur no dependency.
+ *
+ * Attached files (staged to a temp dir via react-native-fs, already an SDK dep):
+ *  - `diagnostics.json` — technical signals (device, camera, MRZ, NFC steps),
+ *  - `scan-data.json`   — the scanned identity data (PII; user reviews it),
+ *  - the captured document/face images.
+ *
+ * The readable summary rides as the share `message` so it's visible in the
+ * draft regardless of the chosen app.
+ */
+import RNFS from 'react-native-fs';
+import { diagnostics } from './diagnostics';
+import { gatherDeviceDetails } from './native-device-info.utils';
+import {
+  buildDiagnosticReport,
+  type ScanDataForReport,
+} from './diagnosticReport';
+import { logError } from './debug.utils';
+
+// `react-native-share` is OPTIONAL. Load it softly so the SDK bundles and runs
+// without it; only host apps that installed it get the diagnostic feature. A
+// static `import` would make Metro fail to resolve the module when it's absent,
+// so we use a guarded require and keep the reference typed loosely.
+type ShareModule = {
+  open: (options: Record<string, unknown>) => Promise<unknown>;
+};
+
+let shareModule: ShareModule | null | undefined;
+
+const loadShare = (): ShareModule | null => {
+  if (shareModule !== undefined) return shareModule;
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const mod = require('react-native-share');
+    shareModule = (mod?.default ?? mod) as ShareModule;
+  } catch {
+    shareModule = null; // not installed — feature unavailable
+  }
+  return shareModule;
+};
+
+/**
+ * Whether diagnostic sharing is available (i.e. `react-native-share` is
+ * installed in the host app). The result-screen button hides itself when false.
+ */
+export const isDiagnosticSharingAvailable = (): boolean => loadShare() != null;
+
+export interface DiagnosticImage {
+  /** Stable file name without extension, e.g. "mrz-side". */
+  name: string;
+  base64: string;
+  mime: 'jpg' | 'png';
+}
+
+export interface SendDiagnosticParams {
+  scan: ScanDataForReport;
+  sdkVersion: string;
+  sessionId?: string;
+  /** base64 images to attach (MRZ side / front / face / NFC chip face). */
+  images?: DiagnosticImage[];
+}
+
+
+const writeTemp = async (
+  dir: string,
+  name: string,
+  data: string,
+  encoding: 'utf8' | 'base64'
+): Promise<string> => {
+  const path = `${dir}/${name}`;
+  await RNFS.writeFile(path, data, encoding);
+  return path.startsWith('file://') ? path : `file://${path}`;
+};
+
+export interface SendResult {
+  shared: boolean;
+  /** True when the user dismissed the share sheet (not an error). */
+  dismissed?: boolean;
+}
+
+/**
+ * Build the report, stage attachments, and present the share sheet. Returns
+ * { shared } — false on error, with `dismissed` set when the user cancelled.
+ */
+export const sendDiagnosticReport = async (
+  params: SendDiagnosticParams
+): Promise<SendResult> => {
+  const share = loadShare();
+  if (!share) {
+    // Optional dependency not installed — nothing to do.
+    return { shared: false };
+  }
+  const { scan, sdkVersion, sessionId, images = [] } = params;
+  const now = Date.now();
+  const iso = new Date(now).toISOString();
+
+  const device = await gatherDeviceDetails();
+  const report = buildDiagnosticReport({
+    diag: diagnostics.snapshot(now, iso),
+    device,
+    scan,
+    sdkVersion,
+    sessionId,
+  });
+
+  const dir = `${RNFS.TemporaryDirectoryPath}/trustchex-diagnostics-${now}`;
+  try {
+    await RNFS.mkdir(dir);
+    const urls: string[] = [];
+    urls.push(
+      await writeTemp(dir, 'diagnostics.json', report.diagnosticsJson, 'utf8')
+    );
+    urls.push(
+      await writeTemp(dir, 'scan-data.json', report.scanDataJson, 'utf8')
+    );
+    for (const img of images) {
+      if (!img.base64) continue;
+      urls.push(
+        await writeTemp(dir, `${img.name}.${img.mime}`, img.base64, 'base64')
+      );
+    }
+
+    try {
+      await share.open({
+        title: report.subject,
+        subject: report.subject, // used by email targets
+        message: report.body,
+        urls,
+        // Per-file MIME types so targets render attachments correctly.
+        filenames: urls.map((u) => u.split('/').pop() ?? 'attachment'),
+        failOnCancel: false,
+      });
+      return { shared: true };
+    } catch (shareErr) {
+      // react-native-share throws on user cancel unless failOnCancel:false; treat
+      // a cancel as a non-error dismissal.
+      const msg =
+        shareErr instanceof Error ? shareErr.message : String(shareErr);
+      if (/cancel|dismiss|user did not share/i.test(msg)) {
+        return { shared: false, dismissed: true };
+      }
+      throw shareErr;
+    }
+  } catch (e) {
+    logError(
+      'Diagnostics',
+      'Failed to share diagnostic report',
+      e instanceof Error ? e.message : String(e)
+    );
+    return { shared: false };
+  } finally {
+    // Best-effort cleanup — temp files are short-lived.
+    setTimeout(() => {
+      RNFS.unlink(dir).catch(() => {});
+    }, 60_000);
+  }
+};

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

@@ -0,0 +1,15 @@
+import 'react-native-get-random-values';
+
+// Unbiased Fisher–Yates shuffle backed by a CSPRNG. Used for the liveness
+// instruction order, which acts as an anti-replay challenge and must not be
+// predictable.
+export const secureShuffle = <T>(items: T[]): T[] => {
+  const result = [...items];
+  const random = new Uint32Array(1);
+  for (let i = result.length - 1; i > 0; i--) {
+    crypto.getRandomValues(random);
+    const j = random[0] % (i + 1);
+    [result[i], result[j]] = [result[j], result[i]];
+  }
+  return result;
+};

package/src/Shared/Services/AnalyticsService.ts

@@ -318,7 +318,13 @@ class AnalyticsService implements IAnalyticsService {
           throw new Error('Rate limit exceeded');
         }
 
-        // For other 4xx errors (Bad Request, Unauthorized, etc.), do NOT retry.
+        // Auth failures are transient from the SDK's perspective (e.g. a token
+        // rollout); throw so the batch is retried instead of silently dropped.
+        if (response.status === 401 || response.status === 403) {
+          throw new Error(`Authentication error: ${response.status}`);
+        }
+
+        // For other 4xx errors (Bad Request, etc.), do NOT retry.
         // We return successfully so the bad events are removed from the queue.
         if (response.status >= 400 && response.status < 500) {
           if (__DEV__)
@@ -450,6 +456,16 @@ class AnalyticsService implements IAnalyticsService {
       'password',
       'apikey',
       'accesstoken',
+      'documentnumber',
+      'personalnumber',
+      'nationalid',
+      'tckimlik',
+      'mrz',
+      'mrztext',
+      'birthdate',
+      'dateofbirth',
+      'sessionkey',
+      'sessiontoken',
     ];
 
     for (const [key, value] of Object.entries(metadata)) {