@trustchex/react-native-sdk 1.475.1 → 1.481.1

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

@@ -40,6 +40,12 @@ const FORMAT_GEOMETRY = {
   }
 };
 const MRZ_CHAR = /^[A-Z0-9<]$/;
+/**
+ * Floor applied to a frame's confidence multiplier. A frame ML Kit was very
+ * unsure about still contributes (it may carry the only reading of a cell), but
+ * at a fraction of a confident frame's weight.
+ */
+const MIN_CONFIDENCE_WEIGHT = 0.25;
 /**
  * Reconstructs fixed-width MRZ candidate line-sets for a frame's raw OCR text.
  * Reuses the same reconstruction the single-frame validator uses, so the
@@ -101,6 +107,10 @@ const linesForFrame = text => {
  * is valid + stable. Reset between documents with `reset`.
  */
 export class MRZFrameAggregator {
+  // Minimum winning vote margin a CONTESTED cell needs before the consensus is
+  // considered confident (and thus eligible to be "stable"). Guards against an
+  // early look-alike misread (A↔4, S↔5, B↔8) locking in on a 1-vote lead.
+
   // format -> per-line, per-column vote tallies
   tallies = {};
   frameCount = 0;
@@ -111,6 +121,7 @@ export class MRZFrameAggregator {
   constructor(options = {}) {
     this.stabilityTarget = Math.max(1, options.stabilityTarget ?? 2);
     this.maxFrames = Math.max(1, options.maxFrames ?? 60);
+    this.minMargin = Math.max(0, options.minMargin ?? 2);
   }
   reset() {
     this.tallies = {};
@@ -176,7 +187,12 @@ export class MRZFrameAggregator {
    * consensus is returned.
    */
   addFrame(input) {
-    const weight = input.weight && input.weight > 0 ? input.weight : 1;
+    const baseWeight = input.weight && input.weight > 0 ? input.weight : 1;
+    // Fold OCR confidence into the weight (clamped to [floor, 1]). Absent
+    // confidence leaves the weight unchanged, so callers without per-symbol
+    // confidence (e.g. iOS ML Kit) keep the prior sharpness-only behaviour.
+    const confidenceFactor = typeof input.confidence === 'number' && Number.isFinite(input.confidence) ? Math.min(1, Math.max(MIN_CONFIDENCE_WEIGHT, input.confidence)) : 1;
+    const weight = baseWeight * confidenceFactor;
     const lines = linesForFrame(input.text);
     if (lines) {
       // Determine the format this frame's lines fit (by line count + width).
@@ -224,6 +240,47 @@ export class MRZFrameAggregator {
     this.frameCount = Math.ceil(this.frameCount / 2);
   }
 
+  /**
+   * Is every CONTESTED cell of this format decided by a clear margin?
+   *
+   * A cell is contested when more than one distinct character has received votes
+   * (e.g. position 5 of a Turkish doc number gets both "A" and the look-alike
+   * "4"). Per-character voting alone reports the consensus "stable" the instant an
+   * early misread takes a 1-vote lead and stays unchanged — so a transient
+   * "A"→"4" confusion locks in before the correct glyph accumulates enough votes.
+   *
+   * Requiring the winner to lead the runner-up by `minMargin` weight on every
+   * contested cell defers stability until the vote has genuinely settled: a 2-vs-1
+   * early lead is NOT confident; a 4-vs-1 (or clean uncontested) reading is. This
+   * is what turns "looks valid this frame" into "the camera agrees across frames".
+   */
+  consensusIsConfident(format) {
+    return this.minContestedMargin(format) >= this.minMargin;
+  }
+
+  /**
+   * Smallest winning vote margin across all CONTESTED cells (where >1 distinct
+   * char was voted). Returns Infinity when no cell is contested. Used both to
+   * gate confidence and to surface a diagnostic of how narrowly a look-alike was
+   * resolved at acceptance.
+   */
+  minContestedMargin(format) {
+    const geom = FORMAT_GEOMETRY[format];
+    const tally = this.tallies[format];
+    let min = Infinity;
+    for (let li = 0; li < geom.lines; li++) {
+      for (let ci = 0; ci < geom.width; ci++) {
+        const cell = tally[li][ci];
+        const weights = Object.values(cell);
+        if (weights.length < 2) continue; // uncontested cell — no ambiguity
+        weights.sort((a, b) => b - a);
+        const margin = weights[0] - weights[1];
+        if (margin < min) min = margin;
+      }
+    }
+    return min;
+  }
+
   /** Read out the winning character per cell for a format. */
   consensusLines(format) {
     const geom = FORMAT_GEOMETRY[format];
@@ -259,12 +316,15 @@ export class MRZFrameAggregator {
         mrz: null,
         validation: null,
         frames: this.frameCount,
-        stable: false
+        stable: false,
+        stableStreak: 0,
+        minContestedMargin: Infinity
       };
     }
     let bestMrz = null;
     let bestValidation = null;
     let bestValid = false;
+    let bestFormat = null;
     for (const format of formats) {
       const lines = this.consensusLines(format);
       const mrz = lines.join('\n');
@@ -275,9 +335,11 @@ export class MRZFrameAggregator {
         bestValid = true;
         bestMrz = validation.correctedMrz ?? mrz;
         bestValidation = validation;
+        bestFormat = format;
       } else if (!bestValid && bestMrz === null) {
         bestMrz = mrz;
         bestValidation = validation;
+        bestFormat = format;
       }
     }
 
@@ -290,11 +352,20 @@ export class MRZFrameAggregator {
       this.stableStreak = stableKey ? 1 : 0;
     }
     this.lastConsensusMrz = stableKey;
+
+    // "Stable" requires BOTH an unchanged streak AND a confident vote: every
+    // contested cell must have resolved by a clear margin. The streak alone lets
+    // an early look-alike misread (A↔4) lock in the instant it takes a 1-vote
+    // lead and stops changing — the confidence gate defers acceptance until the
+    // correct glyph has genuinely won, not merely arrived first.
+    const confident = bestValid && bestFormat != null && this.consensusIsConfident(bestFormat);
     return {
       mrz: bestMrz,
       validation: bestValidation,
       frames: this.frameCount,
-      stable: bestValid && this.stableStreak >= this.stabilityTarget
+      stable: bestValid && confident && this.stableStreak >= this.stabilityTarget,
+      stableStreak: this.stableStreak,
+      minContestedMargin: bestFormat != null ? this.minContestedMargin(bestFormat) : Infinity
     };
   }
 }

package/lib/module/Shared/Libs/native-device-info.utils.js

@@ -2,6 +2,73 @@
 
 import { Platform } from 'react-native';
 import DeviceInfo from 'react-native-device-info';
+
+/**
+ * Full, non-PII device details for the support diagnostic report. Device-
+ * specific scanning/NFC issues correlate with hardware, OS level, memory and
+ * NFC capability, so we capture a broad-but-safe set. Excludes anything that
+ * identifies a person (uniqueId is a per-install vendor id, not PII, and is kept
+ * only for correlating repeat reports from the same device).
+ */
+
+/** Resolve an async getter to a number, tolerating failure. */
+const num = async p => {
+  try {
+    const v = await p;
+    return typeof v === 'number' && isFinite(v) ? v : undefined;
+  } catch {
+    return undefined;
+  }
+};
+
+/** Resolve an async getter, falling back on failure. */
+const safe = async (p, fallback) => {
+  try {
+    return await p;
+  } catch {
+    return fallback;
+  }
+};
+
+/** Read a synchronous getter, tolerating failure. */
+const sync = (fn, fallback) => {
+  try {
+    return fn();
+  } catch {
+    return fallback;
+  }
+};
+
+/** Gather the full non-PII device profile for a diagnostic report. */
+export const gatherDeviceDetails = async () => {
+  const bytesToMB = b => b === undefined ? undefined : Math.round(b / (1024 * 1024));
+  const isAndroid = Platform.OS === 'android';
+  const [manufacturer, isEmulator, apiLevel, installerPackage, totalMemory, usedMemory, totalDisk, freeDisk, batteryLevel, fontScale] = await Promise.all([safe(DeviceInfo.getManufacturer(), 'unknown'), safe(DeviceInfo.isEmulator(), false), isAndroid ? num(DeviceInfo.getApiLevel()) : Promise.resolve(undefined), safe(DeviceInfo.getInstallerPackageName(), 'unknown'), num(DeviceInfo.getTotalMemory()), num(DeviceInfo.getUsedMemory()), num(DeviceInfo.getTotalDiskCapacity()), num(DeviceInfo.getFreeDiskStorage()), num(DeviceInfo.getBatteryLevel()), num(DeviceInfo.getFontScale())]);
+  return {
+    platform: Platform.OS,
+    systemName: isAndroid ? 'Android' : 'iOS',
+    systemVersion: sync(() => DeviceInfo.getSystemVersion(), 'unknown'),
+    apiLevel,
+    brand: sync(() => DeviceInfo.getBrand(), 'unknown'),
+    manufacturer,
+    model: sync(() => DeviceInfo.getModel(), 'unknown'),
+    deviceId: sync(() => DeviceInfo.getDeviceId(), 'unknown'),
+    deviceType: sync(() => DeviceInfo.getDeviceType(), 'unknown'),
+    isTablet: sync(() => DeviceInfo.isTablet(), false),
+    isEmulator,
+    hasNotch: sync(() => DeviceInfo.hasNotch(), false),
+    totalMemoryMB: bytesToMB(totalMemory),
+    usedMemoryMB: bytesToMB(usedMemory),
+    totalDiskMB: bytesToMB(totalDisk),
+    freeDiskMB: bytesToMB(freeDisk),
+    batteryLevel,
+    appVersion: sync(() => DeviceInfo.getVersion(), 'unknown'),
+    buildNumber: sync(() => DeviceInfo.getBuildNumber(), 'unknown'),
+    bundleId: sync(() => DeviceInfo.getBundleId(), 'unknown'),
+    fontScale,
+    installerPackage
+  };
+};
 export const NativeDeviceInfo = {
   generateHumanReadableIdentifier: async () => {
     try {

package/lib/module/Shared/Libs/promise.utils.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import { debugLog } from "./debug.utils.js";
 const runWithRetry = async (fn, maxRetries = 3, delay = 1000) => {
   let retries = 0;
   let lastError;
@@ -7,11 +8,11 @@ const runWithRetry = async (fn, maxRetries = 3, delay = 1000) => {
   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) {
@@ -20,7 +21,7 @@ const runWithRetry = async (fn, maxRetries = 3, delay = 1000) => {
       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));
       }
     }

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

@@ -0,0 +1,130 @@
+"use strict";
+
+/**
+ * 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.js";
+import { gatherDeviceDetails } from "./native-device-info.utils.js";
+import { buildDiagnosticReport } from "./diagnosticReport.js";
+import { logError } from "./debug.utils.js";
+
+// `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.
+
+let shareModule;
+const loadShare = () => {
+  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;
+  } 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 = () => loadShare() != null;
+const writeTemp = async (dir, name, data, encoding) => {
+  const path = `${dir}/${name}`;
+  await RNFS.writeFile(path, data, encoding);
+  return path.startsWith('file://') ? path : `file://${path}`;
+};
+/**
+ * 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 => {
+  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 = [];
+    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/lib/module/Shared/Libs/shuffle.utils.js

@@ -0,0 +1,17 @@
+"use strict";
+
+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 = items => {
+  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/lib/module/Shared/Services/AnalyticsService.js

@@ -263,7 +263,13 @@ class AnalyticsService {
           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__) debugWarn('AnalyticsService', `[Analytics] Dropping batch due to ${response.status} error`);
@@ -354,7 +360,7 @@ class AnalyticsService {
   sanitizeMetadata(metadata) {
     if (!metadata) return undefined;
     const sanitized = {};
-    const forbiddenKeys = ['email', 'emailaddress', 'phone', 'phonenumber', 'firstname', 'lastname', 'fullname', 'address', 'streetaddress', 'ssn', 'socialsecurity', 'passport', 'passportnumber', 'driverlicense', 'creditcard', 'cardnumber', 'cvv', 'password', 'apikey', 'accesstoken'];
+    const forbiddenKeys = ['email', 'emailaddress', 'phone', 'phonenumber', 'firstname', 'lastname', 'fullname', 'address', 'streetaddress', 'ssn', 'socialsecurity', 'passport', 'passportnumber', 'driverlicense', 'creditcard', 'cardnumber', 'cvv', 'password', 'apikey', 'accesstoken', 'documentnumber', 'personalnumber', 'nationalid', 'tckimlik', 'mrz', 'mrztext', 'birthdate', 'dateofbirth', 'sessionkey', 'sessiontoken'];
     for (const [key, value] of Object.entries(metadata)) {
       const lowerKey = key.toLowerCase();