@trustchex/react-native-sdk 1.161.0

package/src/Shared/EIDReader/java/inputStream.ts

@@ -0,0 +1,186 @@
+export abstract class InputStream {
+  // Constants
+  private static readonly MAX_SKIP_BUFFER_SIZE = 2048;
+  private static readonly DEFAULT_BUFFER_SIZE = 16384;
+  private static readonly MAX_BUFFER_SIZE = Number.MAX_SAFE_INTEGER - 8;
+
+  protected static listeners: ((
+    totalBytesRead: number,
+    fileLength: number
+  ) => void)[] = [];
+
+  abstract read(): Promise<number>;
+
+  readBytes(b: Uint8Array): Promise<number> {
+    return this.readBytesWithOffset(b, 0, b.length);
+  }
+
+  async readBytesWithOffset(
+    b: Uint8Array,
+    off: number,
+    len: number
+  ): Promise<number> {
+    if (off < 0 || len < 0 || off + len > b.length) {
+      throw new RangeError('Invalid offset or length');
+    }
+    if (len === 0) {
+      return 0;
+    }
+
+    let c = await this.read();
+    if (c === -1) {
+      return -1;
+    }
+    b[off] = c;
+
+    InputStream.listeners.forEach((listener) => {
+      listener(0, len);
+    });
+
+    let i = 1;
+    try {
+      for (; i < len; i++) {
+        c = await this.read();
+        if (c === -1) {
+          break;
+        }
+        b[off + i] = c;
+
+        if (i % 1000 === 0) {
+          InputStream.listeners.forEach((listener) => {
+            listener(i, len);
+          });
+        }
+      }
+    } catch (e) {}
+    return i;
+  }
+
+  readAllBytes(): Promise<Uint8Array> {
+    return this.readNBytesAsArray(Number.MAX_SAFE_INTEGER);
+  }
+
+  async readNBytesAsArray(len: number): Promise<Uint8Array> {
+    if (len < 0) {
+      throw new Error('len < 0');
+    }
+
+    let bufs: Uint8Array[] = [];
+    let total = 0;
+    let remaining = len;
+    let n: number;
+    do {
+      let buf = new Uint8Array(
+        Math.min(remaining, InputStream.DEFAULT_BUFFER_SIZE)
+      );
+      let nread = 0;
+
+      // read to EOF which may read more or less than buffer size
+      while (
+        (n = await this.readBytesWithOffset(
+          buf,
+          nread,
+          Math.min(buf.length - nread, remaining)
+        )) > 0
+      ) {
+        nread += n;
+        remaining -= n;
+      }
+
+      if (nread > 0) {
+        if (InputStream.MAX_BUFFER_SIZE - total < nread) {
+          throw new Error('Required array size too large');
+        }
+        total += nread;
+        if (nread < buf.length) {
+          buf = buf.subarray(0, nread);
+        }
+        bufs.push(buf);
+      }
+    } while (n >= 0 && remaining > 0);
+
+    const result = new Uint8Array(total);
+    let offset = 0;
+    remaining = total;
+    for (let b of bufs) {
+      result.set(b, offset);
+      offset += b.length;
+      remaining -= b.length;
+    }
+
+    return result;
+  }
+
+  async readNBytes(b: Uint8Array, off: number, len: number): Promise<number> {
+    if (off < 0 || len < 0 || off + len > b.length) {
+      throw new RangeError('Invalid offset or length');
+    }
+
+    let n = 0;
+    while (n < len) {
+      const count = await this.readBytesWithOffset(b, off + n, len - n);
+      if (count < 0) {
+        break;
+      }
+      n += count;
+    }
+    return n;
+  }
+
+  async skip(n: number): Promise<number> {
+    let remaining = n;
+    let nr: number;
+
+    if (n <= 0) {
+      return 0;
+    }
+
+    const size = Math.min(InputStream.MAX_SKIP_BUFFER_SIZE, remaining);
+    const skipBuffer = new Uint8Array(size);
+    while (remaining > 0) {
+      nr = await this.readBytesWithOffset(
+        skipBuffer,
+        0,
+        Math.min(size, remaining)
+      );
+      if (nr < 0) {
+        break;
+      }
+      remaining -= nr;
+    }
+
+    return n - remaining;
+  }
+
+  async skipNBytes(n: number): Promise<void> {
+    while (n > 0) {
+      const skipped = await this.skip(n);
+      if (skipped < n) {
+        if ((await this.read()) === -1) {
+          throw new Error('skipNBytes: EOFException');
+        }
+        n -= skipped;
+      }
+    }
+  }
+
+  markSupported(): boolean {
+    return false;
+  }
+
+  mark(_readLimit: number) {}
+
+  available() {
+    return 0;
+  }
+
+  reset() {}
+
+  close() {}
+
+  static onRead(
+    listener: (totalBytesRead: number, fileLength: number) => void
+  ) {
+    InputStream.listeners.push(listener);
+  }
+}

package/src/Shared/EIDReader/java/inputStreamBuffer.ts

@@ -0,0 +1,200 @@
+import { FragmentBuffer } from '../fragmentBuffer';
+import { InputStream } from './inputStream';
+import { PositionInputStream } from './positionInputStream';
+
+export class InputStreamBuffer {
+  private carrier: PositionInputStream;
+  private buffer: FragmentBuffer;
+
+  constructor(inputStream: InputStream, length: number) {
+    this.carrier = new PositionInputStream(inputStream);
+    this.carrier.mark(length);
+    this.buffer = new FragmentBuffer(length);
+  }
+
+  updateFrom(other: InputStreamBuffer): void {
+    this.buffer.updateFrom(other.buffer);
+  }
+
+  getInputStream(): SubInputStream {
+    return new SubInputStream(this.carrier, this.buffer);
+  }
+
+  getPosition(): number {
+    return this.buffer.getPosition();
+  }
+
+  getBytesBuffered(): number {
+    return this.buffer.getBytesBuffered();
+  }
+
+  getLength(): number {
+    return this.buffer.getLength();
+  }
+}
+
+export class SubInputStream extends InputStream {
+  private position: number;
+  private markedPosition: number;
+  private buffer: FragmentBuffer;
+  private carrier: PositionInputStream;
+
+  constructor(carrier: PositionInputStream, buffer: FragmentBuffer) {
+    super();
+    this.position = 0;
+    this.markedPosition = -1;
+    this.carrier = carrier;
+    this.buffer = buffer;
+  }
+
+  getBuffer(): FragmentBuffer {
+    return this.buffer;
+  }
+
+  async read(): Promise<number> {
+    if (this.position >= this.buffer.getLength()) {
+      return -1;
+    } else if (this.buffer.isCoveredByFragment(this.position)) {
+      return this.buffer.getBuffer()[this.position++] & 0xff;
+    } else {
+      if (this.carrier.markSupported()) {
+        await this.syncCarrierPosition(this.position);
+      }
+      try {
+        const result = await this.carrier.read();
+        if (result < 0) {
+          return -1;
+        }
+        this.buffer.addFragment(this.position++, result);
+        return result;
+      } catch (ioe) {
+        throw ioe;
+      }
+    }
+  }
+
+  async readBytesWithOffset(
+    b: Uint8Array,
+    off: number,
+    len: number
+  ): Promise<number> {
+    if (b == null) {
+      throw new Error('Null buffer');
+    } else if (off < 0 || len < 0 || len > b.length - off) {
+      throw new RangeError('Invalid offset or length');
+    } else if (len === 0) {
+      return 0;
+    }
+
+    if (len > this.buffer.getLength() - this.position) {
+      len = this.buffer.getLength() - this.position;
+    }
+
+    if (this.position >= this.buffer.getLength()) {
+      return -1;
+    }
+
+    if (this.carrier.markSupported()) {
+      await this.syncCarrierPosition(this.position);
+    }
+
+    const fragment = this.buffer.getSmallestUnbufferedFragment(
+      this.position,
+      len
+    );
+    if (fragment.getLength() > 0) {
+      const alreadyBufferedPrefixLength = fragment.getOffset() - this.position;
+      const unbufferedPostfixLength = fragment.getLength();
+      b.set(
+        this.buffer
+          .getBuffer()
+          .subarray(this.position, this.position + alreadyBufferedPrefixLength),
+        off
+      );
+      this.position += alreadyBufferedPrefixLength;
+
+      if (this.carrier.markSupported()) {
+        await this.syncCarrierPosition(this.position);
+      }
+
+      const bytesReadFromCarrier = await this.carrier.readBytesWithOffset(
+        b,
+        off + alreadyBufferedPrefixLength,
+        unbufferedPostfixLength
+      );
+      this.buffer.addFragmentBytesWithOffset(
+        fragment.getOffset(),
+        b,
+        off + alreadyBufferedPrefixLength,
+        bytesReadFromCarrier
+      );
+      this.position += bytesReadFromCarrier;
+
+      return alreadyBufferedPrefixLength + bytesReadFromCarrier;
+    } else {
+      const length = Math.min(len, this.buffer.getLength() - this.position);
+      b.set(
+        this.buffer.getBuffer().subarray(this.position, this.position + length),
+        off
+      );
+      this.position += length;
+      return length;
+    }
+  }
+
+  async skip(n: number): Promise<number> {
+    const leftInBuffer = this.buffer.getBufferedLength(this.position);
+
+    if (n <= leftInBuffer) {
+      this.position += n;
+      return n;
+    } else {
+      this.position += leftInBuffer;
+      let skippedBytes = 0;
+      if (this.carrier.markSupported()) {
+        await this.syncCarrierPosition(this.position);
+        skippedBytes = await this.carrier.skip(n - leftInBuffer);
+        this.position += skippedBytes;
+      } else {
+        skippedBytes = await super.skip(n - leftInBuffer);
+      }
+      return leftInBuffer + skippedBytes;
+    }
+  }
+
+  available(): number {
+    return this.buffer.getBufferedLength(this.position);
+  }
+
+  close(): void {}
+
+  mark(_readLimit: number): void {
+    this.markedPosition = this.position;
+  }
+
+  reset(): void {
+    if (this.markedPosition < 0) {
+      throw new Error('Invalid reset, was mark() called?');
+    }
+    this.position = this.markedPosition;
+  }
+
+  markSupported(): boolean {
+    return true;
+  }
+
+  getPosition(): number {
+    return this.position;
+  }
+
+  private async syncCarrierPosition(position: number): Promise<void> {
+    if (position === this.carrier.getPosition()) {
+      return;
+    }
+    this.carrier.reset();
+    let bytesSkipped = 0;
+    while (bytesSkipped < position) {
+      bytesSkipped += await this.carrier.skip(position - bytesSkipped);
+    }
+  }
+}

package/src/Shared/EIDReader/java/objectInputStream.ts

@@ -0,0 +1,45 @@
+import { InputStream } from './inputStream';
+
+export class ObjectInputStream extends InputStream {
+  private buffer: Uint8Array;
+  private pos: number;
+
+  constructor(buffer: Uint8Array) {
+    super();
+    this.buffer = buffer;
+    this.pos = 0;
+  }
+
+  readObject() {
+    const jsonString = new TextDecoder().decode(this.buffer.slice(this.pos));
+    try {
+      const obj = JSON.parse(jsonString);
+      this.pos = this.buffer.length; // Move position to the end after reading
+      return obj;
+    } catch (e) {
+      throw new Error('Failed to deserialize object');
+    }
+  }
+
+  readUnshared() {
+    const jsonString = new TextDecoder().decode(this.buffer.slice(this.pos));
+    try {
+      const obj = JSON.parse(jsonString);
+      this.pos = this.buffer.length; // Move position to the end after reading
+      return JSON.parse(JSON.stringify(obj)); // Return a deep copy
+    } catch (e) {
+      throw new Error('Failed to deserialize object');
+    }
+  }
+
+  read(): Promise<number> {
+    if (this.pos >= this.buffer.length) {
+      return Promise.resolve(-1);
+    }
+    return Promise.resolve(this.buffer[this.pos++]);
+  }
+
+  close(): void {
+    // No resources to release, but this method is here for compatibility
+  }
+}

package/src/Shared/EIDReader/java/outputStream.ts

@@ -0,0 +1,76 @@
+export abstract class OutputStream {
+  /**
+   * Writes the specified byte to this output stream. The general
+   * contract for `write` is that one byte is written to the output stream.
+   * The byte to be written is the eight low-order bits of the argument `b`.
+   * The 24 high-order bits of `b` are ignored.
+   *
+   * @param b - the byte to write.
+   * @throws an error if an I/O error occurs. In particular,
+   * an error may be thrown if the output stream has been closed.
+   */
+  abstract write(b: number): void;
+
+  /**
+   * Writes `b.length` bytes from the specified byte array to this output stream.
+   * The general contract for `write(b)` is that it should have exactly the same
+   * effect as the call `write(b, 0, b.length)`.
+   *
+   * @param b - the data to write.
+   * @throws an error if an I/O error occurs.
+   */
+  writeBytes(b: Uint8Array): void {
+    this.writeBytesWithOffset(b, 0, b.length);
+  }
+
+  /**
+   * Writes `len` bytes from the specified byte array starting at offset `off`
+   * to this output stream. The general contract for `write(b, off, len)` is that
+   * some of the bytes in the array `b` are written to the output stream in order;
+   * element `b[off]` is the first byte written and `b[off+len-1]` is the last byte written
+   * by this operation.
+   *
+   * @param b - the data to write.
+   * @param off - the start offset in the data.
+   * @param len - the number of bytes to write.
+   * @throws an error if an I/O error occurs.
+   */
+  writeBytesWithOffset(b: Uint8Array, off: number, len: number): void {
+    if (off < 0 || len < 0 || off + len > b.length) {
+      throw new RangeError('Invalid offset or length');
+    }
+    for (let i = 0; i < len; i++) {
+      this.write(b[off + i]);
+    }
+  }
+
+  /**
+   * Flushes this output stream and forces any buffered output bytes
+   * to be written out. The general contract of `flush` is that calling it is
+   * an indication that, if any bytes previously written have been buffered by
+   * the implementation of the output stream, such bytes should immediately be
+   * written to their intended destination.
+   *
+   * If the intended destination of this stream is an abstraction provided by
+   * the underlying operating system, for example a file, then flushing the
+   * stream guarantees only that bytes previously written to the stream are
+   * passed to the operating system for writing; it does not guarantee that
+   * they are actually written to a physical device such as a disk drive.
+   *
+   * The `flush` method of `OutputStream` does nothing by default.
+   *
+   * @throws an error if an I/O error occurs.
+   */
+  flush(): void {}
+
+  /**
+   * Closes this output stream and releases any system resources associated with this stream.
+   * The general contract of `close` is that it closes the output stream.
+   * A closed stream cannot perform output operations and cannot be reopened.
+   *
+   * The `close` method of `OutputStream` does nothing by default.
+   *
+   * @throws an error if an I/O error occurs.
+   */
+  close(): void {}
+}

package/src/Shared/EIDReader/java/positionInputStream.ts

@@ -0,0 +1,64 @@
+import { InputStream } from './inputStream';
+import { Buffer } from 'buffer';
+
+export class PositionInputStream extends InputStream {
+  private carrier: InputStream;
+  private position: number;
+  private markedPosition: number;
+
+  private static MARK_NOT_SET = -1;
+
+  constructor(carrier: InputStream) {
+    super();
+    this.carrier = carrier;
+    this.position = 0;
+    this.markedPosition = PositionInputStream.MARK_NOT_SET;
+  }
+
+  async read() {
+    const buffer = Buffer.alloc(1);
+    const bytesRead = await this.carrier.readBytes(buffer);
+    if (bytesRead > 0) {
+      this.position++;
+    }
+    return buffer[0].valueOf();
+  }
+
+  async readWithOffset(dest: Buffer, offset: number, length: number) {
+    const buffer = Buffer.alloc(length);
+    const bytesRead = await this.carrier.readBytesWithOffset(buffer, 0, length);
+    buffer.copy(dest, offset, 0, bytesRead);
+    this.position += bytesRead;
+
+    return bytesRead;
+  }
+
+  async skip(n: number): Promise<number> {
+    const skippedBytes = await this.carrier.skip(n);
+    if (skippedBytes <= 0) {
+      console.debug(
+        `Carrier (${this.carrier.constructor.name})'s skip(${n}) only skipped ${skippedBytes}, position = ${this.position}`
+      );
+    }
+    this.position += skippedBytes;
+    return skippedBytes;
+  }
+
+  mark(readLimit: number) {
+    this.carrier.mark(readLimit);
+    this.markedPosition = this.position;
+  }
+
+  reset() {
+    this.carrier.reset();
+    this.position = this.markedPosition;
+  }
+
+  markSupported() {
+    return this.carrier.markSupported();
+  }
+
+  getPosition() {
+    return this.position;
+  }
+}

package/src/Shared/EIDReader/java/splittableInputStream.ts

@@ -0,0 +1,69 @@
+import { InputStream } from './inputStream';
+import { InputStreamBuffer, SubInputStream } from './inputStreamBuffer';
+
+export class SplittableInputStream {
+  private inputStreamBuffer: InputStreamBuffer;
+  private carrier: SubInputStream;
+
+  constructor(inputStream: InputStream, length: number) {
+    this.inputStreamBuffer = new InputStreamBuffer(inputStream, length);
+    this.carrier = this.inputStreamBuffer.getInputStream();
+  }
+
+  updateFrom(other: SplittableInputStream): void {
+    this.inputStreamBuffer.updateFrom(other.inputStreamBuffer);
+  }
+
+  async getInputStream(position: number): Promise<InputStream> {
+    try {
+      const inputStream = this.inputStreamBuffer.getInputStream();
+      let skippedBytes = 0;
+      while (skippedBytes < position) {
+        skippedBytes += await inputStream.skip(position - skippedBytes);
+      }
+      return inputStream;
+    } catch (error) {
+      throw new Error('Error getting input stream');
+    }
+  }
+
+  getPosition(): number {
+    return this.carrier.getPosition();
+  }
+
+  async read(): Promise<number> {
+    return this.carrier.read();
+  }
+
+  async skip(n: number): Promise<number> {
+    return await this.carrier.skip(n);
+  }
+
+  available(): number {
+    return this.carrier.available();
+  }
+
+  close(): void {
+    this.carrier.close();
+  }
+
+  mark(readLimit: number): void {
+    this.carrier.mark(readLimit);
+  }
+
+  reset(): void {
+    this.carrier.reset();
+  }
+
+  markSupported(): boolean {
+    return this.carrier.markSupported();
+  }
+
+  getLength(): number {
+    return this.inputStreamBuffer.getLength();
+  }
+
+  getBytesBuffered(): number {
+    return this.inputStreamBuffer.getBytesBuffered();
+  }
+}