@trustchex/react-native-sdk 1.253.0 → 1.266.0

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

@@ -0,0 +1,430 @@
+"use strict";
+
+/**
+ * Analytics Helper Utilities
+ * Convenience functions for common analytics tracking patterns
+ * All functions handle errors silently to prevent blocking application flow
+ */
+
+import { useEffect, useState } from 'react';
+import { analyticsService } from "../Services/AnalyticsService.js";
+import { AnalyticsEventCategory, AnalyticsEventName } from "../Types/analytics.types.js";
+/**
+ * Track screen view event
+ */
+export const trackScreenView = async (screenName, previousScreen) => {
+  try {
+    await analyticsService.trackEvent(AnalyticsEventName.SCREEN_VIEW, AnalyticsEventCategory.NAVIGATION, {
+      screenName,
+      previousScreen
+    });
+  } catch (error) {
+    // Silently fail - analytics should never block app flow
+  }
+};
+
+/**
+ * Track screen exit with duration
+ */
+export const trackScreenExit = async (screenName, durationMs) => {
+  try {
+    await analyticsService.trackEvent(AnalyticsEventName.SCREEN_EXIT, AnalyticsEventCategory.NAVIGATION, {
+      screenName,
+      duration: durationMs
+    });
+  } catch (error) {
+    // Silently fail - analytics should never block app flow
+  }
+};
+
+/**
+ * Track button click
+ */
+export const trackButtonClick = async (buttonName, screenName, metadata) => {
+  try {
+    await analyticsService.trackEvent(AnalyticsEventName.BUTTON_CLICK, AnalyticsEventCategory.USER_ACTION, {
+      buttonName,
+      screenName,
+      ...metadata
+    });
+  } catch (error) {
+    // Silently fail - analytics should never block app flow
+  }
+};
+
+/**
+ * Sanitize stack trace to remove PII and file paths
+ */
+const sanitizeStackTrace = error => {
+  if (!error.stack) return undefined;
+  try {
+    // Keep only function names and line numbers, remove file paths
+    const lines = error.stack.split('\n').slice(0, 5);
+    return lines.map(line => {
+      // Remove full file paths, keep just the filename and line
+      return line.replace(/\(.*\/([^/]+:[0-9]+:[0-9]+)\)/, '($1)').replace(/at\s+.*\/([^/]+)/, 'at $1').trim();
+    }).join(' -> ');
+  } catch {
+    return undefined;
+  }
+};
+
+/**
+ * Infer error category from error code
+ */
+const inferErrorCategory = errorCode => {
+  const code = errorCode.toLowerCase();
+  if (code.includes('network') || code.includes('fetch') || code.includes('timeout')) return 'network';
+  if (code.includes('permission') || code.includes('denied')) return 'permission';
+  if (code.includes('camera')) return 'camera';
+  if (code.includes('nfc') || code.includes('eid')) return 'nfc';
+  if (code.includes('validation') || code.includes('invalid')) return 'validation';
+  if (code.includes('api') || code.includes('response') || code.includes('status')) return 'api';
+  if (code.includes('storage') || code.includes('file') || code.includes('save')) return 'storage';
+  if (code.includes('device')) return 'device';
+  if (code.includes('input') || code.includes('user')) return 'user_input';
+  return 'unknown';
+};
+
+/**
+ * Track error event with unique event name per error code
+ * Event name format: error_{errorCode} (e.g., error_camera_permission_denied)
+ * 
+ * Only errors with severity 'medium' or higher are recorded.
+ * Low severity errors are ignored to reduce noise.
+ * 
+ * @param errorCode - Unique identifier for the error type
+ * @param errorMessage - Human-readable error message (sanitized)
+ * @param screenName - Screen where the error occurred
+ * @param severity - Error severity level: 'low' | 'medium' | 'high' | 'critical'
+ * @param context - Optional additional context for the error
+ */
+export const trackError = async (errorCode, errorMessage, screenName, severity = 'medium', context) => {
+  try {
+    // Only track errors with severity medium or higher
+    // Low severity errors are expected/recoverable and create noise
+    if (severity === 'low') {
+      return;
+    }
+
+    // Create unique event name per error code
+    const eventName = `error_${errorCode.toLowerCase().replace(/[^a-z0-9]/g, '_')}`;
+
+    // Build metadata with all available context
+    const metadata = {
+      errorCode,
+      errorMessage,
+      screenName,
+      severity,
+      category: context?.category || inferErrorCategory(errorCode)
+    };
+
+    // Add optional context fields
+    if (context?.component) metadata.component = context.component;
+    if (context?.userAction) metadata.userAction = context.userAction;
+    if (context?.recoverable !== undefined) metadata.recoverable = context.recoverable;
+    if (context?.retryCount !== undefined) metadata.retryCount = context.retryCount;
+
+    // Add sanitized stack trace if error object provided
+    if (context?.error) {
+      const stackTrace = sanitizeStackTrace(context.error);
+      if (stackTrace) metadata.stackTrace = stackTrace;
+    }
+
+    // Merge additional data
+    if (context?.additionalData) {
+      Object.entries(context.additionalData).forEach(([key, value]) => {
+        metadata[key] = value;
+      });
+    }
+    await analyticsService.trackEvent(eventName, AnalyticsEventCategory.ERROR, metadata);
+  } catch (error) {
+    // Silently fail - analytics should never block app flow
+  }
+};
+
+/**
+ * Track error with full Error object for automatic stack trace extraction
+ */
+export const trackErrorWithDetails = async (error, errorCode, screenName, severity = 'medium', context) => {
+  return trackError(errorCode, error.message || 'Unknown error', screenName, severity, {
+    ...context,
+    error
+  });
+};
+
+/**
+ * Track API call performance
+ */
+export const trackApiCall = async (endpoint, durationMs, statusCode, success) => {
+  try {
+    await analyticsService.trackEvent(AnalyticsEventName.API_CALL_DURATION, AnalyticsEventCategory.PERFORMANCE, {
+      endpoint,
+      duration: durationMs,
+      statusCode,
+      success
+    });
+  } catch (error) {
+    // Silently fail - analytics should never block app flow
+  }
+};
+
+/**
+ * Map workflow step types to valid analytics event names
+ */
+const STEP_EVENT_MAP = {
+  contract_acceptance: {
+    started: AnalyticsEventName.CONTRACT_ACCEPTANCE_STARTED,
+    completed: AnalyticsEventName.CONTRACT_ACCEPTANCE_COMPLETED
+  },
+  identity_document_scan: {
+    started: AnalyticsEventName.DOCUMENT_SCAN_STARTED,
+    completed: AnalyticsEventName.DOCUMENT_SCAN_COMPLETED
+  },
+  identity_document_eid_scan: {
+    started: AnalyticsEventName.IDENTITY_DOCUMENT_EID_SCAN_STARTED,
+    completed: AnalyticsEventName.IDENTITY_DOCUMENT_EID_SCAN_COMPLETED
+  },
+  liveness_check: {
+    started: AnalyticsEventName.LIVENESS_CHECK_STARTED,
+    completed: AnalyticsEventName.LIVENESS_CHECK_COMPLETED
+  }
+};
+function getStepEventName(stepType, suffix) {
+  const normalizedStep = stepType.toLowerCase();
+  const mapping = STEP_EVENT_MAP[normalizedStep];
+  if (mapping) {
+    return mapping[suffix];
+  }
+  // Fallback to dynamic name for unknown step types
+  return `${normalizedStep}_${suffix}`;
+}
+
+/**
+ * Track verification process events
+ */
+export const trackVerificationStart = async stepType => {
+  try {
+    const eventName = getStepEventName(stepType, 'started');
+    await analyticsService.trackEvent(eventName, AnalyticsEventCategory.VERIFICATION, {
+      stepType
+    });
+  } catch (error) {
+    // Silently fail - analytics should never block app flow
+  }
+};
+export const trackVerificationComplete = async (stepType, success, attemptNumber) => {
+  try {
+    const eventName = getStepEventName(stepType, 'completed');
+    await analyticsService.trackEvent(eventName, AnalyticsEventCategory.VERIFICATION, {
+      stepType,
+      success,
+      attemptNumber
+    });
+  } catch (error) {
+    // Silently fail - analytics should never block app flow
+  }
+};
+
+/**
+ * Track session events
+ */
+export const trackSessionStart = async sessionId => {
+  try {
+    await analyticsService.trackEvent(AnalyticsEventName.SESSION_START, AnalyticsEventCategory.SESSION, {
+      sessionId
+    });
+  } catch (error) {
+    // Silently fail - analytics should never block app flow
+  }
+};
+export const trackSessionEnd = async (sessionId, reason) => {
+  try {
+    await analyticsService.trackEvent(AnalyticsEventName.SESSION_END, AnalyticsEventCategory.SESSION, {
+      sessionId,
+      reason
+    });
+  } catch (error) {
+    // Silently fail - analytics should never block app flow
+  }
+};
+
+/**
+ * Track NFC scan events with detailed metadata
+ */
+export const trackNFCScanStart = async (documentType, nfcSupported, nfcEnabled, attemptNumber = 1) => {
+  try {
+    await analyticsService.trackEvent(AnalyticsEventName.NFC_SCAN_STARTED, AnalyticsEventCategory.VERIFICATION, {
+      verificationType: 'nfc',
+      documentType,
+      nfcSupported,
+      nfcEnabled,
+      attemptNumber
+    });
+  } catch (error) {
+    // Silently fail - analytics should never block app flow
+  }
+};
+export const trackNFCScanComplete = async (documentType, scanDuration, attemptNumber = 1) => {
+  try {
+    await analyticsService.trackEvent(AnalyticsEventName.NFC_SCAN_COMPLETED, AnalyticsEventCategory.VERIFICATION, {
+      verificationType: 'nfc',
+      success: true,
+      documentType,
+      scanDuration,
+      attemptNumber
+    });
+  } catch (error) {
+    // Silently fail - analytics should never block app flow
+  }
+};
+export const trackNFCScanFailed = async (documentType, errorType, errorMessage, scanDuration, attemptNumber = 1, deviceModel, osVersion) => {
+  try {
+    const eventName = errorType === 'device_unsupported' ? AnalyticsEventName.NFC_DEVICE_UNSUPPORTED : errorType === 'user_cancelled' ? AnalyticsEventName.NFC_USER_CANCELLED : errorType === 'reading_error' ? AnalyticsEventName.NFC_READING_ERROR : AnalyticsEventName.NFC_SCAN_FAILED;
+    await analyticsService.trackEvent(eventName, AnalyticsEventCategory.ERROR, {
+      verificationType: 'nfc',
+      success: false,
+      documentType,
+      errorType,
+      errorMessage,
+      scanDuration,
+      attemptNumber,
+      deviceModel,
+      osVersion
+    });
+  } catch (error) {
+    // Silently fail - analytics should never block app flow
+  }
+};
+
+/**
+ * EID (identity document with NFC) specific events
+ */
+export const trackEIDScanStart = async (documentType, nfcSupported, nfcEnabled, attemptNumber = 1) => {
+  try {
+    await analyticsService.trackEvent(AnalyticsEventName.IDENTITY_DOCUMENT_EID_SCAN_STARTED, AnalyticsEventCategory.VERIFICATION, {
+      verificationType: 'nfc',
+      documentType,
+      nfcSupported,
+      nfcEnabled,
+      attemptNumber
+    });
+  } catch (error) {
+    // Silently fail - analytics should never block app flow
+  }
+};
+export const trackEIDScanComplete = async (documentType, scanDuration, attemptNumber = 1) => {
+  try {
+    await analyticsService.trackEvent(AnalyticsEventName.IDENTITY_DOCUMENT_EID_SCAN_COMPLETED, AnalyticsEventCategory.VERIFICATION, {
+      verificationType: 'nfc',
+      success: true,
+      documentType,
+      scanDuration,
+      attemptNumber
+    });
+  } catch (error) {
+    // Silently fail - analytics should never block app flow
+  }
+};
+export const trackEIDScanFailed = async (documentType, errorType, errorMessage, scanDuration, attemptNumber = 1, deviceModel, osVersion) => {
+  try {
+    await analyticsService.trackEvent(AnalyticsEventName.IDENTITY_DOCUMENT_EID_SCAN_FAILED, AnalyticsEventCategory.ERROR, {
+      verificationType: 'nfc',
+      success: false,
+      documentType,
+      errorType,
+      errorMessage,
+      scanDuration,
+      attemptNumber,
+      deviceModel,
+      osVersion
+    });
+  } catch (error) {
+    // Silently fail - analytics should never block app flow
+  }
+};
+
+/**
+ * Track step abandonment
+ */
+export const trackStepAbandoned = async (stepName, stepIndex, totalSteps, timeOnStep) => {
+  try {
+    await analyticsService.trackEvent(AnalyticsEventName.STEP_ABANDONED, AnalyticsEventCategory.USER_ACTION, {
+      stepName,
+      stepIndex,
+      totalSteps,
+      timeOnStep,
+      isRequired: true
+    });
+  } catch (error) {
+    // Silently fail - analytics should never block app flow
+  }
+};
+
+/**
+ * Track step skipped
+ */
+export const trackStepSkipped = async (stepName, stepIndex, totalSteps, previousStep) => {
+  try {
+    await analyticsService.trackEvent(AnalyticsEventName.STEP_SKIPPED, AnalyticsEventCategory.USER_ACTION, {
+      stepName,
+      stepIndex,
+      totalSteps,
+      previousStep,
+      isRequired: false
+    });
+  } catch (error) {
+    // Silently fail - analytics should never block app flow
+  }
+};
+
+/**
+ * Track consent/contract acceptance
+ */
+export const trackConsentGiven = async (contractIds, screenName = 'contract_acceptance') => {
+  try {
+    await analyticsService.trackEvent(AnalyticsEventName.CONSENT_GIVEN, AnalyticsEventCategory.USER_ACTION, {
+      screenName,
+      contractIds: contractIds.join(','),
+      consentType: 'contract_acceptance'
+    });
+  } catch (error) {
+    // Silently fail - analytics should never block app flow
+  }
+};
+
+/**
+ * Track funnel step progress
+ */
+export const trackFunnelStep = async (stepName, stepIndex, totalSteps, previousStep, isRequired = true) => {
+  try {
+    await analyticsService.trackEvent(AnalyticsEventName.SCREEN_VIEW, AnalyticsEventCategory.NAVIGATION, {
+      screenName: stepName,
+      stepName,
+      stepIndex,
+      totalSteps,
+      previousStep,
+      isRequired
+    });
+  } catch (error) {
+    // Silently fail - analytics should never block app flow
+  }
+};
+
+/**
+ * React hook for screen tracking
+ */
+export const useScreenTracking = screenName => {
+  const [screenStartTime] = useState(Date.now());
+  useEffect(() => {
+    // Track screen view on mount
+    trackScreenView(screenName);
+
+    // Track screen exit on unmount with current screenName captured in closure
+    const currentScreen = screenName;
+    return () => {
+      const duration = Date.now() - screenStartTime;
+      trackScreenExit(currentScreen, duration);
+    };
+  }, [screenName, screenStartTime]);
+};

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

@@ -1,5 +1,8 @@
 "use strict";
 
+/**
+ * Get average brightness for entire frame (center area)
+ */
 const getAverageBrightness = frame => {
   'worklet';
 
@@ -24,9 +27,62 @@ const getAverageBrightness = frame => {
   }
   return luminanceSum / pixelCount;
 };
+
+/**
+ * Get average brightness for a specific circular region (for face detection)
+ * Calculates brightness only for pixels inside the circle defined by centerX, centerY, and radius
+ */
+const getCircularRegionBrightness = (frame, circleRect) => {
+  'worklet';
+
+  const buffer = frame.toArrayBuffer();
+  const data = new Uint8Array(buffer);
+  const width = frame.width;
+  const height = frame.height;
+
+  // Calculate circle parameters from rect
+  const centerX = Math.floor(circleRect.minX + circleRect.width / 2);
+  const centerY = Math.floor(circleRect.minY + circleRect.height / 2);
+  const radius = Math.floor(Math.min(circleRect.width, circleRect.height) / 2);
+  let luminanceSum = 0;
+  let pixelCount = 0;
+
+  // Calculate bounding box for the circle to optimize iteration
+  const minX = Math.max(0, centerX - radius);
+  const maxX = Math.min(width - 1, centerX + radius);
+  const minY = Math.max(0, centerY - radius);
+  const maxY = Math.min(height - 1, centerY + radius);
+
+  // Iterate only over pixels in the bounding box
+  for (let y = minY; y <= maxY; y++) {
+    for (let x = minX; x <= maxX; x++) {
+      // Check if pixel is inside the circle
+      const dx = x - centerX;
+      const dy = y - centerY;
+      const distanceSquared = dx * dx + dy * dy;
+      if (distanceSquared <= radius * radius) {
+        const index = y * width + x;
+        if (data[index] !== undefined) {
+          luminanceSum += data[index];
+          pixelCount++;
+        }
+      }
+    }
+  }
+  return pixelCount > 0 ? luminanceSum / pixelCount : 0;
+};
 const isFrameBright = frame => {
   'worklet';
 
-  return getAverageBrightness(frame) > 80;
+  return getAverageBrightness(frame) > 60;
+};
+
+/**
+ * Check if a circular region in the frame is bright enough
+ */
+const isCircularRegionBright = (frame, circleRect, threshold = 60) => {
+  'worklet';
+
+  return getCircularRegionBrightness(frame, circleRect) > threshold;
 };
-export { isFrameBright, getAverageBrightness };
+export { isFrameBright, getAverageBrightness, getCircularRegionBrightness, isCircularRegionBright };

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

@@ -3,18 +3,26 @@
 const handleDeepLink = ({
   url
 }) => {
+  console.log('[handleDeepLink] Received URL:', url);
   const isHttps = url.includes('https');
   const route = url.replace(/http(s)?(:)?(\/\/)?/g, '');
   const segments = route.split('/');
+  console.log('[handleDeepLink] Parsed segments:', segments);
   let baseUrl = '';
   let sessionId = '';
   for (let i = 0; i < segments.length; i++) {
     if (segments[i] === 'verification-session') {
       sessionId = segments[i + 1] ?? '';
+      console.log('[handleDeepLink] Found sessionId:', sessionId);
     } else if (segments[i] === 'app-url') {
       baseUrl = `${isHttps ? 'https' : 'http'}://${segments[i + 1]}`;
+      console.log('[handleDeepLink] Found baseUrl:', baseUrl);
     }
   }
+  console.log('[handleDeepLink] Returning:', {
+    baseUrl,
+    sessionId
+  });
   return [baseUrl, sessionId];
 };
 export { handleDeepLink };

package/lib/module/Shared/Libs/http-client.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import { trackApiCall, trackError } from "./analytics.utils.js";
 export class HttpClientError extends Error {
   constructor(message) {
     super(message);
@@ -38,39 +39,99 @@ const request = async (httpMethod, url, body, simulatedResponse) => {
       }, 1000);
     });
   }
-  const response = await fetch(url, {
-    method: httpMethod,
-    headers: {
-      'Content-Type': 'application/json'
-    },
-    body: body ? JSON.stringify(body) : undefined
-  });
-  let responseJson = null;
+  const startTime = Date.now();
+  let statusCode = 0;
+  let success = false;
   try {
-    responseJson = await response.json();
-  } catch (error) {
-    // throw new Error("Invalid response");
-  }
-  if (response && !response.ok && responseJson) {
-    const message = responseJson.message;
-    if (response.status === 401) {
-      throw new UnauthorizedError(message);
-    }
-    if (response.status === 403) {
-      throw new ForbiddenError(message);
-    }
-    if (response.status === 404) {
-      throw new NotFoundError(message);
+    const response = await fetch(url, {
+      method: httpMethod,
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: body ? JSON.stringify(body) : undefined
+    });
+    statusCode = response.status;
+    success = response.ok;
+    let responseJson = null;
+    try {
+      responseJson = await response.json();
+    } catch (error) {
+      // Invalid JSON response
     }
-    if (response.status >= 500) {
-      throw new InternalServerError(message);
+
+    // Track API call performance (non-blocking)
+    // Wrap in try-catch to ensure analytics failures never mask HTTP errors
+    try {
+      const duration = Date.now() - startTime;
+      trackApiCall(url, duration, statusCode, success).catch(() => {});
+    } catch {}
+    if (response && !response.ok && responseJson) {
+      const message = responseJson.message;
+      const getErrorCodeFromStatus = status => {
+        switch (status) {
+          case 400:
+            return 'BAD_REQUEST';
+          case 401:
+            return 'UNAUTHORIZED';
+          case 403:
+            return 'FORBIDDEN';
+          case 404:
+            return 'NOT_FOUND';
+          case 500:
+            return 'INTERNAL_SERVER_ERROR';
+          case 502:
+            return 'BAD_GATEWAY';
+          case 503:
+            return 'SERVICE_UNAVAILABLE';
+          case 504:
+            return 'GATEWAY_TIMEOUT';
+          default:
+            return `API_ERROR_${status}`;
+        }
+      };
+      const getSeverityFromStatus = status => {
+        if (status >= 500) return 'high';
+        if (status === 401 || status === 403) return 'medium';
+        if (status === 400 || status === 404) return 'low';
+        return 'medium';
+      };
+
+      // Track API error (non-blocking)
+      // Wrap in try-catch to ensure analytics failures never mask HTTP errors
+      try {
+        trackError(getErrorCodeFromStatus(statusCode), message || 'API request failed', 'http_client', getSeverityFromStatus(statusCode)).catch(() => {});
+      } catch {}
+      if (response.status === 401) {
+        throw new UnauthorizedError(message);
+      }
+      if (response.status === 403) {
+        throw new ForbiddenError(message);
+      }
+      if (response.status === 404) {
+        throw new NotFoundError(message);
+      }
+      if (response.status >= 500) {
+        throw new InternalServerError(message);
+      }
+      if (response.status >= 400) {
+        throw new BadRequestError(message);
+      }
+      throw new Error(message);
     }
-    if (response.status >= 400) {
-      throw new BadRequestError(message);
+    return responseJson;
+  } catch (error) {
+    // Only track network errors for actual network failures, not HTTP errors
+    // HTTP errors (4xx, 5xx) are already tracked above before throwing
+    if (!(error instanceof HttpClientError)) {
+      try {
+        const duration = Date.now() - startTime;
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        trackApiCall(url, duration, statusCode, false).catch(() => {});
+        trackError('NETWORK_ERROR', errorMessage, 'http_client', 'high').catch(() => {});
+      } catch {}
     }
-    throw new Error(message);
+    throw error;
   }
-  return responseJson;
 };
 const get = (url, simulatedResponse) => {
   return request('GET', url, undefined, simulatedResponse);