import { Wallet } from '@ethereumjs/wallet';

import HdKeyring from '@metamask/eth-hd-keyring';

import { normalize as normalizeAddress } from '@metamask/eth-sig-util';

import type { Hex, Json, KeyringClass } from '@metamask/utils';

import { bytesToHex } from '@metamask/utils';

import { strict as assert } from 'assert';

import * as sinon from 'sinon';

import { KeyringController, keyringBuilderFactory } from '.';

import { KeyringType, KeyringControllerError } from './constants';

import {

MockEncryptor,

KeyringMockWithInit,

PASSWORD,

MOCK_HARDCODED_KEY,

MOCK_ENCRYPTION_SALT,

BaseKeyringMock,

KeyringMockWithDestroy,

buildMockTransaction,

KeyringMockWithSignTransaction,

KeyringMockWithUserOp,

} from './test';

import type { KeyringControllerArgs } from './types';

const MOCK_ENCRYPTION_KEY =

'{"alg":"A256GCM","ext":true,"k":"wYmxkxOOFBDP6F6VuuYFcRt_Po-tSLFHCWVolsHs4VI","key_ops":["encrypt","decrypt"],"kty":"oct"}';

const MOCK_ENCRYPTION_DATA = `{"data":"2fOOPRKClNrisB+tmqIcETyZvDuL2iIR1Hr1nO7XZHyMqVY1cDBetw2gY5C+cIo1qkpyv3bPp+4buUjp38VBsjbijM0F/FLOqWbcuKM9h9X0uwxsgsZ96uwcIf5I46NiMgoFlhppTTMZT0Nkocz+SnvHM0IgLsFan7JqBU++vSJvx2M1PDljZSunOsqyyL+DKmbYmM4umbouKV42dipUwrCvrQJmpiUZrSkpMJrPJk9ufDQO4CyIVo0qry3aNRdYFJ6rgSyq/k6rXMwGExCMHn8UlhNnAMuMKWPWR/ymK1bzNcNs4VU14iVjEXOZGPvD9cvqVe/VtcnIba6axNEEB4HWDOCdrDh5YNWwMlQVL7vSB2yOhPZByGhnEOloYsj2E5KEb9jFGskt7EKDEYNofr6t83G0c+B72VGYZeCvgtzXzgPwzIbhTtKkP+gdBmt2JNSYrTjLypT0q+v4C9BN1xWTxPmX6TTt0NzkI9pJxgN1VQAfSU9CyWTVpd4CBkgom2cSBsxZ2MNbdKF+qSWz3fQcmJ55hxM0EGJSt9+8eQOTuoJlBapRk4wdZKHR2jdKzPjSF2MAmyVD2kU51IKa/cVsckRFEes+m7dKyHRvlNwgT78W9tBDdZb5PSlfbZXnv8z5q1KtAj2lM2ogJ7brHBdevl4FISdTkObpwcUMcvACOOO0dj6CSYjSKr0ZJ2RLChVruZyPDxEhKGb/8Kv8trLOR3mck/et6d050/NugezycNk4nnzu5iP90gPbSzaqdZI=","iv":"qTGO1afGv3waHN9KoW34Eg==","salt":"${MOCK_ENCRYPTION_SALT}"}`;

const walletOneSeedWords =

'puzzle seed penalty soldier say clay field arctic metal hen cage runway';

const mockAddress = '0xef35ca8ebb9669a35c31b5f6f249a9941a812ac1';

const walletOneAddresses = ['0xef35ca8ebb9669a35c31b5f6f249a9941a812ac1'];

const walletOnePrivateKey = [

'ace918800411c0b96b915f76efbbd4d50e6c997180fee58e01f60d3a412d2f7e',

];

const walletTwoSeedWords =

'urge letter protect palace city barely security section midnight wealth south deer';

const walletTwoAddresses = [

'0xbbafcf3d00fb625b65bb1497c94bf42c1f4b3e78',

'0x49dd2653f38f75d40fdbd51e83b9c9724c87f7eb',

];

/**

* Create a keyring controller that has been initialized with the given options.

*

* @param options - Initialization options.

* @param options.constructorOptions - Constructor options, merged with test defaults.

* @param options.password - The vault password. If provided, creates a new vault (if necessary)

* and unlocks the vault.

* @param options.seedPhrase - A seed phrase. If provided, this is used to restore the vault.

* @returns A keyring controller.

*/

async function initializeKeyringController({

constructorOptions,

password,

seedPhrase,

}: {

constructorOptions?: Partial<KeyringControllerArgs>;

password?: string;

seedPhrase?: string;

} = {}) {

const keyringController = new KeyringController({

encryptor: new MockEncryptor(),

cacheEncryptionKey: false,

keyringBuilders: [keyringBuilderFactory(BaseKeyringMock)],

...constructorOptions,

});

if (seedPhrase && !password) {

throw new Error('Password required to restore vault');

} else if (seedPhrase && password) {

await keyringController.createNewVaultWithKeyring(PASSWORD, {

type: KeyringType.HD,

opts: {

mnemonic: walletOneSeedWords,

numberOfAccounts: 1,

},

});

} else if (password) {

await keyringController.createNewVaultWithKeyring(PASSWORD, {

type: KeyringType.HD,

});

}

return keyringController;

}

/**

* Delete the encryption key and salt from the `memStore` of the given keyring controller.

*

* @param keyringController - The keyring controller to delete the encryption key and salt from.

*/

function deleteEncryptionKeyAndSalt(keyringController: KeyringController) {

const keyringControllerState = keyringController.memStore.getState();

delete keyringControllerState.encryptionKey;

delete keyringControllerState.encryptionSalt;

keyringController.memStore.updateState(keyringControllerState);

}

/**

* Stub the `getAccounts` and `addAccounts` methods of the given keyring class to return the given

* account.

*

* @param keyringClass - The keyring class to stub.

* @param account - The account to return.

*/

function stubKeyringClassWithAccount(

keyringClass: KeyringClass<Json>,

account: string,

) {

sinon

.stub(keyringClass.prototype, 'getAccounts')

.returns(Promise.resolve([account]));

sinon

.stub(keyringClass.prototype, 'addAccounts')

.returns(Promise.resolve([account]));

}

describe('KeyringController', () => {

afterEach(() => {

sinon.restore();

});

describe('constructor', () => {

describe('with cacheEncryptionKey = true', () => {

it('should throw error if provided encryptor does not support key export', async () => {

expect(

() =>

// @ts-expect-error we want to bypass typechecks here.

new KeyringController({

cacheEncryptionKey: true,

encryptor: {

decrypt: async (_pass: string, _text: string) =>

Promise.resolve('encrypted'),

encrypt: async (_pass: string, _obj: any) => 'decrypted',

},

}),

).toThrow(KeyringControllerError.UnsupportedEncryptionKeyExport);

});

});

});

describe('setLocked', () => {

it('setLocked correctly sets lock state', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

});

assert.notDeepEqual(

keyringController.keyrings,

[],

'keyrings should not be empty',

);

await keyringController.setLocked();

expect(keyringController.password).toBeUndefined();

expect(keyringController.memStore.getState().isUnlocked).toBe(false);

expect(keyringController.keyrings).toHaveLength(0);

});

it('emits "lock" event', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

});

const lockSpy = sinon.spy();

keyringController.on('lock', lockSpy);

await keyringController.setLocked();

expect(lockSpy.calledOnce).toBe(true);

});

it('calls keyring optional destroy function', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

constructorOptions: {

keyringBuilders: [keyringBuilderFactory(KeyringMockWithDestroy)],

},

});

const destroy = sinon.spy(KeyringMockWithDestroy.prototype, 'destroy');

await keyringController.addNewKeyring('Keyring Mock With Destroy');

await keyringController.setLocked();

expect(destroy.calledOnce).toBe(true);

});

});

describe('submitPassword', () => {

it('should not load keyrings when incorrect password', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

});

await keyringController.createNewVaultWithKeyring(PASSWORD, {

type: KeyringType.HD,

});

await keyringController.persistAllKeyrings();

expect(keyringController.keyrings).toHaveLength(1);

await keyringController.setLocked();

await expect(

keyringController.submitPassword('Wrong password'),

).rejects.toThrow('Incorrect password.');

expect(keyringController.password).toBeUndefined();

expect(keyringController.keyrings).toHaveLength(0);

});

it('emits "unlock" event', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

});

await keyringController.setLocked();

const unlockSpy = sinon.spy();

keyringController.on('unlock', unlockSpy);

await keyringController.submitPassword(PASSWORD);

expect(unlockSpy.calledOnce).toBe(true);

});

});

describe('persistAllKeyrings', () => {

it('should persist keyrings in _unsupportedKeyrings array', async () => {

const mockEncryptor = new MockEncryptor();

const keyringController = await initializeKeyringController({

password: PASSWORD,

constructorOptions: {

encryptor: mockEncryptor,

},

});

const encryptSpy = sinon.spy(mockEncryptor, 'encrypt');

const unsupportedKeyring = { type: 'DUMMY_KEYRING', data: {} };

keyringController.unsupportedKeyrings = [unsupportedKeyring];

await keyringController.persistAllKeyrings();

assert(keyringController.store.getState().vault, 'Vault is not set');

expect(encryptSpy.calledOnce).toBe(true);

expect(encryptSpy.getCalls()[0]?.args[1]).toHaveLength(2);

expect(encryptSpy.getCalls()[0]?.args[1]).toContain(unsupportedKeyring);

});

describe('when `cacheEncryptionKey` is enabled', () => {

describe('when `encryptionKey` is set', () => {

it('should save an up to date encryption salt to the `memStore`', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

constructorOptions: {

cacheEncryptionKey: true,

},

});

const vaultEncryptionKey = '🔑';

const vaultEncryptionSalt = '🧂';

const vault = JSON.stringify({ salt: vaultEncryptionSalt });

keyringController.store.updateState({ vault });

await keyringController.unlockKeyrings(

undefined,

vaultEncryptionKey,

vaultEncryptionSalt,

);

expect(keyringController.memStore.getState().encryptionKey).toBe(

vaultEncryptionKey,

);

expect(keyringController.memStore.getState().encryptionSalt).toBe(

vaultEncryptionSalt,

);

const response = await keyringController.persistAllKeyrings();

expect(response).toBe(true);

expect(keyringController.memStore.getState().encryptionKey).toBe(

vaultEncryptionKey,

);

expect(keyringController.memStore.getState().encryptionSalt).toBe(

vaultEncryptionSalt,

);

});

});

describe('when `encryptionKey` is not set and `password` is set', () => {

it('should save an up to date encryption salt to the `memStore` when `password` is set through `createNewVaultAndKeychain`', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

constructorOptions: {

cacheEncryptionKey: true,

},

});

await keyringController.createNewVaultWithKeyring(PASSWORD, {

type: KeyringType.HD,

});

deleteEncryptionKeyAndSalt(keyringController);

const response = await keyringController.persistAllKeyrings();

expect(response).toBe(true);

expect(keyringController.memStore.getState().encryptionKey).toBe(

MOCK_HARDCODED_KEY,

);

expect(keyringController.memStore.getState().encryptionSalt).toBe(

MOCK_ENCRYPTION_SALT,

);

});

it('should save an up to date encryption salt to the `memStore` when `password` is set through `submitPassword`', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

constructorOptions: {

cacheEncryptionKey: true,

},

});

await keyringController.submitPassword(PASSWORD);

deleteEncryptionKeyAndSalt(keyringController);

const response = await keyringController.persistAllKeyrings();

expect(response).toBe(true);

expect(keyringController.memStore.getState().encryptionKey).toBe(

MOCK_HARDCODED_KEY,

);

expect(keyringController.memStore.getState().encryptionSalt).toBe(

MOCK_ENCRYPTION_SALT,

);

});

});

});

it('should add an `encryptionSalt` to the `memStore` when a vault is restored', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

constructorOptions: {

cacheEncryptionKey: true,

},

});

await keyringController.createNewVaultWithKeyring(PASSWORD, {

type: KeyringType.HD,

opts: {

mnemonic: walletOneSeedWords,

numberOfAccounts: 1,

},

});

const finalMemStore = keyringController.memStore.getState();

expect(finalMemStore.encryptionKey).toBe(MOCK_HARDCODED_KEY);

expect(finalMemStore.encryptionSalt).toBe(MOCK_ENCRYPTION_SALT);

});

});

describe('createNewVaultWithKeyring', () => {

it('should create a new vault with a HD keyring', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

});

keyringController.store.putState({});

assert(!keyringController.store.getState().vault, 'no previous vault');

const newVault = await keyringController.createNewVaultWithKeyring(

PASSWORD,

{

type: KeyringType.HD,

},

);

const { vault } = keyringController.store.getState();

expect(vault).toStrictEqual(expect.stringMatching('.+'));

expect(typeof newVault).toBe('object');

});

it('should create a new vault with a simple keyring', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

});

keyringController.store.putState({});

assert(!keyringController.store.getState().vault, 'no previous vault');

const newVault = await keyringController.createNewVaultWithKeyring(

PASSWORD,

{

type: KeyringType.Simple,

opts: walletOnePrivateKey,

},

);

const { vault } = keyringController.store.getState();

expect(vault).toStrictEqual(expect.stringMatching('.+'));

expect(typeof newVault).toBe('object');

const accounts = await keyringController.getAccounts();

expect(accounts).toHaveLength(1);

expect(accounts[0]).toBe(walletOneAddresses[0]);

});

it('should unlock the vault', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

});

keyringController.store.putState({});

assert(!keyringController.store.getState().vault, 'no previous vault');

await keyringController.createNewVaultWithKeyring(PASSWORD, {

type: KeyringType.HD,

});

const { isUnlocked } = keyringController.memStore.getState();

expect(isUnlocked).toBe(true);

});

it('should encrypt keyrings with the correct password each time they are persisted', async () => {

const mockEncryptor = new MockEncryptor();

const encryptSpy = sinon.spy(mockEncryptor, 'encrypt');

const keyringController = await initializeKeyringController({

password: PASSWORD,

constructorOptions: {

encryptor: mockEncryptor,

},

});

keyringController.store.putState({});

assert(!keyringController.store.getState().vault, 'no previous vault');

await keyringController.createNewVaultWithKeyring(PASSWORD, {

type: KeyringType.HD,

});

const { vault } = keyringController.store.getState();

// eslint-disable-next-line jest/no-restricted-matchers

expect(vault).toBeTruthy();

encryptSpy.args.forEach(([actualPassword]) => {

expect(actualPassword).toBe(PASSWORD);

});

});

it('should throw error if accounts are not generated correctly', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

});

jest

.spyOn(HdKeyring.prototype, 'getAccounts')

.mockImplementation(async () => Promise.resolve([]));

await expect(async () =>

keyringController.createNewVaultWithKeyring(PASSWORD, {

type: KeyringType.HD,

}),

).rejects.toThrow(KeyringControllerError.NoFirstAccount);

});

describe('when `cacheEncryptionKey` is enabled', () => {

it('should add an `encryptionSalt` to the `memStore` when a new vault is created', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

constructorOptions: {

cacheEncryptionKey: true,

},

});

await keyringController.createNewVaultWithKeyring(PASSWORD, {

type: KeyringType.HD,

});

const finalMemStore = keyringController.memStore.getState();

expect(finalMemStore.encryptionKey).toBe(MOCK_HARDCODED_KEY);

expect(finalMemStore.encryptionSalt).toBe(MOCK_ENCRYPTION_SALT);

});

});

it('clears old keyrings and creates a one', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

});

const initialAccounts = await keyringController.getAccounts();

expect(initialAccounts).toHaveLength(1);

await keyringController.addNewKeyring(KeyringType.HD);

const allAccounts = await keyringController.getAccounts();

expect(allAccounts).toHaveLength(2);

await keyringController.createNewVaultWithKeyring(PASSWORD, {

type: KeyringType.HD,

opts: {

mnemonic: walletOneSeedWords,

numberOfAccounts: 1,

},

});

const allAccountsAfter = await keyringController.getAccounts();

expect(allAccountsAfter).toHaveLength(1);

expect(allAccountsAfter[0]).toBe(walletOneAddresses[0]);

});

it('throws error if argument password is not a string', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

});

await expect(async () =>

// @ts-expect-error Missing other required permission types.

keyringController.createNewVaultWithKeyring(12, {

type: KeyringType.HD,

opts: {

mnemonic: walletTwoSeedWords,

numberOfAccounts: 1,

},

}),

).rejects.toThrow('KeyringController - Password must be of type string.');

});

it('throws error if mnemonic passed is invalid', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

});

await expect(async () =>

keyringController.createNewVaultWithKeyring(PASSWORD, {

type: KeyringType.HD,

opts: {

mnemonic:

'test test test palace city barely security section midnight wealth south deer',

numberOfAccounts: 1,

},

}),

).rejects.toThrow(

'Eth-Hd-Keyring: Invalid secret recovery phrase provided',

);

await expect(async () =>

keyringController.createNewVaultWithKeyring(PASSWORD, {

type: KeyringType.HD,

opts: {

mnemonic: '1234',

numberOfAccounts: 1,

},

}),

).rejects.toThrow(

'Eth-Hd-Keyring: Invalid secret recovery phrase provided',

);

});

it('accepts mnemonic passed as type array of numbers', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

});

const allAccountsBefore = await keyringController.getAccounts();

expect(allAccountsBefore[0]).not.toBe(walletTwoAddresses[0]);

const mnemonicAsArrayOfNumbers = Array.from(

Buffer.from(walletTwoSeedWords).values(),

);

await keyringController.createNewVaultWithKeyring(PASSWORD, {

type: KeyringType.HD,

opts: {

mnemonic: mnemonicAsArrayOfNumbers,

numberOfAccounts: 1,

},

});

const allAccountsAfter = await keyringController.getAccounts();

expect(allAccountsAfter).toHaveLength(1);

expect(allAccountsAfter[0]).toBe(walletTwoAddresses[0]);

});

it('throws error if accounts are not created properly', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

});

jest

.spyOn(HdKeyring.prototype, 'getAccounts')

.mockImplementation(async () => Promise.resolve([]));

await expect(async () =>

keyringController.createNewVaultWithKeyring(PASSWORD, {

type: KeyringType.HD,

opts: {

mnemonic: walletTwoSeedWords,

numberOfAccounts: 1,

},

}),

).rejects.toThrow('KeyringController - First Account not found.');

});

});

describe('addNewKeyring', () => {

it('should add simple key pair', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

});

const privateKey =

'c87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3';

const previousAccounts = await keyringController.getAccounts();

const keyring = await keyringController.addNewKeyring(

KeyringType.Simple,

[privateKey],

);

const keyringAccounts = await keyring?.getAccounts();

const expectedKeyringAccounts = [

'0x627306090abab3a6e1400e9345bc60c78a8bef57',

];

expect(keyringAccounts).toStrictEqual(expectedKeyringAccounts);

const allAccounts = await keyringController.getAccounts();

const expectedAllAccounts = previousAccounts.concat(

expectedKeyringAccounts,

);

expect(allAccounts).toStrictEqual(expectedAllAccounts);

});

it('should add HD Key Tree without mnemonic passed as an argument', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

});

const previousAllAccounts = await keyringController.getAccounts();

expect(previousAllAccounts).toHaveLength(1);

const keyring = await keyringController.addNewKeyring(KeyringType.HD);

const keyringAccounts = await keyring?.getAccounts();

expect(keyringAccounts).toHaveLength(1);

const allAccounts = await keyringController.getAccounts();

expect(allAccounts).toHaveLength(2);

});

it('should add HD Key Tree with mnemonic passed as an argument', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

});

const previousAllAccounts = await keyringController.getAccounts();

expect(previousAllAccounts).toHaveLength(1);

const keyring = await keyringController.addNewKeyring(KeyringType.HD, {

numberOfAccounts: 2,

mnemonic: walletTwoSeedWords,

});

const keyringAccounts = await keyring?.getAccounts();

expect(keyringAccounts).toHaveLength(2);

expect(keyringAccounts?.[0]).toStrictEqual(walletTwoAddresses[0]);

expect(keyringAccounts?.[1]).toStrictEqual(walletTwoAddresses[1]);

const allAccounts = await keyringController.getAccounts();

expect(allAccounts).toHaveLength(3);

});

it('should add keyring that expects undefined serialized state', async () => {

let deserializedSpy = sinon.spy();

const mockKeyringBuilder = () => {

const keyring = new KeyringMockWithInit();

deserializedSpy = sinon.spy(keyring, 'deserialize');

return keyring;

};

mockKeyringBuilder.type = 'Mock Keyring';

const keyringController = await initializeKeyringController({

constructorOptions: {

keyringBuilders: [mockKeyringBuilder],

},

password: PASSWORD,

});

await keyringController.addNewKeyring('Mock Keyring');

expect(deserializedSpy.callCount).toBe(1);

expect(deserializedSpy.calledWith(undefined)).toBe(true);

});

it('should call init method if available', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

constructorOptions: {

keyringBuilders: [keyringBuilderFactory(KeyringMockWithInit)],

},

});

const initSpy = sinon.spy(KeyringMockWithInit.prototype, 'init');

const keyring = await keyringController.addNewKeyring(

'Keyring Mock With Init',

);

expect(keyring).toBeInstanceOf(KeyringMockWithInit);

sinon.assert.calledOnce(initSpy);

});

it('should add HD Key Tree when addAccounts is asynchronous', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

});

const originalAccAccounts = HdKeyring.prototype.addAccounts;

sinon.stub(HdKeyring.prototype, 'addAccounts').callsFake(async () => {

return new Promise((resolve) => {

setImmediate(() => {

resolve(originalAccAccounts.bind(this)());

});

});

});

sinon.stub(HdKeyring.prototype, 'deserialize').callsFake(async () => {

return new Promise<void>((resolve) => {

setImmediate(() => {

resolve();

});

});

});

sinon

.stub(HdKeyring.prototype, 'getAccounts')

.callsFake(() => ['mock account']);

const keyring = await keyringController.addNewKeyring(KeyringType.HD, {

mnemonic: 'mock mnemonic',

});

const keyringAccounts = await keyring?.getAccounts();

expect(keyringAccounts).toHaveLength(1);

});

});

describe('restoreKeyring', () => {

it(`should pass a keyring's serialized data back to the correct type.`, async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

});

const mockSerialized = {

type: 'HD Key Tree',

data: {

mnemonic: walletOneSeedWords,

numberOfAccounts: 1,

},

};

const keyring = await keyringController.restoreKeyring(mockSerialized);

// eslint-disable-next-line no-unsafe-optional-chaining

// @ts-expect-error this value should never be undefined in this specific context.

const { numberOfAccounts } = await keyring.serialize();

expect(numberOfAccounts).toBe(1);

const accounts = await keyring?.getAccounts();

expect(accounts?.[0]).toBe(walletOneAddresses[0]);

});

it('should return undefined if keyring type is not supported.', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

});

const unsupportedKeyring = { type: 'Ledger Keyring', data: 'DUMMY' };

const keyring = await keyringController.restoreKeyring(

unsupportedKeyring,

);

expect(keyring).toBeUndefined();

});

});

describe('getAccounts', () => {

it('returns the result of getAccounts for each keyring', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

});

keyringController.keyrings = [

{

// @ts-expect-error there's only a need to mock the getAccounts method for this test.

async getAccounts() {

return Promise.resolve([1, 2, 3]);

},

},

{

// @ts-expect-error there's only a need to mock the getAccounts method for this test.

async getAccounts() {

return Promise.resolve([4, 5, 6]);

},

},

];

const result = await keyringController.getAccounts();

expect(result).toStrictEqual([

'0x01',

'0x02',

'0x03',

'0x04',

'0x05',

'0x06',

]);

});

});

describe('removeAccount', () => {

it('removes an account from the corresponding keyring', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

});

const account: { privateKey: string; publicKey: Hex } = {

privateKey:

'c87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3',

publicKey: '0x627306090abab3a6e1400e9345bc60c78a8bef57',

};

const accountsBeforeAdding = await keyringController.getAccounts();

// Add a new keyring with one account

await keyringController.addNewKeyring(KeyringType.Simple, [

account.privateKey,

]);

expect(keyringController.keyrings).toHaveLength(2);

// remove that account that we just added

await keyringController.removeAccount(account.publicKey);

expect(keyringController.keyrings).toHaveLength(1);

// fetch accounts after removal

const result = await keyringController.getAccounts();

expect(result).toStrictEqual(accountsBeforeAdding);

});

it('removes the keyring if there are no accounts after removal', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

});

const account: { privateKey: string; publicKey: Hex } = {

privateKey:

'c87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3',

publicKey: '0x627306090abab3a6e1400e9345bc60c78a8bef57',

};

// Add a new keyring with one account

await keyringController.addNewKeyring(KeyringType.Simple, [

account.privateKey,

]);

// We should have 2 keyrings

expect(keyringController.keyrings).toHaveLength(2);

// remove that account that we just added

await keyringController.removeAccount(account.publicKey);

// Check that the previous keyring with only one account

// was also removed after removing the account

expect(keyringController.keyrings).toHaveLength(1);

});

it('calls keyring optional destroy function', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

constructorOptions: {

keyringBuilders: [keyringBuilderFactory(KeyringMockWithDestroy)],

},

});

const destroy = sinon.spy(KeyringMockWithDestroy.prototype, 'destroy');

const keyring = await keyringController.addNewKeyring(

'Keyring Mock With Destroy',

);

sinon.stub(keyringController, 'getKeyringForAccount').resolves(keyring);

await keyringController.removeAccount('0x0');

expect(destroy.calledOnce).toBe(true);

});

it('does not remove the keyring if there are accounts remaining after removing one from the keyring', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

});

// Add a new keyring with two accounts

await keyringController.addNewKeyring(KeyringType.HD, {

mnemonic: walletTwoSeedWords,

numberOfAccounts: 2,

});

// We should have 2 keyrings

expect(keyringController.keyrings).toHaveLength(2);

// remove one account from the keyring we just added

// @ts-expect-error this value should never be undefied

await keyringController.removeAccount(walletTwoAddresses[0]);

// Check that the newly added keyring was not removed after

// removing the account since it still has an account left

expect(keyringController.keyrings).toHaveLength(2);

});

it('throws an error if the keyring for the given account does not support account removal', async () => {

const mockAccount = '0x5aC6d462f054690A373Fabf8cc28E161003aEB19';

stubKeyringClassWithAccount(BaseKeyringMock, mockAccount);

const keyringController = await initializeKeyringController({

password: PASSWORD,

constructorOptions: {

keyringBuilders: [keyringBuilderFactory(BaseKeyringMock)],

},

});

await keyringController.addNewKeyring(BaseKeyringMock.type);

await expect(

keyringController.removeAccount(mockAccount),

).rejects.toThrow(KeyringControllerError.UnsupportedRemoveAccount);

});

});

describe('unlockKeyrings', () => {

it('returns the list of keyrings', async () => {

const keyringController = await initializeKeyringController({

password: PASSWORD,

});

await keyringController.setLocked();

const keyrings = await keyringController.unlockKeyrings(PASSWORD);

expect(keyrings).toHaveLength(1);

await Promise.all(

keyrings.map(async (keyring) => {

// @ts-expect-error numberOfAccounts mising in Json specification.

const { numberOfAccounts } = await keyring.serialize();

expect(numberOfAccounts).toBe(1);

}),

);

});

it('add serialized keyring to unsupportedKeyrings array if keyring type is not known', async () => {

const mockEncryptor = new MockEncryptor();

const keyringController = await initializeKeyringController({

password: PASSWORD,

constructorOptions: {

encryptor: mockEncryptor,

},

});

const unsupportedKeyrings = [{ type: 'Ledger Keyring', data: 'DUMMY' }];

await mockEncryptor.encrypt(PASSWORD, unsupportedKeyrings);

await keyringController.setLocked();

const keyrings = await keyringController.unlockKeyrings(PASSWORD);

expect(keyrings).toHaveLength(0);

expect(keyringController.unsupportedKeyrings).toStrictEqual(

unsupportedKeyrings,

);

});

it('should throw error if there is no vault', async () => {

const keyringController = new KeyringController({

cacheEncryptionKey: false,

});

await expect(async () =>

keyringController.unlockKeyrings(PASSWORD),

).rejects.toThrow(KeyringControllerError.VaultError);

});

it('should throw error if decrypted vault is not an array of serialized keyrings', async () => {

const mockEncryptor = new MockEncryptor();

sinon

.stub(mockEncryptor, 'decrypt')

.resolves('[{"foo": "not a valid keyring}]');

const keyringController = await initializeKeyringController({

password: PASSWORD,

constructorOptions: {

encryptor: mockEncryptor,

},

});

await expect(async () =>

keyringController.unlockKeyrings(PASSWORD),

).rejects.toThrow(KeyringControllerError.VaultDataError);

});

it('should throw error if decrypted vault includes an invalid keyring', async () => {

const mockEncryptor = new MockEncryptor();

sinon

.stub(mockEncryptor, 'decrypt')

.resolves([{ foo: 'not a valid keyring' }]);

const keyringController = await initializeKeyringController({

password: PASSWORD,

constructorOptions: {

encryptor: mockEncryptor,

},

});

await expect(async () =>

keyringController.unlockKeyrings(PASSWORD),

).rejects.toThrow(KeyringControllerError.VaultDataError);

});

describe('with old vault format', () => {

describe(`with cacheEncryptionKey = true and encryptionKey is unset`, () => {

it('should update the vault', async () => {

const mockEncryptor = new MockEncryptor();

const keyringController = await initializeKeyringController({

password: PASSWORD,

constructorOptions: {

cacheEncryptionKey: true,

encryptor: mockEncryptor,

},

});

deleteEncryptionKeyAndSalt(keyringController);

const initialVault = keyringController.store.getState().vault;

const mockEncryptionResult = {

data: '0x1234',

iv: 'an iv',

};

sinon.stub(mockEncryptor, 'isVaultUpdated').returns(false);

sinon

.stub(mockEncryptor, 'encryptWithKey')

.resolves(mockEncryptionResult);

await keyringController.unlockKeyrings(PASSWORD);

const updatedVault = keyringController.store.getState().vault;

expect(initialVault).not.toBe(updatedVault);

expect(updatedVault).toBe(

JSON.stringify({

...mockEncryptionResult,

salt: MOCK_ENCRYPTION_SALT,

}),

);