ciphermask/test/unit/app/seed-phrase-verifier-test.js

import assert from 'assert';
import { cloneDeep } from 'lodash';
import KeyringController from 'eth-keyring-controller';
import firstTimeState from '../../../app/scripts/first-time-state';
import seedPhraseVerifier from '../../../app/scripts/lib/seed-phrase-verifier';
import mockEncryptor from '../../lib/mock-encryptor';

describe('SeedPhraseVerifier', function () {
  describe('verifyAccounts', function () {
    const password = 'passw0rd1';
    const hdKeyTree = 'HD Key Tree';

    let keyringController;
    let primaryKeyring;

    beforeEach(async function () {
      keyringController = new KeyringController({
        initState: cloneDeep(firstTimeState),
        encryptor: mockEncryptor,
      });

      assert(keyringController);

      await keyringController.createNewVaultAndKeychain(password);
      primaryKeyring = keyringController.getKeyringsByType(hdKeyTree)[0];
    });

    it('should be able to verify created account with seed words', async function () {
      const createdAccounts = await primaryKeyring.getAccounts();
      assert.equal(createdAccounts.length, 1);

      const serialized = await primaryKeyring.serialize();
      const seedWords = serialized.mnemonic;
      assert.notEqual(seedWords.length, 0);

      await seedPhraseVerifier.verifyAccounts(createdAccounts, seedWords);
    });

    it('should be able to verify created account (upper case) with seed words', async function () {
      const createdAccounts = await primaryKeyring.getAccounts();
      assert.equal(createdAccounts.length, 1);

      const upperCaseAccounts = [createdAccounts[0].toUpperCase()];

      const serialized = await primaryKeyring.serialize();
      const seedWords = serialized.mnemonic;
      assert.notEqual(seedWords.length, 0);

      await seedPhraseVerifier.verifyAccounts(upperCaseAccounts, seedWords);
    });

    it('should be able to verify created account (lower case) with seed words', async function () {
      const createdAccounts = await primaryKeyring.getAccounts();
      assert.equal(createdAccounts.length, 1);
      const lowerCaseAccounts = [createdAccounts[0].toLowerCase()];

      const serialized = await primaryKeyring.serialize();
      const seedWords = serialized.mnemonic;
      assert.notEqual(seedWords.length, 0);

      await seedPhraseVerifier.verifyAccounts(lowerCaseAccounts, seedWords);
    });

    it('should return error with good but different seed words', async function () {
      const createdAccounts = await primaryKeyring.getAccounts();
      assert.equal(createdAccounts.length, 1);

      await primaryKeyring.serialize();
      const seedWords =
        'debris dizzy just program just float decrease vacant alarm reduce speak stadium';

      try {
        await seedPhraseVerifier.verifyAccounts(createdAccounts, seedWords);
        assert.fail('Should reject');
      } catch (err) {
        assert.ok(
          err.message.indexOf('Not identical accounts!') >= 0,
          'Wrong error message',
        );
      }
    });

    it('should return error with undefined existing accounts', async function () {
      const createdAccounts = await primaryKeyring.getAccounts();
      assert.equal(createdAccounts.length, 1);

      await primaryKeyring.serialize();
      const seedWords =
        'debris dizzy just program just float decrease vacant alarm reduce speak stadium';

      try {
        await seedPhraseVerifier.verifyAccounts(undefined, seedWords);
        assert.fail('Should reject');
      } catch (err) {
        assert.equal(err.message, 'No created accounts defined.');
      }
    });

    it('should return error with empty accounts array', async function () {
      const createdAccounts = await primaryKeyring.getAccounts();
      assert.equal(createdAccounts.length, 1);

      await primaryKeyring.serialize();
      const seedWords =
        'debris dizzy just program just float decrease vacant alarm reduce speak stadium';

      try {
        await seedPhraseVerifier.verifyAccounts([], seedWords);
        assert.fail('Should reject');
      } catch (err) {
        assert.equal(err.message, 'No created accounts defined.');
      }
    });

    it('should be able to verify more than one created account with seed words', async function () {
      await keyringController.addNewAccount(primaryKeyring);
      await keyringController.addNewAccount(primaryKeyring);

      const createdAccounts = await primaryKeyring.getAccounts();
      assert.equal(createdAccounts.length, 3);

      const serialized = await primaryKeyring.serialize();
      const seedWords = serialized.mnemonic;
      assert.notEqual(seedWords.length, 0);

      await seedPhraseVerifier.verifyAccounts(createdAccounts, seedWords);
    });
  });
});