@digitaldefiance/ecies-lib 1.1.23 → 1.1.24

package/src/services/ecies/multi-recipient.ts

@@ -0,0 +1,394 @@
+import { IECIESConstants } from '../../interfaces/ecies-consts';
+import { Constants } from '../../constants';
+import { IECIESConfig } from '../../interfaces/ecies-config';
+import { concatUint8Arrays } from '../../utils';
+import { AESGCMService } from '../aes-gcm';
+import { EciesCryptoCore } from './crypto-core';
+import {
+  IMultiEncryptedMessage,
+  IMultiEncryptedParsedHeader,
+  IMultiRecipient,
+} from './interfaces';
+import { EciesComponentId, getEciesI18nEngine } from '../../i18n-setup';
+import { EciesStringKey } from '../../enumerations';
+
+/**
+ * Browser-compatible multi-recipient ECIES encryption/decryption
+ */
+export class EciesMultiRecipient {
+  protected readonly cryptoCore: EciesCryptoCore;
+  protected readonly eciesConsts: IECIESConstants;
+
+  constructor(config: IECIESConfig, eciesParams: IECIESConstants = Constants.ECIES) {
+    this.cryptoCore = new EciesCryptoCore(config, eciesParams);
+    this.eciesConsts = eciesParams;
+  }
+
+  /**
+   * Get the header size for multi-recipient encryption
+   */
+  public getHeaderSize(recipientCount: number): number {
+    return (
+      this.eciesConsts.MULTIPLE.DATA_LENGTH_SIZE +
+      this.eciesConsts.MULTIPLE.RECIPIENT_COUNT_SIZE +
+      recipientCount * this.eciesConsts.MULTIPLE.RECIPIENT_ID_SIZE +
+      recipientCount * this.eciesConsts.MULTIPLE.ENCRYPTED_KEY_SIZE
+    );
+  }
+
+  /**
+   * Encrypt a message symmetric key with a public key
+   * @param receiverPublicKey The public key of the receiver
+   * @param messageSymmetricKey The message to encrypt
+   * @returns The encrypted message
+   */
+  public async encryptKey(
+    receiverPublicKey: Uint8Array,
+    messageSymmetricKey: Uint8Array,
+  ): Promise<Uint8Array> {
+    const ephemeralKeyPair = await this.cryptoCore.generateEphemeralKeyPair();
+    const sharedSecret = await this.cryptoCore.computeSharedSecret(
+      ephemeralKeyPair.privateKey,
+      receiverPublicKey,
+    );
+
+    const symKey = sharedSecret.slice(0, this.eciesConsts.SYMMETRIC.KEY_SIZE);
+
+    const encryptResult = await AESGCMService.encrypt(
+      messageSymmetricKey,
+      symKey,
+      true,
+      this.eciesConsts
+    );
+    const { encrypted, iv } = encryptResult;
+    const authTag = encryptResult.tag;
+
+    if (!authTag) {
+      const engine = getEciesI18nEngine();
+      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_ECIESError_AuthenticationTagIsRequiredForKeyEncryption));
+    }
+
+    return concatUint8Arrays(
+      new Uint8Array(ephemeralKeyPair.publicKey),
+      iv,
+      authTag,
+      encrypted,
+    );
+  }
+
+  /**
+   * Decrypts symmetric key encrypted with ECIES
+   * @param privateKey The private key to decrypt the data
+   * @param encryptedKey The data to decrypt
+   * @returns The decrypted data buffer
+   */
+  public async decryptKey(
+    privateKey: Uint8Array,
+    encryptedKey: Uint8Array,
+  ): Promise<Uint8Array> {
+    if (encryptedKey.length !== this.eciesConsts.MULTIPLE.ENCRYPTED_KEY_SIZE) {
+      const engine = getEciesI18nEngine();
+      throw new Error(engine.translate(
+        EciesComponentId,
+        EciesStringKey.Error_ECIESError_InvalidEncryptedKeyLengthTemplate, {keySize: this.eciesConsts.MULTIPLE.ENCRYPTED_KEY_SIZE, encryptedKeyLength: encryptedKey.length}));
+    }
+
+    const ephemeralPublicKey = encryptedKey.slice(0, this.eciesConsts.PUBLIC_KEY_LENGTH);
+    const iv = encryptedKey.slice(
+      this.eciesConsts.PUBLIC_KEY_LENGTH,
+      this.eciesConsts.PUBLIC_KEY_LENGTH + this.eciesConsts.IV_SIZE,
+    );
+    const authTag = encryptedKey.slice(
+      this.eciesConsts.PUBLIC_KEY_LENGTH + this.eciesConsts.IV_SIZE,
+      this.eciesConsts.PUBLIC_KEY_LENGTH + this.eciesConsts.IV_SIZE + this.eciesConsts.AUTH_TAG_SIZE,
+    );
+    const encrypted = encryptedKey.slice(
+      this.eciesConsts.PUBLIC_KEY_LENGTH + this.eciesConsts.IV_SIZE + this.eciesConsts.AUTH_TAG_SIZE,
+    );
+
+    const sharedSecret = await this.cryptoCore.computeSharedSecret(
+      privateKey,
+      ephemeralPublicKey,
+    );
+    const symKey = sharedSecret.slice(0, this.eciesConsts.SYMMETRIC.KEY_SIZE);
+
+    const encryptedWithTag = AESGCMService.combineEncryptedDataAndTag(
+      encrypted,
+      authTag,
+    );
+
+    try {
+      const decrypted = await AESGCMService.decrypt(
+        iv,
+        encryptedWithTag,
+        symKey,
+        true,
+        this.eciesConsts
+      );
+      if (decrypted.length !== this.eciesConsts.SYMMETRIC.KEY_SIZE) {
+        const engine = getEciesI18nEngine();
+        throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_ECIESError_InvalidDataLength));
+      }
+      return decrypted;
+    } catch (error) {
+      console.error('Failed to decrypt key:', error);
+      const engine = getEciesI18nEngine();
+      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_ECIESError_FailedToDecryptKey));
+    }
+  }
+
+  /**
+   * Encrypt a message for multiple recipients
+   */
+  public async encryptMultiple(
+    recipients: IMultiRecipient[],
+    message: Uint8Array,
+    preamble: Uint8Array = new Uint8Array(0),
+  ): Promise<IMultiEncryptedMessage> {
+    const engine = getEciesI18nEngine();
+    if (recipients.length > this.eciesConsts.MULTIPLE.MAX_RECIPIENTS) {
+      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_ECIESError_TooManyRecipientsTemplate, { recipientsCount: recipients.length }));
+    }
+
+    if (message.length > this.eciesConsts.MAX_RAW_DATA_SIZE) {
+      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_ECIESError_MessageTooLargeTemplate, { length: message.length }));
+    }
+
+    // Generate symmetric key
+    const symmetricKey = crypto.getRandomValues(
+      new Uint8Array(this.eciesConsts.SYMMETRIC.KEY_SIZE),
+    );
+
+    // Encrypt message with symmetric key
+    const encryptResult = await AESGCMService.encrypt(
+      message,
+      symmetricKey,
+      true,
+      this.eciesConsts
+    );
+    const { encrypted, iv } = encryptResult;
+    const authTag = encryptResult.tag;
+
+    if (!authTag) {
+      const engine = getEciesI18nEngine();
+      throw new Error(
+        engine.translate(EciesComponentId, EciesStringKey.Error_ECIESError_AuthenticationTagIsRequiredForMultiRecipientECIESEncryption),
+      );
+    }
+
+    // Create stored message: preamble + iv + authTag + encrypted
+    const storedMessage = concatUint8Arrays(preamble, iv, authTag, encrypted);
+
+    // Encrypt symmetric key for each recipient
+    const recipientIds: Uint8Array[] = [];
+    const recipientKeys: Uint8Array[] = [];
+
+    for (const recipient of recipients) {
+      const encryptedKey = await this.encryptKey(
+        recipient.publicKey,
+        symmetricKey,
+      );
+
+      recipientIds.push(recipient.id);
+      recipientKeys.push(encryptedKey);
+    }
+
+    const headerSize = this.getHeaderSize(recipients.length);
+
+    return {
+      dataLength: message.length,
+      recipientCount: recipients.length,
+      recipientIds,
+      recipientKeys,
+      encryptedMessage: storedMessage,
+      headerSize,
+    };
+  }
+
+  /**
+   * Decrypt a multi-recipient message for a specific recipient
+   */
+  public async decryptMultipleForRecipient(
+    encryptedData: IMultiEncryptedMessage,
+    recipientId: Uint8Array,
+    privateKey: Uint8Array,
+  ): Promise<Uint8Array> {
+    // Find recipient's encrypted key
+    const recipientIndex = encryptedData.recipientIds.findIndex((id) =>
+      this.arraysEqual(id, recipientId),
+    );
+
+    if (recipientIndex === -1) {
+      const engine = getEciesI18nEngine();
+      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_ECIESError_RecipientNotFound));
+    }
+
+    const encryptedKey = encryptedData.recipientKeys[recipientIndex];
+
+    // Decrypt the symmetric key
+    const symmetricKey = await this.decryptKey(privateKey, encryptedKey);
+
+    // Extract components from encrypted message
+    let offset = 0;
+    const iv = encryptedData.encryptedMessage.slice(
+      offset,
+      offset + this.eciesConsts.IV_SIZE,
+    );
+    offset += this.eciesConsts.IV_SIZE;
+
+    const authTag = encryptedData.encryptedMessage.slice(
+      offset,
+      offset + this.eciesConsts.AUTH_TAG_SIZE,
+    );
+    offset += this.eciesConsts.AUTH_TAG_SIZE;
+
+    const encrypted = encryptedData.encryptedMessage.slice(offset);
+
+    // AES-GCM provides authentication via auth tag (no separate CRC needed)
+
+    // Decrypt with symmetric key
+    const encryptedWithTag = AESGCMService.combineEncryptedDataAndTag(
+      encrypted,
+      authTag,
+    );
+
+    const decrypted = await AESGCMService.decrypt(
+      iv,
+      encryptedWithTag,
+      symmetricKey,
+      true,
+      this.eciesConsts
+    );
+
+    // Verify length
+    if (decrypted.length !== encryptedData.dataLength) {
+      const engine = getEciesI18nEngine();
+      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_ECIESError_DecryptedDataLengthMismatch));
+    }
+
+    return decrypted;
+  }
+
+  /**
+   * Build header for multi-recipient message
+   */
+  public buildHeader(data: IMultiEncryptedMessage): Uint8Array {
+    if (data.recipientIds.length !== data.recipientKeys.length) {
+      const engine = getEciesI18nEngine();
+      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_ECIESError_RecipientCountMismatch));
+    }
+
+    if (data.dataLength < 0 || data.dataLength > this.eciesConsts.MAX_RAW_DATA_SIZE) {
+      const engine = getEciesI18nEngine();
+      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_ECIESError_InvalidDataLength));
+    }
+
+    // Data length (8 bytes)
+    const dataLengthUint8Array = new Uint8Array(8);
+    new DataView(dataLengthUint8Array.buffer).setBigUint64(
+      0,
+      BigInt(data.dataLength),
+      false,
+    );
+
+    // Recipient count (2 bytes)
+    const recipientCountUint8Array = new Uint8Array(2);
+    new DataView(recipientCountUint8Array.buffer).setUint16(
+      0,
+      data.recipientIds.length,
+      false,
+    );
+
+    // Recipient IDs
+    const recipientIdsUint8Array = concatUint8Arrays(...data.recipientIds);
+
+    // Encrypted keys
+    const encryptedKeysUint8Array = concatUint8Arrays(...data.recipientKeys);
+
+    return concatUint8Arrays(
+      dataLengthUint8Array,
+      recipientCountUint8Array,
+      recipientIdsUint8Array,
+      encryptedKeysUint8Array,
+    );
+  }
+
+  /**
+   * Parse multi-recipient header
+   */
+  public parseHeader(data: Uint8Array): IMultiEncryptedParsedHeader {
+    if (data.length < 10) {
+      const engine = getEciesI18nEngine();
+      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_ECIESError_DataTooShortForMultiRecipientHeader));
+      // minimum: 8 + 2
+    }
+
+    let offset = 0;
+    const view = new DataView(data.buffer, data.byteOffset);
+
+    // Read data length
+    const dataLength = Number(view.getBigUint64(offset, false));
+    offset += 8;
+
+    if (dataLength <= 0 || dataLength > this.eciesConsts.MAX_RAW_DATA_SIZE) {
+      const engine = getEciesI18nEngine();
+      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_ECIESError_InvalidDataLength));
+    }
+
+    // Read recipient count
+    const recipientCount = view.getUint16(offset, false);
+    offset += 2;
+
+    if (recipientCount <= 0 || recipientCount > this.eciesConsts.MULTIPLE.MAX_RECIPIENTS) {
+      const engine = getEciesI18nEngine();
+      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_ECIESError_InvalidRecipientCount));
+    }
+
+    // Read recipient IDs
+    const recipientIds: Uint8Array[] = [];
+    for (let i = 0; i < recipientCount; i++) {
+      recipientIds.push(
+        data.slice(offset, offset + this.eciesConsts.MULTIPLE.RECIPIENT_ID_SIZE),
+      );
+      offset += this.eciesConsts.MULTIPLE.RECIPIENT_ID_SIZE;
+    }
+
+    // Read encrypted keys
+    const recipientKeys: Uint8Array[] = [];
+    for (let i = 0; i < recipientCount; i++) {
+      recipientKeys.push(
+        data.slice(offset, offset + this.eciesConsts.MULTIPLE.ENCRYPTED_KEY_SIZE),
+      );
+      offset += this.eciesConsts.MULTIPLE.ENCRYPTED_KEY_SIZE;
+    }
+
+    return {
+      dataLength,
+      recipientCount,
+      recipientIds,
+      recipientKeys,
+      headerSize: offset,
+    };
+  }
+
+  /**
+   * Parse complete multi-recipient message
+   */
+  public parseMessage(data: Uint8Array): IMultiEncryptedMessage {
+    const header = this.parseHeader(data);
+    const encryptedMessage = data.slice(header.headerSize);
+
+    return {
+      ...header,
+      encryptedMessage,
+    };
+  }
+
+  private arraysEqual(a: Uint8Array, b: Uint8Array): boolean {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) return false;
+    }
+    return true;
+  }
+}

package/src/services/ecies/service.ts

@@ -0,0 +1,317 @@
+import { IECIESConstants } from '../../interfaces/ecies-consts';
+import { Constants } from '../../constants';
+import {
+  EciesEncryptionType,
+  EciesEncryptionTypeEnum,
+} from '../../enumerations/ecies-encryption-type';
+import { IECIESConfig } from '../../interfaces/ecies-config';
+import { SecureString } from '../../secure-string';
+import { SignatureString, SignatureUint8Array } from '../../types';
+import { EciesCryptoCore } from './crypto-core';
+import { ISimpleKeyPair, IWalletSeed } from './interfaces';
+import { EciesSignature } from './signature';
+import { EciesSingleRecipient } from './single-recipient';
+
+/**
+ * Browser-compatible ECIES service that mirrors the server-side functionality
+ * Uses Web Crypto API and @scure/@noble libraries for browser compatibility
+ */
+export class ECIESService {
+  protected readonly _config: IECIESConfig;
+  protected readonly cryptoCore: EciesCryptoCore;
+  protected readonly signature: EciesSignature;
+  protected readonly singleRecipient: EciesSingleRecipient;
+  protected readonly eciesConsts: IECIESConstants;
+
+  constructor(config?: Partial<IECIESConfig>, eciesParams: IECIESConstants = Constants.ECIES) {
+    this.eciesConsts = eciesParams;
+    this._config = {
+      curveName: this.eciesConsts.CURVE_NAME,
+      primaryKeyDerivationPath: this.eciesConsts.PRIMARY_KEY_DERIVATION_PATH,
+      mnemonicStrength: this.eciesConsts.MNEMONIC_STRENGTH,
+      symmetricAlgorithm: this.eciesConsts.SYMMETRIC.ALGORITHM,
+      symmetricKeyBits: this.eciesConsts.SYMMETRIC.KEY_BITS,
+      symmetricKeyMode: this.eciesConsts.SYMMETRIC.MODE,
+      ...config,
+    };
+
+    // Initialize components
+    this.cryptoCore = new EciesCryptoCore(this._config, this.eciesConsts);
+    this.signature = new EciesSignature(this.cryptoCore);
+    this.singleRecipient = new EciesSingleRecipient(this._config);
+  }
+
+  public get core(): EciesCryptoCore {
+    return this.cryptoCore;
+  }
+
+  public get config(): IECIESConfig {
+    return this._config;
+  }
+
+  public get curveName(): string {
+    return this._config.curveName;
+  }
+
+  // === Key Management Methods ===
+
+  /**
+   * Generate a new mnemonic
+   */
+  public generateNewMnemonic(): SecureString {
+    return this.cryptoCore.generateNewMnemonic();
+  }
+
+  /**
+   * Generate wallet and seed from mnemonic
+   */
+  public walletAndSeedFromMnemonic(mnemonic: SecureString): IWalletSeed {
+    return this.cryptoCore.walletAndSeedFromMnemonic(mnemonic);
+  }
+
+  /**
+   * Create simple key pair from seed
+   */
+  public seedToSimpleKeyPair(seed: Uint8Array): ISimpleKeyPair {
+    return this.cryptoCore.seedToSimpleKeyPair(seed);
+  }
+
+  /**
+   * Create simple key pair from mnemonic
+   */
+  public mnemonicToSimpleKeyPair(mnemonic: SecureString): ISimpleKeyPair {
+    return this.cryptoCore.mnemonicToSimpleKeyPair(mnemonic);
+  }
+
+  /**
+   * Get public key from private key
+   */
+  public getPublicKey(privateKey: Uint8Array): Uint8Array {
+    return this.cryptoCore.getPublicKey(privateKey);
+  }
+
+  // === Core Encryption/Decryption Methods ===
+
+  /**
+   * Encrypt for single recipient (simple or single mode)
+   */
+  public async encryptSimpleOrSingle(
+    encryptSimple: boolean,
+    receiverPublicKey: Uint8Array,
+    message: Uint8Array,
+    preamble: Uint8Array = new Uint8Array(0),
+  ): Promise<Uint8Array> {
+    return this.singleRecipient.encrypt(
+      encryptSimple,
+      receiverPublicKey,
+      message,
+      preamble,
+    );
+  }
+
+  /**
+   * Parse single encrypted header
+   */
+  public parseSingleEncryptedHeader(
+    encryptionType: EciesEncryptionTypeEnum,
+    data: Uint8Array,
+    preambleSize: number = 0,
+    options?: { dataLength?: number },
+  ) {
+    const { header } = this.singleRecipient.parseEncryptedMessage(
+      encryptionType,
+      data,
+      preambleSize,
+      options,
+    );
+    return header;
+  }
+
+  /**
+   * Decrypt with header
+   */
+  public async decryptSimpleOrSingleWithHeader(
+    decryptSimple: boolean,
+    privateKey: Uint8Array,
+    encryptedData: Uint8Array,
+    preambleSize: number = 0,
+    options?: { dataLength?: number },
+  ): Promise<Uint8Array> {
+    return await this.singleRecipient.decryptWithHeader(
+      decryptSimple
+        ? EciesEncryptionTypeEnum.Simple
+        : EciesEncryptionTypeEnum.Single,
+      privateKey,
+      encryptedData,
+      preambleSize,
+      options,
+    );
+  }
+
+  /**
+   * Extended decrypt with header
+   */
+  public async decryptSimpleOrSingleWithHeaderEx(
+    encryptionType: EciesEncryptionTypeEnum,
+    privateKey: Uint8Array,
+    encryptedData: Uint8Array,
+    preambleSize: number = 0,
+    options?: { dataLength?: number },
+  ) {
+    return this.singleRecipient.decryptWithHeaderEx(
+      encryptionType,
+      privateKey,
+      encryptedData,
+      preambleSize,
+      options,
+    );
+  }
+
+  /**
+   * Decrypt with individual components
+   */
+  public async decryptSingleWithComponents(
+    privateKey: Uint8Array,
+    ephemeralPublicKey: Uint8Array,
+    iv: Uint8Array,
+    authTag: Uint8Array,
+    encrypted: Uint8Array,
+  ): Promise<{ decrypted: Uint8Array; ciphertextLength?: number }> {
+    const decrypted = await this.singleRecipient.decryptWithComponents(
+      privateKey,
+      ephemeralPublicKey,
+      iv,
+      authTag,
+      encrypted,
+    );
+
+    return { decrypted, ciphertextLength: encrypted.length };
+  }
+
+  // === Signature Methods ===
+
+  /**
+   * Sign a message
+   */
+  public signMessage(
+    privateKey: Uint8Array,
+    data: Uint8Array,
+  ): SignatureUint8Array {
+    return this.signature.signMessage(privateKey, data);
+  }
+
+  /**
+   * Verify a message signature
+   */
+  public verifyMessage(
+    publicKey: Uint8Array,
+    data: Uint8Array,
+    signature: SignatureUint8Array,
+  ): boolean {
+    return this.signature.verifyMessage(publicKey, data, signature);
+  }
+
+  /**
+   * Convert signature string to buffer
+   */
+  public signatureStringToSignatureUint8Array(
+    signatureString: SignatureString,
+  ): SignatureUint8Array {
+    return this.signature.signatureStringToSignatureUint8Array(signatureString);
+  }
+
+  /**
+   * Convert signature buffer to string
+   */
+  public signatureUint8ArrayToSignatureString(
+    signatureArray: SignatureUint8Array,
+  ): string {
+    return this.signature.signatureUint8ArrayToSignatureString(signatureArray);
+  }
+
+  // === Utility Methods ===
+
+  /**
+   * Compute encrypted length from data length
+   */
+  public computeEncryptedLengthFromDataLength(
+    dataLength: number,
+    encryptionMode: EciesEncryptionType,
+    recipientCount?: number,
+  ): number {
+    if (dataLength < 0) {
+      throw new Error('Invalid data length');
+    }
+
+    switch (encryptionMode) {
+      case 'simple':
+        return dataLength + this.eciesConsts.SIMPLE.FIXED_OVERHEAD_SIZE;
+      case 'single':
+        return dataLength + this.eciesConsts.SINGLE.FIXED_OVERHEAD_SIZE;
+      case 'multiple':
+        // Basic calculation for multiple recipients
+        return (
+          dataLength +
+          this.eciesConsts.MULTIPLE.FIXED_OVERHEAD_SIZE +
+          (recipientCount ?? 1) * this.eciesConsts.MULTIPLE.ENCRYPTED_KEY_SIZE
+        );
+      default:
+        throw new Error('Invalid encryption type');
+    }
+  }
+
+  /**
+   * Compute decrypted length from encrypted data length
+   */
+  public computeDecryptedLengthFromEncryptedDataLength(
+    encryptedDataLength: number,
+    padding?: number,
+  ): number {
+    if (encryptedDataLength < 0) {
+      throw new Error('Invalid encrypted data length');
+    }
+
+  const overhead = this.eciesConsts.SINGLE.FIXED_OVERHEAD_SIZE;
+    const actualPadding = padding !== undefined ? padding : 0;
+    const decryptedLength = encryptedDataLength - overhead - actualPadding;
+
+    if (decryptedLength < 0) {
+      throw new Error('Computed decrypted length is negative');
+    }
+
+    return decryptedLength;
+  }
+
+  /**
+   * Generic encrypt method
+   */
+  public async encrypt(
+    encryptionType: EciesEncryptionTypeEnum,
+    recipients: Array<{ publicKey: Uint8Array }>,
+    message: Uint8Array,
+    preamble?: Uint8Array,
+  ): Promise<Uint8Array> {
+    if (
+      (encryptionType === EciesEncryptionTypeEnum.Simple ||
+        EciesEncryptionTypeEnum.Single) &&
+      recipients.length === 1
+    ) {
+      return this.singleRecipient.encrypt(
+        encryptionType === EciesEncryptionTypeEnum.Simple,
+        recipients[0].publicKey,
+        message,
+        preamble,
+      );
+    } else if (
+      encryptionType === EciesEncryptionTypeEnum.Multiple &&
+      recipients.length > 1
+    ) {
+      // TODO: Implement multi-recipient encryption
+      throw new Error('Multi-recipient encryption not yet implemented');
+    } else {
+      throw new Error(
+        `Invalid encryption type or number of recipients: ${encryptionType}, ${recipients.length}`,
+      );
+    }
+  }
+}