@digitaldefiance/ecies-lib 4.4.13 → 4.4.14

package/src/test-mocks/mock-frontend-member.ts

@@ -1,276 +0,0 @@
-import {
-  EmailString,
-  MemberType,
-  SecureBuffer,
-  SecureString,
-} from '@digitaldefiance/ecies-lib';
-import { Wallet } from '@ethereumjs/wallet';
-import { faker } from '@faker-js/faker';
-
-import { ObjectId } from 'bson';
-import type { IFrontendMemberOperational } from '../interfaces/frontend-member-operational';
-import { SignatureUint8Array } from '../types';
-
-const hexToUint8Array = (hex: string): Uint8Array => {
-  const clean = hex.replace(/^0x/, '');
-  const bytes = new Uint8Array(clean.length / 2);
-  for (let i = 0; i < clean.length; i += 2) {
-    bytes[i / 2] = parseInt(clean.slice(i, i + 2), 16);
-  }
-  return bytes;
-};
-
-const createMockWallet = (): Wallet =>
-  ({
-    getPrivateKey: () =>
-      hexToUint8Array(faker.string.hexadecimal({ length: 64 })),
-    getPublicKey: () =>
-      hexToUint8Array(faker.string.hexadecimal({ length: 128 })),
-    getAddress: () => hexToUint8Array(faker.string.hexadecimal({ length: 40 })),
-    sign: () => hexToUint8Array(faker.string.hexadecimal({ length: 128 })),
-  } as any);
-
-export class MockFrontendMember
-  implements IFrontendMemberOperational<ObjectId>
-{
-  private _id: ObjectId;
-  private _type: MemberType;
-  private _name: string;
-  private _email: EmailString;
-  private _publicKey: Uint8Array;
-  private _creatorId: ObjectId;
-  private _dateCreated: Date;
-  private _dateUpdated: Date;
-  private _privateKey?: SecureBuffer;
-  private _wallet?: Wallet;
-  private _hasPrivateKey: boolean;
-
-  constructor(
-    data: Partial<{
-      id: ObjectId;
-      type: MemberType;
-      name: string;
-      email: EmailString;
-      publicKey: Uint8Array;
-      privateKey: SecureBuffer;
-      wallet: Wallet;
-      creatorId: ObjectId;
-      dateCreated: Date;
-      dateUpdated: Date;
-      hasPrivateKey: boolean;
-    }> = {},
-  ) {
-    this._id = data.id || new ObjectId();
-    this._type = data.type || faker.helpers.enumValue(MemberType);
-    this._name = data.name || faker.person.fullName();
-    this._email = data.email || new EmailString(faker.internet.email());
-    this._publicKey =
-      data.publicKey ||
-      hexToUint8Array(faker.string.hexadecimal({ length: 130 }));
-    this._creatorId = data.creatorId || this._id;
-    this._dateCreated = data.dateCreated || faker.date.past();
-    this._dateUpdated =
-      data.dateUpdated ||
-      faker.date.between({ from: this._dateCreated, to: new Date() });
-    this._privateKey = data.privateKey;
-    this._wallet =
-      data.wallet ||
-      (data.hasPrivateKey !== false ? createMockWallet() : undefined);
-    this._hasPrivateKey = data.hasPrivateKey ?? !!this._privateKey;
-  }
-
-  get id(): ObjectId {
-    return this._id;
-  }
-  get type(): MemberType {
-    return this._type;
-  }
-  get name(): string {
-    return this._name;
-  }
-  get email(): EmailString {
-    return this._email;
-  }
-  get publicKey(): Uint8Array {
-    return this._publicKey;
-  }
-  get creatorId(): ObjectId {
-    return this._creatorId;
-  }
-  get dateCreated(): Date {
-    return this._dateCreated;
-  }
-  get dateUpdated(): Date {
-    return this._dateUpdated;
-  }
-  get privateKey(): SecureBuffer | undefined {
-    return this._privateKey;
-  }
-  get wallet(): Wallet | undefined {
-    return this._wallet;
-  }
-  get hasPrivateKey(): boolean {
-    return this._hasPrivateKey;
-  }
-
-  unloadPrivateKey(): void {}
-
-  unloadWallet(): void {}
-
-  unloadWalletAndPrivateKey(): void {}
-
-  loadWallet(mnemonic: SecureString): void {}
-
-  loadPrivateKey(privateKey: SecureBuffer): void {}
-
-  sign(data: Uint8Array): SignatureUint8Array {
-    return hexToUint8Array(
-      faker.string.hexadecimal({ length: 128 }),
-    ) as SignatureUint8Array;
-  }
-
-  verify(signature: SignatureUint8Array, data: Uint8Array): boolean {
-    return true;
-  }
-
-  async encryptData(data: string | Uint8Array): Promise<Uint8Array> {
-    return hexToUint8Array(faker.string.hexadecimal({ length: 256 }));
-  }
-
-  async decryptData(encryptedData: Uint8Array): Promise<Uint8Array> {
-    const text = faker.lorem.paragraph();
-    return new TextEncoder().encode(text);
-  }
-
-  async *encryptDataStream(
-    source: AsyncIterable<Uint8Array> | ReadableStream<Uint8Array>,
-    options?: {
-      recipientPublicKey?: Uint8Array;
-      onProgress?: (progress: {
-        bytesProcessed: number;
-        chunksProcessed: number;
-      }) => void;
-      signal?: AbortSignal;
-    },
-  ): AsyncGenerator<
-    import('../interfaces/encrypted-chunk').IEncryptedChunk,
-    void,
-    unknown
-  > {
-    // Mock implementation
-    const chunks = [];
-    if ('getReader' in source) {
-      const reader = (source as ReadableStream<Uint8Array>).getReader();
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          chunks.push(value);
-        }
-      } finally {
-        reader.releaseLock();
-      }
-    } else {
-      for await (const chunk of source as AsyncIterable<Uint8Array>) {
-        chunks.push(chunk);
-      }
-    }
-    let index = 0;
-    for (const chunk of chunks) {
-      yield {
-        index: index++,
-        data: hexToUint8Array(
-          faker.string.hexadecimal({ length: chunk.length * 2 }),
-        ),
-        isLast: index === chunks.length,
-        metadata: {
-          originalSize: chunk.length,
-          encryptedSize: chunk.length * 2,
-          timestamp: Date.now(),
-        },
-      };
-    }
-  }
-
-  async *decryptDataStream(
-    source: AsyncIterable<Uint8Array> | ReadableStream<Uint8Array>,
-    options?: {
-      onProgress?: (progress: {
-        bytesProcessed: number;
-        chunksProcessed: number;
-      }) => void;
-      signal?: AbortSignal;
-    },
-  ): AsyncGenerator<Uint8Array, void, unknown> {
-    // Mock implementation
-    if ('getReader' in source) {
-      const reader = (source as ReadableStream<Uint8Array>).getReader();
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          yield value;
-        }
-      } finally {
-        reader.releaseLock();
-      }
-    } else {
-      for await (const chunk of source as AsyncIterable<Uint8Array>) {
-        yield chunk;
-      }
-    }
-  }
-
-  toJson(): string {
-    return JSON.stringify({
-      id: this._id.toString(),
-      type: this._type,
-      name: this._name,
-      email: this._email.toString(),
-      publicKey: btoa(String.fromCharCode(...this._publicKey)),
-      creatorId: this._creatorId.toString(),
-      dateCreated: this._dateCreated.toISOString(),
-      dateUpdated: this._dateUpdated.toISOString(),
-    });
-  }
-
-  dispose(): void {}
-
-  static create(
-    overrides: Partial<{
-      id: ObjectId;
-      type: MemberType;
-      name: string;
-      email: EmailString;
-      publicKey: Uint8Array;
-      privateKey: SecureBuffer;
-      wallet: Wallet;
-      creatorId: ObjectId;
-      dateCreated: Date;
-      dateUpdated: Date;
-      hasPrivateKey: boolean;
-    }> = {},
-  ): MockFrontendMember {
-    return new MockFrontendMember(overrides);
-  }
-
-  static createMultiple(count: number): MockFrontendMember[] {
-    return Array.from({ length: count }, () => this.create());
-  }
-
-  static createWithPrivateKey(): MockFrontendMember {
-    return new MockFrontendMember({
-      privateKey: new SecureBuffer(
-        hexToUint8Array(faker.string.hexadecimal({ length: 64 })),
-      ),
-      hasPrivateKey: true,
-    });
-  }
-
-  static createWithoutPrivateKey(): MockFrontendMember {
-    return new MockFrontendMember({
-      privateKey: undefined,
-      hasPrivateKey: false,
-    });
-  }
-}

package/src/types/deep-partial.ts

@@ -1,11 +0,0 @@
-export type DeepPartial<T> = {
-  [P in keyof T]?: T[P] extends (...args: any[]) => any
-    ? T[P]
-    : T[P] extends ReadonlyArray<infer U>
-    ? ReadonlyArray<DeepPartial<U>>
-    : T[P] extends Array<infer U>
-    ? Array<DeepPartial<U>>
-    : T[P] extends object
-    ? DeepPartial<T[P]>
-    : T[P];
-};

package/src/utils/encryption-type-utils.ts

@@ -1,76 +0,0 @@
-import {
-  EciesEncryptionType,
-  EciesEncryptionTypeEnum,
-  EciesEncryptionTypeEnumTypeMap,
-  EciesEncryptionTypeStringMap,
-} from '../enumerations/ecies-encryption-type';
-import { ECIESErrorTypeEnum } from '../enumerations/ecies-error-type';
-import { ECIESError } from '../errors/ecies';
-
-/**
- * Converts an encryption type (string or enum) to its string representation
- * @param type The encryption type to convert
- * @returns The string representation of the encryption type
- * @throws ECIESError if the type is invalid
- */
-export function encryptionTypeToString(
-  type: EciesEncryptionType | EciesEncryptionTypeEnum,
-): string {
-  // if enum
-  let resultType: EciesEncryptionType;
-  if (typeof type === 'number') {
-    resultType = EciesEncryptionTypeEnumTypeMap[type];
-    if (resultType === undefined) {
-      throw new ECIESError(ECIESErrorTypeEnum.InvalidEncryptionType);
-    }
-  } else {
-    resultType = type;
-  }
-  const result = EciesEncryptionTypeStringMap[resultType];
-  if (result === undefined) {
-    throw new ECIESError(ECIESErrorTypeEnum.InvalidEncryptionType);
-  }
-  return result;
-}
-
-/**
- * Converts an encryption type enum to its type representation
- * @param type The encryption type enum to convert
- * @returns The type representation of the encryption type
- * @throws ECIESError if the type is invalid
- */
-export function encryptionTypeEnumToType(
-  type: EciesEncryptionTypeEnum,
-): EciesEncryptionType {
-  const result = EciesEncryptionTypeEnumTypeMap[type];
-  if (result === undefined) {
-    throw new ECIESError(ECIESErrorTypeEnum.InvalidEncryptionType);
-  }
-  return result;
-}
-
-/**
- * Validates that a value is a valid EciesEncryptionTypeEnum
- * @param type The value to validate
- * @returns true if the value is a valid EciesEncryptionTypeEnum, false otherwise
- */
-export function validateEciesEncryptionTypeEnum(
-  type: EciesEncryptionTypeEnum,
-): boolean {
-  return Object.values(EciesEncryptionTypeEnum).includes(type);
-}
-
-/**
- * Ensures that a value is a valid EciesEncryptionTypeEnum
- * @param type The value to validate
- * @returns The validated EciesEncryptionTypeEnum
- * @throws ECIESError if the type is invalid
- */
-export function ensureEciesEncryptionTypeEnum(
-  type: EciesEncryptionTypeEnum,
-): EciesEncryptionTypeEnum {
-  if (!validateEciesEncryptionTypeEnum(type)) {
-    throw new ECIESError(ECIESErrorTypeEnum.InvalidEncryptionType);
-  }
-  return type;
-}

package/src/utils.ts

@@ -1,329 +0,0 @@
-import { EciesStringKey } from './enumerations/ecies-string-key';
-import { LengthEncodingType } from './enumerations/length-encoding-type';
-import { LengthErrorType } from './enumerations/length-error-type';
-import { LengthError } from './errors';
-import { EciesComponentId, getEciesI18nEngine } from './i18n-setup';
-
-/**
- * Encodes the length of the data in the buffer
- * @param buffer The buffer to encode
- * @returns The encoded buffer
- */
-export function lengthEncodeData(buffer: Uint8Array): Uint8Array {
-  const lengthType: LengthEncodingType = getLengthEncodingTypeForLength(
-    buffer.length,
-  );
-  const lengthTypeSize: number = getLengthForLengthType(lengthType);
-  const result = new Uint8Array(1 + lengthTypeSize + buffer.length);
-  const view = new DataView(result.buffer);
-
-  view.setUint8(0, lengthType);
-  switch (lengthType) {
-    case LengthEncodingType.UInt8:
-      view.setUint8(1, buffer.length);
-      break;
-    case LengthEncodingType.UInt16:
-      view.setUint16(1, buffer.length, false); // big-endian
-      break;
-    case LengthEncodingType.UInt32:
-      view.setUint32(1, buffer.length, false); // big-endian
-      break;
-    case LengthEncodingType.UInt64:
-      view.setBigUint64(1, BigInt(buffer.length), false); // big-endian
-      break;
-  }
-  result.set(buffer, 1 + lengthTypeSize);
-  return result;
-}
-
-export function decodeLengthEncodedData(buffer: Uint8Array): {
-  data: Uint8Array;
-  totalLength: number;
-} {
-  if (buffer.length < 1) {
-    throw new LengthError(LengthErrorType.LengthIsTooShort);
-  }
-
-  const view = new DataView(
-    buffer.buffer,
-    buffer.byteOffset,
-    buffer.byteLength,
-  );
-  const lengthType: LengthEncodingType = getLengthEncodingTypeFromValue(
-    view.getUint8(0),
-  );
-  const lengthTypeSize: number = getLengthForLengthType(lengthType);
-
-  if (buffer.length < 1 + lengthTypeSize) {
-    throw new LengthError(LengthErrorType.LengthIsTooShort);
-  }
-
-  let length: number | BigInt;
-  switch (lengthType) {
-    case LengthEncodingType.UInt8:
-      length = view.getUint8(1);
-      break;
-    case LengthEncodingType.UInt16:
-      length = view.getUint16(1, false); // big-endian
-      break;
-    case LengthEncodingType.UInt32:
-      length = view.getUint32(1, false); // big-endian
-      break;
-    case LengthEncodingType.UInt64:
-      length = view.getBigUint64(1, false); // big-endian
-      if (length.valueOf() > BigInt(Number.MAX_SAFE_INTEGER)) {
-        throw new LengthError(LengthErrorType.LengthIsTooLong);
-      }
-      break;
-    default:
-      throw new LengthError(LengthErrorType.LengthIsInvalidType);
-  }
-
-  const totalLength = 1 + lengthTypeSize + Number(length);
-  if (totalLength > buffer.length) {
-    throw new LengthError(LengthErrorType.LengthIsTooShort);
-  }
-  return {
-    data: buffer.subarray(1 + lengthTypeSize, totalLength),
-    totalLength,
-  };
-}
-
-export function uint8ArrayToBase64(uint8Array: Uint8Array): string {
-  let binaryString = '';
-  for (let i = 0; i < uint8Array.length; i++) {
-    binaryString += String.fromCharCode(uint8Array[i]);
-  }
-  return btoa(binaryString);
-}
-
-export function base64ToUint8Array(base64String: string): Uint8Array {
-  const binaryString = atob(base64String);
-  const len = binaryString.length;
-  const bytes = new Uint8Array(len);
-  for (let i = 0; i < len; i++) {
-    bytes[i] = binaryString.charCodeAt(i);
-  }
-  return bytes;
-}
-
-export function uint8ArrayToHex(uint8Array: Uint8Array): string {
-  return Array.from(uint8Array)
-    .map((byte) => byte.toString(16).padStart(2, '0'))
-    .join('');
-}
-
-export function hexToUint8Array(hexString: string): Uint8Array {
-  const engine = getEciesI18nEngine();
-  if (!hexString || typeof hexString !== 'string') {
-    throw new Error(
-      engine.translate(
-        EciesComponentId,
-        EciesStringKey.Error_Utils_InvalidHexString,
-      ),
-    );
-  }
-  if (hexString.length % 2 !== 0) {
-    throw new Error(
-      engine.translate(
-        EciesComponentId,
-        EciesStringKey.Error_Utils_HexStringMustHaveEvenLength,
-      ),
-    );
-  }
-  if (!/^[0-9a-fA-F]*$/.test(hexString)) {
-    throw new Error(
-      engine.translate(
-        EciesComponentId,
-        EciesStringKey.Error_Utils_HexStringContainsInvalidCharacters,
-      ),
-    );
-  }
-  const len = hexString.length;
-  const bytes = new Uint8Array(len / 2);
-  for (let i = 0; i < len; i += 2) {
-    bytes[i / 2] = parseInt(hexString.substring(i, i + 2), 16);
-  }
-  return bytes;
-}
-
-/**
- * Utility functions for browser ECIES implementation
- */
-
-/**
- * CRC16-CCITT implementation for data integrity checking
- * Uses CRC16-CCITT-FALSE variant (init 0xFFFF)
- */
-export function crc16(data: Uint8Array): Uint8Array {
-  let crc = 0xffff; // Initial value for CRC16-CCITT-FALSE
-  const polynomial = 0x1021; // CRC16-CCITT polynomial
-
-  for (let i = 0; i < data.length; i++) {
-    crc ^= data[i] << 8;
-    for (let j = 0; j < 8; j++) {
-      if (crc & 0x8000) {
-        crc = (crc << 1) ^ polynomial;
-      } else {
-        crc = crc << 1;
-      }
-      crc &= 0xffff; // Keep it 16-bit
-    }
-  }
-
-  const result = new Uint8Array(2);
-  result[0] = (crc >>> 8) & 0xff; // Big-endian
-  result[1] = crc & 0xff;
-  return result;
-}
-
-/**
- * Convert string to Uint8Array (UTF-8 encoding)
- */
-export function stringToUint8Array(str: string): Uint8Array {
-  return new TextEncoder().encode(str);
-}
-
-/**
- * Convert Uint8Array to string (UTF-8 decoding)
- */
-export function uint8ArrayToString(array: Uint8Array): string {
-  return new TextDecoder().decode(array);
-}
-
-/**
- * Secure random bytes generation
- */
-export function randomBytes(length: number): Uint8Array {
-  return crypto.getRandomValues(new Uint8Array(length));
-}
-
-/**
- * Compare two Uint8Arrays for equality
- */
-export function arraysEqual(a: Uint8Array, b: Uint8Array): boolean {
-  if (a.length !== b.length) return false;
-  let result = 0;
-  for (let i = 0; i < a.length; i++) {
-    result |= a[i] ^ b[i];
-  }
-  return result === 0;
-}
-
-/**
- * Concatenate multiple Uint8Arrays
- */
-export function concatUint8Arrays(...arrays: Uint8Array[]): Uint8Array {
-  const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
-  const result = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const array of arrays) {
-    result.set(array, offset);
-    offset += array.length;
-  }
-  return result;
-}
-
-/**
- * Get the length encoding type for a given length
- * @param length The length to evaluate
- * @returns The corresponding LengthEncodingType
- */
-export function getLengthEncodingTypeForLength<
-  TStringKey extends string,
-  TLanguage extends string,
->(length: number | BigInt): LengthEncodingType {
-  if (typeof length === 'number') {
-    if (length < 256) {
-      return LengthEncodingType.UInt8;
-    } else if (length < 65536) {
-      return LengthEncodingType.UInt16;
-    } else if (length < 4294967296) {
-      return LengthEncodingType.UInt32;
-    } else if (length < Number.MAX_SAFE_INTEGER) {
-      return LengthEncodingType.UInt64;
-    } else {
-      throw new LengthError(LengthErrorType.LengthIsTooLong);
-    }
-  } else if (typeof length === 'bigint') {
-    if (length < 256n) {
-      return LengthEncodingType.UInt8;
-    } else if (length < 65536n) {
-      return LengthEncodingType.UInt16;
-    } else if (length < 4294967296n) {
-      return LengthEncodingType.UInt32;
-    } else if (length < 18446744073709551616n) {
-      return LengthEncodingType.UInt64;
-    } else {
-      throw new LengthError(LengthErrorType.LengthIsTooLong);
-    }
-  } else {
-    throw new LengthError(LengthErrorType.LengthIsInvalidType);
-  }
-}
-
-/**
- * Get the length encoding type for a given value
- * @param value The value to evaluate
- * @returns The corresponding LengthEncodingType
- */
-export function getLengthEncodingTypeFromValue<
-  TStringKey extends string,
-  TLanguage extends string,
->(value: number): LengthEncodingType {
-  for (const length of Object.values(LengthEncodingType)) {
-    if (length === value) {
-      return length;
-    }
-  }
-  throw new LengthError(LengthErrorType.LengthIsInvalidType);
-}
-
-/**
- * Safely converts BigInt to Number, throwing if value exceeds safe integer range
- * @param value The BigInt value to convert
- * @returns The number value
- */
-export function safeBigIntToNumber(value: bigint): number {
-  const engine = getEciesI18nEngine();
-  if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
-    throw new Error(
-      engine.translate(
-        EciesComponentId,
-        EciesStringKey.Error_Utils_ValueExceedsSafeIntegerRange,
-      ),
-    );
-  }
-  if (value < BigInt(Number.MIN_SAFE_INTEGER)) {
-    throw new Error(
-      engine.translate(
-        EciesComponentId,
-        EciesStringKey.Error_Utils_ValueBelowSafeIntegerRange,
-      ),
-    );
-  }
-  return Number(value);
-}
-
-/**
- * Get the length in bytes for a given LengthEncodingType
- * @param type The LengthEncodingType to evaluate
- * @returns The length in bytes
- */
-export function getLengthForLengthType<
-  TStringKey extends string,
-  TLanguage extends string,
->(type: LengthEncodingType): number {
-  switch (type) {
-    case LengthEncodingType.UInt8:
-      return 1;
-    case LengthEncodingType.UInt16:
-      return 2;
-    case LengthEncodingType.UInt32:
-      return 4;
-    case LengthEncodingType.UInt64:
-      return 8;
-    default:
-      throw new LengthError(LengthErrorType.LengthIsInvalidType);
-  }
-}