@digitaldefiance/ecies-lib 4.4.11 → 4.4.14

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

@@ -1,377 +0,0 @@
-import { ECIESService } from './ecies/service';
-import {
-  IMultiRecipientChunk,
-  IMultiRecipientChunkHeader,
-  IRecipientHeader,
-  IMultiRecipientConstants,
-  getMultiRecipientConstants,
-} from '../interfaces/multi-recipient-chunk';
-import { EciesComponentId, getEciesI18nEngine } from '../i18n-setup';
-import { EciesStringKey } from '../enumerations';
-import { Constants } from '../constants';
-import { IConstants } from '../interfaces/constants';
-import { AESGCMService } from './aes-gcm';
-import { concatUint8Arrays } from '../utils';
-
-/**
- * Processes multi-recipient chunks using symmetric encryption.
- * Supports dynamic recipient ID sizes based on the configured ID provider.
- */
-export class MultiRecipientProcessor {
-  private readonly recipientIdSize: number;
-  private readonly constants: IMultiRecipientConstants;
-
-  /**
-   * Create a new multi-recipient processor.
-   * @param ecies - ECIES service for key encryption
-   * @param config - Configuration containing ID provider (defaults to global Constants)
-   */
-  constructor(
-    private readonly ecies: ECIESService,
-    private readonly config: IConstants = Constants
-  ) {
-    this.recipientIdSize = config.idProvider.byteLength;
-    this.constants = getMultiRecipientConstants(this.recipientIdSize);
-  }
-
-  /**
-   * Encrypt chunk for multiple recipients
-   */
-  async encryptChunk(
-    data: Uint8Array,
-    recipients: Array<{ id: Uint8Array; publicKey: Uint8Array }>,
-    chunkIndex: number,
-    isLast: boolean,
-    symmetricKey: Uint8Array,
-    senderPrivateKey?: Uint8Array,
-  ): Promise<IMultiRecipientChunk> {
-    // Validate inputs
-    const engine = getEciesI18nEngine();
-    if (recipients.length === 0 || recipients.length > this.constants.MAX_RECIPIENTS) {
-      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_MultiRecipient_InvalidRecipientCountTemplate, { count: recipients.length }));
-    }
-    if (symmetricKey.length !== 32) {
-      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_MultiRecipient_SymmetricKeyMust32Bytes));
-    }
-    if (chunkIndex < 0 || chunkIndex > 0xFFFFFFFF) {
-      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_MultiRecipient_InvalidChunkIndexTemplate, { index: chunkIndex }));
-    }
-    
-    // Sign-then-Encrypt
-    let dataToEncrypt = data;
-    if (senderPrivateKey) {
-      const signature = this.ecies.core.sign(senderPrivateKey, data);
-      dataToEncrypt = concatUint8Arrays(signature, data);
-    }
-
-    if (dataToEncrypt.length > 0x7FFFFFFF) {
-      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_MultiRecipient_DataSizeExceedsMaximumTemplate, { size: dataToEncrypt.length }));
-    }
-
-    // Check for duplicate recipient IDs
-    const seenIds = new Set<string>();
-    for (const recipient of recipients) {
-      const idStr = Buffer.from(recipient.id).toString('hex');
-      if (seenIds.has(idStr)) {
-        throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_MultiRecipient_DuplicateRecipientId));
-      }
-      seenIds.add(idStr);
-    }
-
-    // Generate ONE ephemeral key pair for all recipients
-    const ephemeralKeyPair = await this.ecies.core.generateEphemeralKeyPair();
-
-    // Build recipient headers
-    const recipientHeaders: IRecipientHeader[] = [];
-    for (const recipient of recipients) {
-      if (recipient.id.length !== this.recipientIdSize) {
-        throw new Error(
-          `Recipient ID must be ${this.recipientIdSize} bytes (configured by ID provider), got ${recipient.id.length} bytes`
-        );
-      }
-      
-      // Use Recipient ID as AAD for key encryption
-      const encryptedKey = await this.ecies.encryptKey(
-        recipient.publicKey,
-        symmetricKey,
-        ephemeralKeyPair.privateKey,
-        recipient.id
-      );
-      
-      recipientHeaders.push({
-        id: recipient.id,
-        keySize: encryptedKey.length,
-        encryptedKey,
-      });
-    }
-
-    // Calculate sizes with overflow check
-    let recipientHeadersSize = 0;
-    for (const h of recipientHeaders) {
-      const headerSize = this.recipientIdSize + 
-                        this.constants.KEY_SIZE_BYTES + h.keySize;
-      if (recipientHeadersSize + headerSize < recipientHeadersSize) {
-        throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_MultiRecipient_RecipientHeadersSizeOverflow));
-      }
-      recipientHeadersSize += headerSize;
-    }
-
-    // Calculate encrypted size (Data + Tag)
-    // AES-GCM tag is 16 bytes
-    const encryptedSize = dataToEncrypt.length + 16;
-
-    const totalSize = this.constants.HEADER_SIZE + 
-                     recipientHeadersSize + 
-                     Constants.ECIES.IV_SIZE + // IV
-                     encryptedSize;
-
-    // Check for integer overflow (max safe: 2^31 - 1 for Uint8Array)
-    if (totalSize > 0x7FFFFFFF || totalSize < 0) {
-      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_MultiRecipient_ChunkSizeOverflow));
-    }
-
-    // Build chunk buffer
-    const chunk = new Uint8Array(totalSize);
-    const view = new DataView(chunk.buffer);
-    let offset = 0;
-
-    // Write header
-    view.setUint32(offset, this.constants.MAGIC, false);
-    offset += 4;
-    view.setUint16(offset, this.constants.VERSION, false);
-    offset += 2;
-    view.setUint16(offset, recipients.length, false);
-    offset += 2;
-    view.setUint32(offset, chunkIndex, false);
-    offset += 4;
-    view.setUint32(offset, dataToEncrypt.length, false); // Original Size (includes signature if present)
-    offset += 4;
-    view.setUint32(offset, encryptedSize, false);
-    offset += 4;
-    view.setUint8(offset, isLast ? this.constants.FLAG_IS_LAST : 0);
-    offset += 1;
-
-    // Write Ephemeral Public Key (33 bytes)
-    chunk.set(ephemeralKeyPair.publicKey, offset);
-    offset += 33;
-
-    // Padding to HEADER_SIZE (64 bytes)
-    offset = this.constants.HEADER_SIZE;
-
-    // Write recipient headers
-    for (const header of recipientHeaders) {
-      chunk.set(header.id, offset);
-      offset += this.recipientIdSize;
-      view.setUint16(offset, header.keySize, false);
-      offset += this.constants.KEY_SIZE_BYTES;
-      chunk.set(header.encryptedKey, offset);
-      offset += header.keySize;
-    }
-
-    // Extract the full header (including recipient headers) to use as AAD
-    const headerBytes = chunk.slice(0, offset);
-
-    // Encrypt data with AES-256-GCM using Header as AAD
-    const encryptResult = await AESGCMService.encrypt(
-      dataToEncrypt,
-      symmetricKey,
-      true, // Return tag separately
-      Constants.ECIES,
-      headerBytes // AAD
-    );
-
-    // Write IV
-    chunk.set(encryptResult.iv, offset);
-    offset += Constants.ECIES.IV_SIZE;
-
-    // Write encrypted data
-    chunk.set(encryptResult.encrypted, offset);
-    offset += encryptResult.encrypted.length;
-
-    // Write auth tag
-    if (encryptResult.tag) {
-      chunk.set(encryptResult.tag, offset);
-    }
-
-    return {
-      index: chunkIndex,
-      data: chunk,
-      isLast,
-      recipientCount: recipients.length,
-    };
-  }
-
-  /**
-   * Decrypt chunk for specific recipient
-   */
-  async decryptChunk(
-    chunkData: Uint8Array,
-    recipientId: Uint8Array,
-    privateKey: Uint8Array,
-    senderPublicKey?: Uint8Array,
-  ): Promise<{ data: Uint8Array; header: IMultiRecipientChunkHeader }> {
-    const engine = getEciesI18nEngine();
-    if (chunkData.length < this.constants.HEADER_SIZE) {
-      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_MultiRecipient_ChunkTooSmall));
-    }
-
-    const view = new DataView(chunkData.buffer, chunkData.byteOffset);
-    let offset = 0;
-
-    // Parse header
-    const magic = view.getUint32(offset, false);
-    offset += 4;
-    if (magic !== this.constants.MAGIC) {
-      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_MultiRecipient_InvalidChunkMagic));
-    }
-
-    const version = view.getUint16(offset, false);
-    offset += 2;
-    if (version !== this.constants.VERSION) {
-      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_MultiRecipient_UnsupportedVersionTemplate, { version }));
-    }
-
-    const recipientCount = view.getUint16(offset, false);
-    offset += 2;
-    if (recipientCount === 0 || recipientCount > this.constants.MAX_RECIPIENTS) {
-      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_MultiRecipient_InvalidRecipientCountTemplate, { count: recipientCount }));
-    }
-    const chunkIndex = view.getUint32(offset, false);
-    offset += 4;
-    const originalSize = view.getUint32(offset, false);
-    offset += 4;
-    const encryptedSize = view.getUint32(offset, false);
-    offset += 4;
-    const flags = view.getUint8(offset);
-    offset += 1;
-
-    // Read Ephemeral Public Key (33 bytes)
-    const ephemeralPublicKey = chunkData.slice(offset, offset + 33);
-    offset += 33;
-
-    offset = this.constants.HEADER_SIZE;
-
-    // Validate encryptedSize against chunk size
-    // We know it must be at least HEADER + IV + EncryptedSize (which includes tag)
-    const minChunkSize = this.constants.HEADER_SIZE + Constants.ECIES.IV_SIZE + encryptedSize;
-    if (chunkData.length < minChunkSize) {
-      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_MultiRecipient_ChunkTooSmallForEncryptedSize));
-    }
-
-    // Find recipient header and decrypt symmetric key
-    let symmetricKey: Uint8Array | null = null;
-    let tempOffset = offset;
-    
-    for (let i = 0; i < recipientCount; i++) {
-      // Check if we have enough data for recipient ID
-      if (tempOffset + this.recipientIdSize > chunkData.length) {
-        throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_MultiRecipient_ChunkTruncatedRecipientId));
-      }
-      
-      const id = chunkData.slice(tempOffset, tempOffset + this.recipientIdSize);
-      tempOffset += this.recipientIdSize;
-      
-      // Check if we have enough data for keySize field
-      if (tempOffset + this.constants.KEY_SIZE_BYTES > chunkData.length) {
-        throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_MultiRecipient_ChunkTruncatedKeySize));
-      }
-      
-      const keySize = view.getUint16(tempOffset, false);
-      tempOffset += this.constants.KEY_SIZE_BYTES;
-
-      // Validate keySize (typical ECIES: 100-400 bytes)
-      if (keySize === 0 || keySize > 1000) {
-        throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_MultiRecipient_InvalidKeySizeTemplate, { size: keySize }));
-      }
-      
-      // Check if we have enough data for the encrypted key
-      if (tempOffset + keySize > chunkData.length) {
-        throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_MultiRecipient_ChunkTruncatedEncryptedKey));
-      }
-      
-      const encryptedKey = chunkData.slice(tempOffset, tempOffset + keySize);
-      tempOffset += keySize;
-
-      // Check if this is our recipient
-      if (this.arraysEqual(id, recipientId)) {
-        // Use Recipient ID as AAD for key decryption
-        symmetricKey = await this.ecies.decryptKey(privateKey, encryptedKey, ephemeralPublicKey, id);
-        // Don't break - need to skip all recipient headers
-      }
-    }
-
-    if (!symmetricKey) {
-      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_MultiRecipient_RecipientNotFoundInChunk));
-    }
-    
-    // Update offset to after all recipient headers
-    offset = tempOffset;
-
-    // Extract header bytes for AAD
-    const headerBytes = chunkData.slice(0, offset);
-
-    // Read IV
-    if (offset + Constants.ECIES.IV_SIZE > chunkData.length) {
-      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_MultiRecipient_ChunkTooSmall));
-    }
-    const iv = chunkData.slice(offset, offset + Constants.ECIES.IV_SIZE);
-    offset += Constants.ECIES.IV_SIZE;
-
-    // Read encrypted data (includes auth tag)
-    if (offset + encryptedSize > chunkData.length) {
-      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_MultiRecipient_ChunkTooSmall));
-    }
-    const encryptedWithTag = chunkData.slice(offset, offset + encryptedSize);
-    offset += encryptedSize;
-
-    // Decrypt with AAD
-    const decrypted = await AESGCMService.decrypt(
-      iv, 
-      encryptedWithTag, 
-      symmetricKey, 
-      true, 
-      Constants.ECIES, 
-      headerBytes
-    );
-
-    // Verify signature if sender public key provided
-    let finalData = decrypted;
-    if (senderPublicKey) {
-      if (decrypted.length < 64) {
-        throw new Error('Decrypted chunk too short to contain signature');
-      }
-      const signature = decrypted.slice(0, 64);
-      const message = decrypted.slice(64);
-      
-      const isValid = this.ecies.core.verify(senderPublicKey, message, signature);
-      if (!isValid) {
-        throw new Error('Invalid sender signature in chunk');
-      }
-      finalData = message;
-    }
-
-    return {
-      data: finalData,
-      header: {
-        magic,
-        version,
-        recipientCount,
-        chunkIndex,
-        originalSize,
-        encryptedSize,
-        flags,
-      },
-    };
-  }
-
-  private arraysEqual(a: Uint8Array, b: Uint8Array): boolean {
-    if (a.length !== b.length) return false;
-    
-    // Constant-time comparison to prevent timing attacks
-    let diff = 0;
-    for (let i = 0; i < a.length; i++) {
-      diff |= a[i] ^ b[i];
-    }
-    return diff === 0;
-  }
-}

package/src/services/password-login.ts

@@ -1,226 +0,0 @@
-import { Wallet } from '@ethereumjs/wallet';
-import { EciesEncryptionTypeEnum } from '../enumerations/ecies-encryption-type';
-import { Pbkdf2ProfileEnum } from '../enumerations/pbkdf2-profile';
-import { SecureString } from '../secure-string';
-import { hexToUint8Array, uint8ArrayToHex } from '../utils';
-import { AESGCMService } from './aes-gcm';
-import { ECIESService } from './ecies/service';
-import { Pbkdf2Service } from './pbkdf2';
-import { EciesStringKey, PasswordLoginErrorTypeEnum } from '../enumerations';
-import { buildReasonMap, TranslatableGenericError, TypedHandleableError } from '@digitaldefiance/i18n-lib';
-import { IECIESConstants } from '../interfaces/ecies-consts';
-import { Constants } from '../constants';
-import { EciesComponentId } from '../i18n-setup';
-
-
-export class PasswordLoginService {
-  protected readonly eciesService: ECIESService;
-  protected readonly pbkdf2Service: Pbkdf2Service;
-  protected readonly eciesConsts: IECIESConstants;
-  public static readonly privateKeyStorageKey = 'encryptedPrivateKey';
-  public static readonly saltStorageKey = 'passwordLoginSalt';
-  public static readonly encryptedMnemonicStorageKey = 'encryptedMnemonic';
-  public static readonly profileStorageKey = 'pbkdf2Profile';
-
-  constructor(eciesService: ECIESService, pbkdf2Service: Pbkdf2Service, eciesParams: IECIESConstants = Constants.ECIES) {
-    this.eciesService = eciesService;
-    this.pbkdf2Service = pbkdf2Service;
-    this.eciesConsts = eciesParams;
-  }
-
-  public async createPasswordLoginBundle(
-    mnemonic: SecureString,
-    password: SecureString,
-    profile: Pbkdf2ProfileEnum = Pbkdf2ProfileEnum.BROWSER_PASSWORD,
-  ): Promise<{
-    salt: Uint8Array;
-    encryptedPrivateKey: Uint8Array;
-    encryptedMnemonic: Uint8Array;
-    wallet: Wallet;
-  }> {
-    const { wallet } = this.eciesService.walletAndSeedFromMnemonic(mnemonic);
-
-    const derivedKey =
-      await this.pbkdf2Service.deriveKeyFromPasswordWithProfileAsync(
-        password.valueAsUint8Array,
-        profile,
-      );
-
-    // Encrypt private key with derived key
-    const privateKeyBytes = wallet.getPrivateKey();
-    const { encrypted, iv, tag } = await AESGCMService.encrypt(
-      privateKeyBytes,
-      derivedKey.hash,
-      true,
-    );
-    if (!tag) {
-      throw new TranslatableGenericError(EciesComponentId, EciesStringKey.Error_Utils_EncryptionFailedNoAuthTag);
-    }
-    const encryptedPrivateKey = AESGCMService.combineIvTagAndEncryptedData(
-      iv,
-      encrypted,
-      tag,
-    );
-
-    // now use the public key to encrypt the mnemonic and store it
-    const encryptedMnemonic = await this.eciesService.encrypt(
-      EciesEncryptionTypeEnum.Simple,
-      wallet.getPublicKey(),
-      mnemonic.valueAsUint8Array,
-    );
-
-    return {
-      salt: derivedKey.salt,
-      encryptedPrivateKey: encryptedPrivateKey,
-      encryptedMnemonic: encryptedMnemonic,
-      wallet,
-    };
-  }
-
-  /**
-   * Set up password login by deriving a key from the password and using it to encrypt
-   * @param mnemonic The user's mnemonic
-   * @param password The user's password
-   */
-  public async setupPasswordLoginLocalStorageBundle(
-    mnemonic: SecureString,
-    password: SecureString,
-    profile: Pbkdf2ProfileEnum = Pbkdf2ProfileEnum.BROWSER_PASSWORD,
-  ): Promise<Wallet> {
-    const { salt, encryptedPrivateKey, encryptedMnemonic, wallet } =
-      await this.createPasswordLoginBundle(mnemonic, password, profile);
-
-    // store the salt and encrypted private key in local storage
-    try {
-      localStorage.setItem(
-        PasswordLoginService.saltStorageKey,
-        uint8ArrayToHex(salt),
-      );
-      localStorage.setItem(
-        PasswordLoginService.privateKeyStorageKey,
-        uint8ArrayToHex(encryptedPrivateKey),
-      );
-      localStorage.setItem(
-        PasswordLoginService.encryptedMnemonicStorageKey,
-        uint8ArrayToHex(encryptedMnemonic),
-      );
-      localStorage.setItem(
-        PasswordLoginService.profileStorageKey,
-        profile,
-      );
-    } catch (error) {
-      throw new TypedHandleableError<typeof PasswordLoginErrorTypeEnum, EciesStringKey>(EciesComponentId, PasswordLoginErrorTypeEnum.FailedToStoreLoginData, buildReasonMap<typeof PasswordLoginErrorTypeEnum, EciesStringKey>(PasswordLoginErrorTypeEnum, ['Error', 'PasswordLoginError']), new Error(), { cause: error instanceof Error ? error : undefined });
-    }
-    return wallet;
-  }
-
-  public async getWalletAndMnemonicFromEncryptedPasswordBundle(
-    salt: Uint8Array,
-    encryptedPrivateKey: Uint8Array,
-    encryptedMnemonic: Uint8Array,
-    password: SecureString,
-    profile: Pbkdf2ProfileEnum = Pbkdf2ProfileEnum.BROWSER_PASSWORD,
-  ): Promise<{ wallet: Wallet; mnemonic: SecureString }> {
-    if (!salt || !encryptedPrivateKey || !encryptedMnemonic) {
-     throw new TypedHandleableError<typeof PasswordLoginErrorTypeEnum, EciesStringKey>(EciesComponentId, PasswordLoginErrorTypeEnum.PasswordLoginNotSetUp, buildReasonMap<typeof PasswordLoginErrorTypeEnum, EciesStringKey>(PasswordLoginErrorTypeEnum, ['Error', 'PasswordLoginError']), new Error());
-    }
-
-    const derivedKey =
-      await this.pbkdf2Service.deriveKeyFromPasswordWithProfileAsync(
-        password.valueAsUint8Array,
-        profile,
-        salt,
-      );
-
-    // Decrypt private key with derived key
-    const { iv, encryptedDataWithTag } = AESGCMService.splitEncryptedData(
-      encryptedPrivateKey,
-      true,
-      this.eciesConsts,
-    );
-    const privateKeyBytes = await AESGCMService.decrypt(
-      iv,
-      encryptedDataWithTag,
-      derivedKey.hash,
-      true,
-      this.eciesConsts,
-    );
-
-    const wallet = Wallet.fromPrivateKey(privateKeyBytes);
-
-    // now decrypt the mnemonic
-    const decryptedMnemonic =
-      await this.eciesService.decryptSimpleOrSingleWithHeader(
-        true,
-        wallet.getPrivateKey(),
-        encryptedMnemonic,
-      );
-
-    return { wallet, mnemonic: new SecureString(decryptedMnemonic) };
-  }
-
-  /**
-   * Recover wallet and mnemonic from password
-   * @param password The user's password
-   * @returns The user's wallet and mnemonic
-   */
-  public async getWalletAndMnemonicFromLocalStorageBundle(
-    password: SecureString,
-  ): Promise<{ wallet: Wallet; mnemonic: SecureString }> {
-    const saltHex = localStorage.getItem(PasswordLoginService.saltStorageKey);
-    const encryptedPrivateKeyHex = localStorage.getItem(
-      PasswordLoginService.privateKeyStorageKey,
-    );
-    const encryptedMnemonicHex = localStorage.getItem(
-      PasswordLoginService.encryptedMnemonicStorageKey,
-    );
-    const profileStr = localStorage.getItem(PasswordLoginService.profileStorageKey);
-
-    if (
-      !saltHex ||
-      !encryptedPrivateKeyHex ||
-      !encryptedMnemonicHex ||
-      saltHex === '' ||
-      encryptedPrivateKeyHex === '' ||
-      encryptedMnemonicHex === ''
-    ) {
-      throw new TypedHandleableError<typeof PasswordLoginErrorTypeEnum, EciesStringKey>(EciesComponentId, PasswordLoginErrorTypeEnum.PasswordLoginNotSetUp, buildReasonMap<typeof PasswordLoginErrorTypeEnum, EciesStringKey>(PasswordLoginErrorTypeEnum, ['Error', 'PasswordLoginError']), new Error());
-    }
-
-    const salt = hexToUint8Array(saltHex);
-    const encryptedPrivateKey = hexToUint8Array(encryptedPrivateKeyHex);
-    const encryptedMnemonic = hexToUint8Array(encryptedMnemonicHex);
-    const profile = (profileStr as Pbkdf2ProfileEnum) || Pbkdf2ProfileEnum.BROWSER_PASSWORD;
-
-    return await this.getWalletAndMnemonicFromEncryptedPasswordBundle(
-      salt,
-      encryptedPrivateKey,
-      encryptedMnemonic,
-      password,
-      profile,
-    );
-  }
-
-  /**
-   *
-   * @returns True if password login is set up (i.e. salt and encrypted private key are in local storage)
-   */
-  public static isPasswordLoginSetup(): boolean {
-    const saltHex = localStorage.getItem(PasswordLoginService.saltStorageKey);
-    const encryptedPrivateKeyHex = localStorage.getItem(
-      PasswordLoginService.privateKeyStorageKey,
-    );
-    const encryptedMnemonicHex = localStorage.getItem(
-      PasswordLoginService.encryptedMnemonicStorageKey,
-    );
-
-    return !!(
-      saltHex &&
-      encryptedPrivateKeyHex &&
-      encryptedMnemonicHex &&
-      saltHex !== '' &&
-      encryptedPrivateKeyHex !== '' &&
-      encryptedMnemonicHex !== ''
-    );
-  }
-}