@trustchex/react-native-sdk 1.161.0

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

@@ -0,0 +1,198 @@
+//
+// An almost complete implementation in JS of the `java.util.Random`
+// class from J2SE, designed to so far as possible produce the same
+// output sequences as the Java original when supplied with the same
+// seed.
+//
+
+const p2_16 = 0x0000000010000;
+const p2_24 = 0x0000001000000;
+const p2_27 = 0x0000008000000;
+const p2_31 = 0x0000080000000;
+const p2_32 = 0x0000100000000;
+const p2_48 = 0x1000000000000;
+const p2_53 = Math.pow(2, 53); // NB: exceeds Number.MAX_SAFE_INTEGER
+
+const m2_16 = 0xffff;
+
+//
+// multiplicative term for the PRNG
+//
+const [c2, c1, c0] = [0x0005, 0xdeec, 0xe66d];
+
+export class JavaRandom {
+  protected s2: number;
+  private s1: number;
+  private s0: number;
+  private nextNextGaussian?: number;
+  private haveNextNextGaussian = false;
+
+  constructor(seedVal?: number) {
+    // perform seed initialization
+    if (!seedVal) {
+      seedVal = Math.floor(Math.random() * p2_48);
+    }
+    this.checkIsPositiveInt(seedVal);
+    this.s0 = (seedVal & m2_16) ^ c0;
+    this.s1 = ((seedVal / p2_16) & m2_16) ^ c1;
+    this.s2 = ((seedVal / p2_32) & m2_16) ^ c2;
+  }
+
+  // 53-bit safe version of
+  // seed = (seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1)
+  //
+  _next = () => {
+    let carry = 0xb;
+
+    let r0 = this.s0 * c0 + carry;
+    carry = r0 >>> 16;
+    r0 &= m2_16;
+
+    let r1 = this.s1 * c0 + this.s0 * c1 + carry;
+    carry = r1 >>> 16;
+    r1 &= m2_16;
+
+    let r2 = this.s2 * c0 + this.s1 * c1 + this.s0 * c2 + carry;
+    r2 &= m2_16;
+
+    [this.s2, this.s1, this.s0] = [r2, r1, r0];
+
+    return this.s2 * p2_16 + this.s1;
+  };
+
+  private next_signed(bits: number) {
+    return this._next() >> (32 - bits);
+  }
+
+  private next(bits: number) {
+    return this._next() >>> (32 - bits);
+  }
+
+  private checkIsNumber(n: any) {
+    if (typeof n !== 'number') {
+      throw TypeError();
+    }
+  }
+
+  private checkIsPositiveInt(n: number, r = Number.MAX_SAFE_INTEGER) {
+    this.checkIsNumber(n);
+    if (n < 0 || n > r) {
+      throw RangeError();
+    }
+  }
+
+  nextInt(bound?: number) {
+    if (bound === undefined) {
+      return this.next_signed(32);
+    }
+
+    this.checkIsPositiveInt(bound, 0x7fffffff);
+
+    // special case if bound is a power of two
+    if ((bound & -bound) === bound) {
+      let r = this.next(31) / p2_31;
+      return ~~(bound * r);
+    }
+
+    var bits, val;
+    do {
+      bits = this.next(31);
+      val = bits % bound;
+    } while (bits - val + (bound - 1) < 0);
+    return val;
+  }
+
+  nextLong() {
+    if (typeof BigInt !== 'function') {
+      throw Error('BigInt unsupported');
+    }
+    let msb = BigInt(this.next_signed(32));
+    let lsb = BigInt(this.next_signed(32));
+    const p2_32n = BigInt(p2_32);
+    return msb * p2_32n + lsb;
+  }
+
+  nextBoolean() {
+    return this.next(1) !== 0;
+  }
+
+  nextFloat() {
+    return this.next(24) / p2_24;
+  }
+
+  nextDouble() {
+    return (p2_27 * this.next(26) + this.next(27)) / p2_53;
+  }
+
+  nextBytes(bytes: number[]) {
+    if (!Array.isArray(bytes)) {
+      throw TypeError;
+    }
+
+    for (let i = 0; i < bytes.length; ) {
+      for (
+        let rnd = this.nextInt(), n = Math.min(bytes.length - i, 4);
+        n-- > 0;
+        rnd >>= 8
+      ) {
+        // double shift extends bit sign in bit 7
+        bytes[i++] = (rnd << 24) >> 24;
+      }
+    }
+  }
+
+  nextGaussian() {
+    if (this.haveNextNextGaussian) {
+      this.haveNextNextGaussian = false;
+      return this.nextNextGaussian;
+    } else {
+      let v1, v2, s;
+      do {
+        v1 = 2 * this.nextDouble() - 1.0;
+        v2 = 2 * this.nextDouble() - 1.0;
+        s = v1 * v1 + v2 * v2;
+      } while (s >= 1 || s === 0);
+      let multiplier = Math.sqrt((-2 * Math.log(s)) / s);
+      this.nextNextGaussian = v2 * multiplier;
+      this.haveNextNextGaussian = true;
+      return v1 * multiplier;
+    }
+  }
+
+  //
+  // stream functions replaced with JS generators
+  //
+  checkStreamSize(streamSize?: number) {
+    if (streamSize === undefined) {
+      return undefined;
+    }
+
+    this.checkIsPositiveInt(streamSize);
+
+    return streamSize;
+  }
+
+  *ints(streamSize?: number) {
+    streamSize = this.checkStreamSize(streamSize);
+    let forever = streamSize === undefined;
+    while (forever || (streamSize && streamSize-- > 0)) {
+      yield this.nextInt();
+    }
+  }
+
+  *longs(streamSize?: number) {
+    streamSize = this.checkStreamSize(streamSize);
+    let forever = streamSize === undefined;
+    while (forever || (streamSize && streamSize-- > 0)) {
+      yield this.nextLong();
+    }
+  }
+
+  *doubles(streamSize?: number) {
+    streamSize = this.checkStreamSize(streamSize);
+    let forever = streamSize === undefined;
+    while (forever || (streamSize && streamSize-- > 0)) {
+      yield this.nextDouble();
+    }
+  }
+}

package/src/Shared/EIDReader/wrappedAPDUEvent.ts

@@ -0,0 +1,36 @@
+import { APDUEvent } from './smartcards/apduEvent';
+import { CommandAPDU } from './smartcards/commandAPDU';
+import { ResponseAPDU } from './smartcards/responseAPDU';
+
+export class WrappedAPDUEvent extends APDUEvent {
+  private plainTextCommandAPDU: CommandAPDU;
+  private plainTextResponseAPDU: ResponseAPDU;
+
+  constructor(
+    source: Object,
+    type: string,
+    sequenceNumber: number,
+    plainTextCommandAPDU: CommandAPDU,
+    plainTextResponseAPDU: ResponseAPDU,
+    wrappedCommandAPDU: CommandAPDU,
+    wrappedResponseAPDU: ResponseAPDU
+  ) {
+    super(
+      source,
+      type,
+      sequenceNumber,
+      wrappedCommandAPDU,
+      wrappedResponseAPDU
+    );
+    this.plainTextCommandAPDU = plainTextCommandAPDU;
+    this.plainTextResponseAPDU = plainTextResponseAPDU;
+  }
+
+  getPlainTextCommandAPDU(): CommandAPDU {
+    return this.plainTextCommandAPDU;
+  }
+
+  getPlainTextResponseAPDU(): ResponseAPDU {
+    return this.plainTextResponseAPDU;
+  }
+}

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

@@ -0,0 +1,34 @@
+import type { Frame } from 'react-native-vision-camera';
+
+const getAverageBrightness = (frame: Frame): number => {
+  'worklet';
+  const buffer = frame.toArrayBuffer();
+  const data = new Uint8Array(buffer);
+  const width = frame.width;
+  const height = frame.height;
+  const centerX = Math.floor(width / 2);
+  const centerY = Math.floor(height / 2);
+  const halfSizeX = Math.floor(width / 2);
+  const halfSizeY = Math.floor(height / 2);
+  let luminanceSum = 0;
+  let pixelCount = 0;
+
+  for (let y = centerY - halfSizeY; y < centerY + halfSizeY; y++) {
+    for (let x = centerX - halfSizeX; x < centerX + halfSizeX; x++) {
+      const index = y * width + x;
+      if (data[index] !== undefined) {
+        luminanceSum += data[index];
+        pixelCount++;
+      }
+    }
+  }
+
+  return luminanceSum / pixelCount;
+};
+
+const isFrameBright = (frame: Frame): boolean => {
+  'worklet';
+  return getAverageBrightness(frame) > 80;
+};
+
+export { isFrameBright, getAverageBrightness };

package/src/Shared/Libs/contains.ts

@@ -0,0 +1,59 @@
+export interface Rect {
+  minX: number;
+  minY: number;
+  width: number;
+  height: number;
+}
+
+interface Contains {
+  outside: Rect;
+  inside: Rect;
+}
+
+export function contains({ outside, inside }: Contains) {
+  const outsideMaxX = outside.minX + outside.width;
+  const insideMaxX = inside.minX + inside.width;
+
+  const outsideMaxY = outside.minY + outside.height;
+  const insideMaxY = inside.minY + inside.height;
+
+  if (inside.minX < outside.minX) {
+    return false;
+  }
+  if (insideMaxX > outsideMaxX) {
+    return false;
+  }
+  if (inside.minY < outside.minY) {
+    return false;
+  }
+  if (insideMaxY > outsideMaxY) {
+    return false;
+  }
+
+  return true;
+}
+
+export function contains2({ outside, inside }: Contains) {
+  const outsideMaxX = outside.minX + outside.width;
+  const insideMaxX = inside.minX + inside.width;
+
+  const outsideMaxY = outside.minY + outside.height;
+  const insideMaxY = inside.minY + inside.height;
+
+  const xIntersect = Math.max(
+    0,
+    Math.min(insideMaxX, outsideMaxX) - Math.max(inside.minX, outside.minX)
+  );
+  const yIntersect = Math.max(
+    0,
+    Math.min(insideMaxY, outsideMaxY) - Math.max(inside.minY, outside.minY)
+  );
+  const intersectArea = xIntersect * yIntersect;
+
+  const insideArea = inside.width * inside.height;
+  const outsideArea = outside.width * outside.height;
+
+  const unionArea = insideArea + outsideArea - intersectArea;
+
+  return unionArea === outsideArea;
+}

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

@@ -0,0 +1,47 @@
+import 'react-native-get-random-values';
+import { Buffer } from 'buffer';
+import { gcm } from '@noble/ciphers/aes';
+import { randomBytes } from '@noble/ciphers/webcrypto';
+import { secp256k1 } from '@noble/curves/secp256k1';
+import httpClient from './http-client';
+
+const getSessionKey = async (apiUrl: string, sessionId: string) => {
+  const clientPrivateKey = secp256k1.utils.randomPrivateKey();
+  const clientPublicKey = secp256k1.getPublicKey(clientPrivateKey);
+  const serverResponse = await httpClient.post<
+    { serverPublicKey: String },
+    { clientPublicKey: String }
+  >(`${apiUrl}/verification-sessions/${sessionId}/auth`, {
+    clientPublicKey: Buffer.from(clientPublicKey).toString('hex'),
+  });
+  const sharedKey = secp256k1.getSharedSecret(
+    clientPrivateKey,
+    Buffer.from(serverResponse.serverPublicKey, 'hex').toString('hex')
+  );
+  const sessionKey = (
+    Buffer.from(new Date().getUTCDate().toString(), 'utf-8').toString('hex') +
+    Buffer.from(sharedKey).toString('hex')
+  ).substring(0, 32);
+
+  return sessionKey;
+};
+
+const encryptWithAes = (data: string, key: string) => {
+  const nonce = randomBytes(32);
+  const dataBytes = Buffer.from(data, 'utf-8');
+  const aes = gcm(Buffer.from(key, 'hex'), nonce);
+  const ciphertext = aes.encrypt(dataBytes);
+  return {
+    encryptedData: Buffer.from(ciphertext).toString('hex'),
+    nonce: Buffer.from(nonce).toString('hex'),
+  };
+};
+
+const decryptWithAes = (data: string, key: string, nonce: string) => {
+  const dataBytes = Buffer.from(data, 'hex');
+  const aes = gcm(Buffer.from(key, 'hex'), Buffer.from(nonce, 'hex'));
+  const decrypted = aes.decrypt(dataBytes);
+  return Buffer.from(decrypted).toString('utf-8');
+};
+
+export { getSessionKey, encryptWithAes, decryptWithAes };

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

@@ -0,0 +1,38 @@
+/**
+ * Leading edge debounce - executes immediately on first call, then ignores subsequent calls
+ * until the wait period has passed without any calls
+ * @param func Function to debounce
+ * @param wait Wait time in milliseconds
+ * @returns Debounced function that executes immediately on first call
+ */
+const debounce = <T extends (...args: any[]) => any>(
+  func: T,
+  wait: number
+): ((...args: Parameters<T>) => void) => {
+  let timeout: NodeJS.Timeout | null = null;
+  let lastCallTime = 0;
+
+  return (...args: Parameters<T>): void => {
+    const now = Date.now();
+
+    // If this is the first call or enough time has passed since last execution
+    if (!timeout || now - lastCallTime >= wait) {
+      // Execute immediately
+      func(...args);
+      lastCallTime = now;
+
+      // Clear any existing timeout
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+
+      // Set new timeout to reset the debounce state
+      timeout = setTimeout(() => {
+        timeout = null;
+      }, wait);
+    }
+    // Subsequent calls within the wait period are ignored
+  };
+};
+
+export default debounce;

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

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

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

@@ -0,0 +1,82 @@
+import type { VerificationSession } from '../Types/verificationSession';
+
+type SimulatedDataType =
+  | 'VERIFICATION_SESSIONS'
+  | 'SEND_VERIFICATION_CODE'
+  | 'GET_SESSION'
+  | 'GET_VERIFIED_SESSION';
+
+const demoSession = {
+  id: 'demo-verification-id',
+  identificationId: 'demo-identification-id',
+  sendOTP: true,
+  locale: 'en',
+  branding: {
+    primaryColor: '#000000',
+    secondaryColor: '#000000',
+    tertiaryColor: '#000000',
+  },
+  workflowSteps: [
+    {
+      type: 'CONTRACT_ACCEPTANCE',
+      required: false,
+      data: {
+        contracts: {
+          en: {
+            id: '1',
+            name: 'Terms of Service',
+            url: `https://app.trustchex.com/app/mobile/tcpp/demo/en.html`,
+          },
+          tr: {
+            id: '2',
+            name: 'Hizmet Şartları',
+            url: `https://app.trustchex.com/app/mobile/tcpp/demo/tr.html`,
+          },
+        },
+      },
+    },
+    {
+      type: 'IDENTITY_DOCUMENT_SCAN',
+      required: false,
+    },
+    {
+      type: 'IDENTITY_DOCUMENT_EID_SCAN',
+      required: false,
+    },
+    {
+      type: 'LIVENESS_CHECK',
+      required: false,
+    },
+  ],
+} satisfies VerificationSession;
+
+const isDemoSession = (email: string) => email === 'demo@trustchex.com';
+
+const getSimulatedDemoData = <TResponse, TBody>(
+  dataType: SimulatedDataType,
+  body?: TBody
+) => {
+  switch (dataType) {
+    case 'VERIFICATION_SESSIONS':
+      return [demoSession] satisfies VerificationSession[] as TResponse;
+
+    case 'GET_SESSION':
+      return demoSession satisfies VerificationSession as TResponse;
+
+    case 'SEND_VERIFICATION_CODE':
+      return {} as TResponse;
+
+    case 'GET_VERIFIED_SESSION':
+      if (
+        !body ||
+        !(body && typeof body === 'object' && 'code' in body) ||
+        body.code !== '877829'
+      ) {
+        throw new Error('Invalid verification code');
+      }
+
+      return demoSession satisfies VerificationSession as TResponse;
+  }
+};
+
+export { getSimulatedDemoData, isDemoSession };

package/src/Shared/Libs/http-client.ts

@@ -0,0 +1,148 @@
+interface ErrorResponse {
+  message: string;
+}
+
+export class HttpClientError extends Error {
+  constructor(message?: string) {
+    super(message);
+  }
+}
+
+export class UnauthorizedError extends HttpClientError {
+  constructor(message?: string) {
+    super(message ?? 'Unauthorized');
+  }
+}
+
+export class ForbiddenError extends HttpClientError {
+  constructor(message?: string) {
+    super(message ?? 'Forbidden');
+  }
+}
+
+export class NotFoundError extends HttpClientError {
+  constructor(message?: string) {
+    super(message ?? 'Not found');
+  }
+}
+
+export class BadRequestError extends HttpClientError {
+  constructor(message?: string) {
+    super(message ?? 'Bad request');
+  }
+}
+
+export class InternalServerError extends HttpClientError {
+  constructor(message?: string) {
+    super(message ?? 'Internal server error');
+  }
+}
+
+const request = async <TResponse, TBody>(
+  httpMethod: 'GET' | 'POST' | 'PUT' | 'DELETE',
+  url: string,
+  body?: TBody,
+  simulatedResponse?: TResponse
+) => {
+  if (simulatedResponse) {
+    return new Promise<TResponse>((resolve) => {
+      setTimeout(() => {
+        resolve(simulatedResponse);
+      }, 1000);
+    });
+  }
+
+  const response = await fetch(url, {
+    method: httpMethod,
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+
+  let responseJson = null;
+
+  try {
+    responseJson = await response.json();
+  } catch (error) {
+    // throw new Error("Invalid response");
+  }
+
+  if (response && !response.ok && responseJson) {
+    const message = (responseJson as unknown as ErrorResponse).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);
+    }
+
+    if (response.status >= 500) {
+      throw new InternalServerError(message);
+    }
+
+    if (response.status >= 400) {
+      throw new BadRequestError(message);
+    }
+
+    throw new Error(message);
+  }
+
+  return responseJson as Promise<TResponse>;
+};
+
+const get = <TResponse>(url: string, simulatedResponse?: TResponse) => {
+  return request<TResponse, undefined>(
+    'GET',
+    url,
+    undefined,
+    simulatedResponse
+  );
+};
+
+const post = <TResponse, TBody>(
+  url: string,
+  body?: TBody,
+  simulatedResponse?: TResponse
+) => {
+  return request<TResponse, TBody>('POST', url, body, simulatedResponse);
+};
+
+const put = <TResponse, TBody>(
+  url: string,
+  body?: any,
+  simulatedResponse?: TResponse
+) => {
+  return request<TResponse, TBody>('PUT', url, body, simulatedResponse);
+};
+
+const del = <TResponse>(url: string, simulatedResponse?: TResponse) => {
+  return request<TResponse, undefined>(
+    'DELETE',
+    url,
+    undefined,
+    simulatedResponse
+  );
+};
+
+const upload = async (url: string, file: File) => {
+  const formData = new FormData();
+  formData.append('file', file);
+
+  const response = await fetch(url, {
+    method: 'POST',
+    body: formData,
+  });
+
+  if (!response.ok) {
+    throw new Error('Upload failed');
+  }
+};
+
+export default { get, post, put, del, upload };