@trustchex/react-native-sdk 1.355.1 → 1.357.0

package/src/Shared/EIDReader/tlv/tlv.helpers.ts

@@ -0,0 +1,96 @@
+import { ASN1Constants } from './asn1Constants';
+
+export class TLVHelpers extends ASN1Constants {
+  public static isPrimitive(tag: number): boolean {
+    let i = 3;
+    for (; i >= 0; i--) {
+      const mask = 0xff << (8 * i);
+      if ((tag & mask) !== 0x00) {
+        break;
+      }
+    }
+    const msByte = ((tag & (0xff << (8 * i))) >> (8 * i)) & 0xff;
+    return (msByte & 0x20) === 0x00;
+  }
+
+  public static getTagLength(tag: number): number {
+    return TLVHelpers.getTagAsBytes(tag).length;
+  }
+
+  public static getLengthLength(length: number): number {
+    return TLVHelpers.getLengthAsBytes(length).length;
+  }
+
+  public static getTagAsBytes(tag: number): number[] {
+    const out: number[] = [];
+    const byteCount = Math.floor(Math.log(tag) / Math.log(256)) + 1;
+    for (let i = 0; i < byteCount; i++) {
+      const pos = 8 * (byteCount - i - 1);
+      out.push((tag & (0xff << pos)) >> pos);
+    }
+    const tagBytes = out;
+    switch (TLVHelpers.getTagClass(tag)) {
+      case TLVHelpers.APPLICATION_CLASS:
+        tagBytes[0] |= 0x40;
+        break;
+      case TLVHelpers.CONTEXT_SPECIFIC_CLASS:
+        tagBytes[0] |= 0x80;
+        break;
+      case TLVHelpers.PRIVATE_CLASS:
+        tagBytes[0] |= 0xc0;
+        break;
+      default:
+        break;
+    }
+    if (!TLVHelpers.isPrimitive(tag)) {
+      tagBytes[0] |= 0x20;
+    }
+    return tagBytes;
+  }
+
+  public static getLengthAsBytes(length: number): number[] {
+    const out: number[] = [];
+    if (length < 0x80) {
+      out.push(length);
+    } else {
+      const byteCount = TLVHelpers.log(length, 256);
+      out.push(0x80 | byteCount);
+      for (let i = 0; i < byteCount; i++) {
+        const pos = 8 * (byteCount - i - 1);
+        out.push((length & (0xff << pos)) >> pos);
+      }
+    }
+    return out;
+  }
+
+  static getTagClass(tag: number): number {
+    let i = 3;
+    for (; i >= 0; i--) {
+      const mask = 0xff << (8 * i);
+      if ((tag & mask) !== 0x00) {
+        break;
+      }
+    }
+    const msByte = ((tag & (0xff << (8 * i))) >> (8 * i)) & 0xff;
+    switch (msByte & 0xc0) {
+      case 0x00:
+        return TLVHelpers.UNIVERSAL_CLASS;
+      case 0x40:
+        return TLVHelpers.APPLICATION_CLASS;
+      case 0x80:
+        return TLVHelpers.CONTEXT_SPECIFIC_CLASS;
+      case 0xc0:
+      default:
+        return TLVHelpers.PRIVATE_CLASS;
+    }
+  }
+
+  private static log(n: number, base: number): number {
+    let result = 0;
+    while (n > 0) {
+      n = n / base;
+      result++;
+    }
+    return result;
+  }
+}

package/src/Shared/EIDReader/tlv/tlv.utils.ts

@@ -1,97 +1,12 @@
 import { ByteArrayInputStream } from '../java/byteArrayInputStream';
 import { ByteArrayOutputStream } from '../java/byteArrayOutputStream';
-import { ASN1Constants } from './asn1Constants';
 import { TLVInputStream } from './tlvInputStream';
 import { TLVOutputStream } from './tlvOutputStream';
 import { Buffer } from 'buffer';
+import { TLVHelpers } from './tlv.helpers';
 
-class TLVUtil extends ASN1Constants {
-  public static isPrimitive(tag: number): boolean {
-    let i = 3;
-    for (; i >= 0; i--) {
-      const mask = 0xff << (8 * i);
-      if ((tag & mask) !== 0x00) {
-        break;
-      }
-    }
-    const msByte = ((tag & (0xff << (8 * i))) >> (8 * i)) & 0xff;
-    return (msByte & 0x20) === 0x00;
-  }
-
-  public static getTagLength(tag: number): number {
-    return TLVUtil.getTagAsBytes(tag).length;
-  }
-
-  public static getLengthLength(length: number): number {
-    return TLVUtil.getLengthAsBytes(length).length;
-  }
-
-  /**
-   * The tag bytes of this object.
-   *
-   * @param tag the tag
-   *
-   * @return the tag bytes of this object.
-   */
-  public static getTagAsBytes(tag: number): number[] {
-    const out: number[] = [];
-    const byteCount = Math.floor(Math.log(tag) / Math.log(256)) + 1;
-    for (let i = 0; i < byteCount; i++) {
-      const pos = 8 * (byteCount - i - 1);
-      out.push((tag & (0xff << pos)) >> pos);
-    }
-    const tagBytes = out;
-    switch (TLVUtil.getTagClass(tag)) {
-      case TLVUtil.APPLICATION_CLASS:
-        tagBytes[0] |= 0x40;
-        break;
-      case TLVUtil.CONTEXT_SPECIFIC_CLASS:
-        tagBytes[0] |= 0x80;
-        break;
-      case TLVUtil.PRIVATE_CLASS:
-        tagBytes[0] |= 0xc0;
-        break;
-      default:
-        /* NOTE: Unsupported tag class. Now what? */
-        break;
-    }
-    if (!TLVUtil.isPrimitive(tag)) {
-      tagBytes[0] |= 0x20;
-    }
-    return tagBytes;
-  }
+class TLVUtil extends TLVHelpers {
 
-  /**
-   * The length bytes of this object.
-   *
-   * @param length the length
-   *
-   * @return length of encoded value as bytes
-   */
-  public static getLengthAsBytes(length: number): number[] {
-    const out: number[] = [];
-    if (length < 0x80) {
-      /* short form */
-      out.push(length);
-    } else {
-      const byteCount = TLVUtil.log(length, 256);
-      out.push(0x80 | byteCount);
-      for (let i = 0; i < byteCount; i++) {
-        const pos = 8 * (byteCount - i - 1);
-        out.push((length & (0xff << pos)) >> pos);
-      }
-    }
-    return out;
-  }
-
-  /**
-   * TLV encodes an encoded data object with a tag.
-   *
-   * @param tag the tag
-   * @param data the data to encode
-   *
-   * @return the TLV encoded data
-   */
   public static wrapDO(tag: number, data: number[]): Uint8Array {
     if (data == null) {
       throw new Error('Data to wrap is null');
@@ -117,14 +32,6 @@ class TLVUtil extends ASN1Constants {
     }
   }
 
-  /**
-   * TLV decodes tagged TLV data object.
-   *
-   * @param expectedTag the tag to expect, an {@code IllegalArgumentException} will be throws if a different tag is read
-   * @param wrappedData the encoded data
-   *
-   * @return the decoded data
-   */
   public static async unwrapDO(
     expectedTag: number,
     wrappedData: number[]
@@ -166,36 +73,6 @@ class TLVUtil extends ASN1Constants {
     }
   }
 
-  static getTagClass(tag: number): number {
-    let i = 3;
-    for (; i >= 0; i--) {
-      const mask = 0xff << (8 * i);
-      if ((tag & mask) !== 0x00) {
-        break;
-      }
-    }
-    const msByte = ((tag & (0xff << (8 * i))) >> (8 * i)) & 0xff;
-    switch (msByte & 0xc0) {
-      case 0x00:
-        return TLVUtil.UNIVERSAL_CLASS;
-      case 0x40:
-        return TLVUtil.APPLICATION_CLASS;
-      case 0x80:
-        return TLVUtil.CONTEXT_SPECIFIC_CLASS;
-      case 0xc0:
-      default:
-        return TLVUtil.PRIVATE_CLASS;
-    }
-  }
-
-  private static log(n: number, base: number): number {
-    let result = 0;
-    while (n > 0) {
-      n = n / base;
-      result++;
-    }
-    return result;
-  }
 }
 
 export default TLVUtil;

package/src/Shared/EIDReader/tlv/tlvInputStream.ts

@@ -1,7 +1,7 @@
 import { ByteArrayInputStream } from '../java/byteArrayInputStream';
 import { DataInputStream } from '../java/dataInputStream';
 import { InputStream } from '../java/inputStream';
-import TLVUtil from './tlv.utils';
+import { TLVHelpers } from './tlv.helpers';
 import { TLVInputState } from './tlvInputState';
 
 export class TLVInputStream extends InputStream {
@@ -132,11 +132,11 @@ export class TLVInputStream extends InputStream {
       if (this.state.getIsAtStartOfTag()) {
       } else if (this.state.getIsAtStartOfLength()) {
         await this.readLength();
-        if (TLVUtil.isPrimitive(this.state.getTag())) {
+        if (TLVHelpers.isPrimitive(this.state.getTag())) {
           await this.skipValue();
         }
       } else {
-        if (TLVUtil.isPrimitive(this.state.getTag())) {
+        if (TLVHelpers.isPrimitive(this.state.getTag())) {
           await this.skipValue();
         }
       }
@@ -144,7 +144,7 @@ export class TLVInputStream extends InputStream {
       if (tag === searchTag) {
         return;
       }
-      if (TLVUtil.isPrimitive(tag)) {
+      if (TLVHelpers.isPrimitive(tag)) {
         const length = await this.readLength();
         const skippedBytes = await this.skipValue();
         if (skippedBytes >= length) {

package/src/Shared/EIDReader/tlv/tlvOutputState.ts

@@ -1,4 +1,4 @@
-import TLVUtil from './tlv.utils';
+import { TLVHelpers } from './tlv.helpers';
 
 export class TLVOutputState {
   private state: TLVStruct[];
@@ -68,7 +68,7 @@ export class TLVOutputState {
     const obj = new TLVStruct(tag);
     if (this.state.length !== 0) {
       const parent = this.state[this.state.length - 1];
-      const tagBytes = TLVUtil.getTagAsBytes(tag);
+      const tagBytes = TLVHelpers.getTagAsBytes(tag);
       parent.write(tagBytes, 0, tagBytes.length);
     }
 
@@ -99,7 +99,7 @@ export class TLVOutputState {
       const obj = this.state.pop();
       if (this.state.length !== 0) {
         const parent = this.state[this.state.length - 1];
-        const lengthBytes = TLVUtil.getLengthAsBytes(length);
+        const lengthBytes = TLVHelpers.getLengthAsBytes(length);
         parent.write(lengthBytes, 0, lengthBytes.length);
       }
 
@@ -125,7 +125,7 @@ export class TLVOutputState {
           currentObject.getValueBytesProcessed() === currentObject.getLength()
         ) {
           this.state.pop();
-          const lengthBytes = TLVUtil.getLengthAsBytes(byteCount);
+          const lengthBytes = TLVHelpers.getLengthAsBytes(byteCount);
           const value = currentObject.getValue();
           this.updateValueBytesProcessed(lengthBytes, 0, lengthBytes.length);
           this.updateValueBytesProcessed(value, 0, value.length);

package/src/Shared/EIDReader/tlv/tlvOutputStream.ts

@@ -1,6 +1,6 @@
 import { DataOutputStream } from '../java/dataOutputStream';
 import { OutputStream } from '../java/outputStream';
-import TLVUtil from './tlv.utils';
+import { TLVHelpers } from './tlv.helpers';
 import { TLVOutputState } from './tlvOutputState';
 
 export class TLVOutputStream extends OutputStream {
@@ -20,7 +20,7 @@ export class TLVOutputStream extends OutputStream {
     if (!this.state.getIsAtStartOfTag()) {
       throw new Error('Cannot write tag, still need length');
     }
-    const tagAsBytes = TLVUtil.getTagAsBytes(tag);
+    const tagAsBytes = TLVHelpers.getTagAsBytes(tag);
     this.outputStream.writeBytes(Uint8Array.from(tagAsBytes));
     this.state.setTagProcessed(tag);
   }
@@ -29,7 +29,7 @@ export class TLVOutputStream extends OutputStream {
     if (!this.state.getIsAtStartOfLength()) {
       throw new Error('Cannot write length');
     }
-    const lengthAsBytes = TLVUtil.getLengthAsBytes(length);
+    const lengthAsBytes = TLVHelpers.getLengthAsBytes(length);
     this.outputStream.writeBytes(Uint8Array.from(lengthAsBytes));
     this.state.setLengthProcessed(length);
   }
@@ -92,7 +92,7 @@ export class TLVOutputStream extends OutputStream {
       const length = bufferedValueBytes.length;
       this.state.updatePreviousLength(length);
       if (this.state.canBeWritten()) {
-        const lengthAsBytes = TLVUtil.getLengthAsBytes(length);
+        const lengthAsBytes = TLVHelpers.getLengthAsBytes(length);
         this.outputStream.writeBytes(Uint8Array.from(lengthAsBytes));
         this.outputStream.writeBytes(Uint8Array.from(bufferedValueBytes));
       }

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

@@ -10,7 +10,11 @@ import {
   AnalyticsEventCategory,
   AnalyticsEventName,
 } from '../Types/analytics.types';
-import type { AnalyticsEventMetadata, ErrorSeverity, ErrorContext } from '../Types/analytics.types';
+import type {
+  AnalyticsEventMetadata,
+  ErrorSeverity,
+  ErrorContext,
+} from '../Types/analytics.types';
 
 /**
  * Track screen view event
@@ -86,11 +90,12 @@ const sanitizeStackTrace = (error: Error): string | undefined => {
     // Keep only function names and line numbers, remove file paths
     const lines = error.stack.split('\n').slice(0, 5);
     return lines
-      .map(line => {
+      .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();
+        return line
+          .replace(/\(.*\/([^/]+:[0-9]+:[0-9]+)\)/, '($1)')
+          .replace(/at\s+.*\/([^/]+)/, 'at $1')
+          .trim();
       })
       .join(' -> ');
   } catch {
@@ -103,13 +108,30 @@ const sanitizeStackTrace = (error: Error): string | undefined => {
  */
 const inferErrorCategory = (errorCode: string): string => {
   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('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('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';
@@ -118,10 +140,10 @@ const inferErrorCategory = (errorCode: string): string => {
 /**
  * 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
@@ -165,9 +187,11 @@ export const trackError = async (
     // 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;
-    
+    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);
@@ -245,7 +269,10 @@ export const trackApiCall = async (
 /**
  * Map workflow step types to valid analytics event names
  */
-const STEP_EVENT_MAP: Record<string, { started: AnalyticsEventName; completed: AnalyticsEventName }> = {
+const STEP_EVENT_MAP: Record<
+  string,
+  { started: AnalyticsEventName; completed: AnalyticsEventName }
+> = {
   contract_acceptance: {
     started: AnalyticsEventName.CONTRACT_ACCEPTANCE_STARTED,
     completed: AnalyticsEventName.CONTRACT_ACCEPTANCE_COMPLETED,
@@ -264,7 +291,10 @@ const STEP_EVENT_MAP: Record<string, { started: AnalyticsEventName; completed: A
   },
 };
 
-function getStepEventName(stepType: string, suffix: 'started' | 'completed'): string {
+function getStepEventName(
+  stepType: string,
+  suffix: 'started' | 'completed'
+): string {
   const normalizedStep = stepType.toLowerCase();
   const mapping = STEP_EVENT_MAP[normalizedStep];
   if (mapping) {
@@ -277,9 +307,7 @@ function getStepEventName(stepType: string, suffix: 'started' | 'completed'): st
 /**
  * Track verification process events
  */
-export const trackVerificationStart = async (
-  stepType: string
-) => {
+export const trackVerificationStart = async (stepType: string) => {
   try {
     const eventName = getStepEventName(stepType, 'started');
 

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

@@ -0,0 +1,149 @@
+/**
+ * Debug logging utility with log levels for SDK development
+ * Logs are filtered based on the current log level and debug mode
+ *
+ * Log Levels (lower number = more verbose):
+ * 0 - TRACE (all debug information)
+ * 1 - DEBUG (important debug information)
+ * 2 - INFO (informational messages)
+ * 3 - WARN (warnings and important issues)
+ * 4 - ERROR (errors only)
+ * 5 - SILENT (no logging)
+ *
+ * Enable debug mode via:
+ * 1. Environment variable: TRUSTCHEX_DEBUG=true
+ * 2. Global flag: (global as any).TRUSTCHEX_DEBUG = true
+ * 3. TrustchexProvider prop: debug={true}
+ *
+ * Set log level via:
+ * 1. setLogLevel(LogLevel.TRACE)
+ * 2. TRUSTCHEX_LOG_LEVEL environment variable
+ * 3. TrustchexProvider prop: logLevel="trace"
+ */
+
+export enum LogLevel {
+  TRACE = 0,
+  DEBUG = 1,
+  INFO = 2,
+  WARN = 3,
+  ERROR = 4,
+  SILENT = 5,
+}
+
+let debugEnabled =
+  process.env.NODE_ENV === 'development' &&
+  ((global as any).TRUSTCHEX_DEBUG === true ||
+    process.env.TRUSTCHEX_DEBUG === 'true');
+
+// Default to TRACE level for development debugging
+let currentLogLevel: LogLevel = debugEnabled ? LogLevel.TRACE : LogLevel.WARN;
+
+// Parse log level from env or string
+const parseLogLevel = (level: string | LogLevel | undefined): LogLevel => {
+  if (level === undefined) return currentLogLevel;
+  if (typeof level === 'number') return level;
+
+  const levelMap: Record<string, LogLevel> = {
+    trace: LogLevel.TRACE,
+    debug: LogLevel.DEBUG,
+    info: LogLevel.INFO,
+    warn: LogLevel.WARN,
+    error: LogLevel.ERROR,
+    silent: LogLevel.SILENT,
+  };
+
+  return levelMap[level.toLowerCase()] ?? currentLogLevel;
+};
+
+export const setDebugMode = (enabled: boolean) => {
+  debugEnabled = enabled;
+  // When debug mode is enabled, default to TRACE level
+  if (enabled && currentLogLevel === LogLevel.WARN) {
+    currentLogLevel = LogLevel.TRACE;
+  }
+};
+
+export const setLogLevel = (level: LogLevel | string) => {
+  currentLogLevel = parseLogLevel(level);
+};
+
+export const isDebugEnabled = () => {
+  return debugEnabled;
+};
+
+export const getLogLevel = () => {
+  return currentLogLevel;
+};
+
+// Check if a message at the given level should be logged
+const shouldLog = (level: LogLevel): boolean => {
+  return debugEnabled && level >= currentLogLevel;
+};
+
+export const traceLog = (tag: string, message: string, data?: unknown) => {
+  if (!shouldLog(LogLevel.TRACE)) return;
+
+  if (data !== undefined) {
+    console.log(`[${tag}] TRACE: ${message}`, data);
+  } else {
+    console.log(`[${tag}] TRACE: ${message}`);
+  }
+};
+
+export const debugLog = (tag: string, message: string, data?: unknown) => {
+  if (!shouldLog(LogLevel.DEBUG)) return;
+
+  if (data !== undefined) {
+    console.log(`[${tag}] DEBUG: ${message}`, data);
+  } else {
+    console.log(`[${tag}] DEBUG: ${message}`);
+  }
+};
+
+export const infoLog = (tag: string, message: string, data?: unknown) => {
+  if (!shouldLog(LogLevel.INFO)) return;
+
+  if (data !== undefined) {
+    console.log(`[${tag}] INFO: ${message}`, data);
+  } else {
+    console.log(`[${tag}] INFO: ${message}`);
+  }
+};
+
+export const debugWarn = (tag: string, message: string, data?: unknown) => {
+  if (!shouldLog(LogLevel.WARN)) return;
+
+  if (data !== undefined) {
+    console.warn(`[${tag}] WARN: ${message}`, data);
+  } else {
+    console.warn(`[${tag}] WARN: ${message}`);
+  }
+};
+
+export const debugError = (tag: string, message: string, error?: unknown) => {
+  if (!shouldLog(LogLevel.ERROR)) return;
+
+  if (error !== undefined) {
+    console.error(`[${tag}] ERROR: ${message}`, error);
+  } else {
+    console.error(`[${tag}] ERROR: ${message}`);
+  }
+};
+
+// Always log errors regardless of debug mode (critical issues)
+export const logError = (tag: string, message: string, error?: unknown) => {
+  if (error !== undefined) {
+    console.error(`[${tag}] ERROR: ${message}`, error);
+  } else {
+    console.error(`[${tag}] ERROR: ${message}`);
+  }
+};
+
+// Always log warnings for critical issues regardless of debug mode
+export const logWarn = (tag: string, message: string, data?: unknown) => {
+  if (data !== undefined) {
+    console.warn(`[${tag}] WARN: ${message}`, data);
+  } else {
+    console.warn(`[${tag}] WARN: ${message}`);
+  }
+};

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

@@ -1,23 +1,25 @@
+import { debugLog } from './debug.utils';
+
 const handleDeepLink = ({ url }: { url: string }) => {
-  console.log('[handleDeepLink] Received URL:', url);
+  debugLog('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);
+  debugLog('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);
+      debugLog('handleDeepLink', 'Found sessionId:', sessionId);
     } else if (segments[i] === 'app-url') {
       baseUrl = `${isHttps ? 'https' : 'http'}://${segments[i + 1]}`;
-      console.log('[handleDeepLink] Found baseUrl:', baseUrl);
+      debugLog('handleDeepLink', 'Found baseUrl:', baseUrl);
     }
   }
 
-  console.log('[handleDeepLink] Returning:', { baseUrl, sessionId });
+  debugLog('handleDeepLink', 'Returning:', { baseUrl, sessionId });
   return [baseUrl, sessionId];
 };
 

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

@@ -21,6 +21,7 @@ const demoSession = {
       type: 'CONTRACT_ACCEPTANCE',
       required: false,
       data: {
+        voiceGuidanceActive: true,
         contracts: {
           en: {
             id: '1',
@@ -38,14 +39,17 @@ const demoSession = {
     {
       type: 'IDENTITY_DOCUMENT_SCAN',
       required: false,
+      data: { voiceGuidanceActive: true },
     },
     {
       type: 'IDENTITY_DOCUMENT_EID_SCAN',
       required: false,
+      data: { voiceGuidanceActive: true },
     },
     {
       type: 'LIVENESS_CHECK',
       required: false,
+      data: { voiceGuidanceActive: true },
     },
   ],
 } satisfies VerificationSession;