@metamask-previews/keyring-controller 12.0.0-preview.d357889 → 12.2.0-preview.0a7589e7

package/dist/KeyringController.js

@@ -42,15 +42,22 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _KeyringController_instances, _KeyringController_keyring, _KeyringController_qrKeyringStateListener, _KeyringController_registerMessageHandlers, _KeyringController_addQRKeyring, _KeyringController_subscribeToQRKeyringEvents, _KeyringController_unsubscribeFromQRKeyringsEvents, _KeyringController_fullUpdate, _KeyringController_handleLock, _KeyringController_handleUnlock, _KeyringController_getMemState;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _KeyringController_instances, _KeyringController_keyringBuilders, _KeyringController_keyrings, _KeyringController_unsupportedKeyrings, _KeyringController_password, _KeyringController_encryptor, _KeyringController_cacheEncryptionKey, _KeyringController_qrKeyringStateListener, _KeyringController_registerMessageHandlers, _KeyringController_getKeyringBuilderForType, _KeyringController_addQRKeyring, _KeyringController_subscribeToQRKeyringEvents, _KeyringController_unsubscribeFromQRKeyringsEvents, _KeyringController_createNewVaultWithKeyring, _KeyringController_updateKeyringsInState, _KeyringController_unlockKeyrings, _KeyringController_createKeyringWithFirstAccount, _KeyringController_newKeyring, _KeyringController_clearKeyrings, _KeyringController_restoreKeyring, _KeyringController_destroyKeyring, _KeyringController_removeEmptyKeyrings, _KeyringController_checkForDuplicate, _KeyringController_setUnlocked, _KeyringController_getMemState;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KeyringController = exports.SignTypedDataVersion = exports.AccountImportStrategy = exports.KeyringTypes = void 0;
+exports.KeyringController = exports.getDefaultKeyringState = exports.keyringBuilderFactory = exports.SignTypedDataVersion = exports.AccountImportStrategy = exports.isCustodyKeyring = exports.KeyringTypes = void 0;
+const util_1 = require("@ethereumjs/util");
 const base_controller_1 = require("@metamask/base-controller");
-const eth_keyring_controller_1 = require("@metamask/eth-keyring-controller");
+const encryptorUtils = __importStar(require("@metamask/browser-passworder"));
+const eth_hd_keyring_1 = __importDefault(require("@metamask/eth-hd-keyring"));
+const eth_sig_util_1 = require("@metamask/eth-sig-util");
+const eth_simple_keyring_1 = __importDefault(require("@metamask/eth-simple-keyring"));
 const utils_1 = require("@metamask/utils");
 const async_mutex_1 = require("async-mutex");
-const ethereumjs_util_1 = require("ethereumjs-util");
 const ethereumjs_wallet_1 = __importStar(require("ethereumjs-wallet"));
+const constants_1 = require("./constants");
 const name = 'KeyringController';
 /**
  * Available keyring types
@@ -64,8 +71,17 @@ var KeyringTypes;
     KeyringTypes["ledger"] = "Ledger Hardware";
     KeyringTypes["lattice"] = "Lattice Hardware";
     KeyringTypes["snap"] = "Snap Keyring";
-    KeyringTypes["custody"] = "Custody";
 })(KeyringTypes = exports.KeyringTypes || (exports.KeyringTypes = {}));
+/**
+ * Custody keyring types are a special case, as they are not a single type
+ * but they all start with the prefix "Custody".
+ * @param keyringType - The type of the keyring.
+ * @returns Whether the keyring type is a custody keyring.
+ */
+const isCustodyKeyring = (keyringType) => {
+    return keyringType.startsWith('Custody');
+};
+exports.isCustodyKeyring = isCustodyKeyring;
 /**
  * A strategy for importing an account
  */
@@ -85,10 +101,31 @@ var SignTypedDataVersion;
     SignTypedDataVersion["V3"] = "V3";
     SignTypedDataVersion["V4"] = "V4";
 })(SignTypedDataVersion = exports.SignTypedDataVersion || (exports.SignTypedDataVersion = {}));
-const defaultState = {
-    isUnlocked: false,
-    keyrings: [],
+/**
+ * Get builder function for `Keyring`
+ *
+ * Returns a builder function for `Keyring` with a `type` property.
+ *
+ * @param KeyringConstructor - The Keyring class for the builder.
+ * @returns A builder function for the given Keyring.
+ */
+function keyringBuilderFactory(KeyringConstructor) {
+    const builder = () => new KeyringConstructor();
+    builder.type = KeyringConstructor.type;
+    return builder;
+}
+exports.keyringBuilderFactory = keyringBuilderFactory;
+const defaultKeyringBuilders = [
+    keyringBuilderFactory(eth_simple_keyring_1.default),
+    keyringBuilderFactory(eth_hd_keyring_1.default),
+];
+const getDefaultKeyringState = () => {
+    return {
+        isUnlocked: false,
+        keyrings: [],
+    };
 };
+exports.getDefaultKeyringState = getDefaultKeyringState;
 /**
  * Assert that the given keyring has an exportable
  * mnemonic.
@@ -101,6 +138,53 @@ function assertHasUint8ArrayMnemonic(keyring) {
         throw new Error("Can't get mnemonic bytes from keyring");
     }
 }
+/**
+ * Assert that the provided encryptor supports
+ * encryption and encryption key export.
+ *
+ * @param encryptor - The encryptor to check.
+ * @throws If the encryptor does not support key encryption.
+ */
+function assertIsExportableKeyEncryptor(encryptor) {
+    if (!('importKey' in encryptor &&
+        typeof encryptor.importKey === 'function' &&
+        'decryptWithKey' in encryptor &&
+        typeof encryptor.decryptWithKey === 'function' &&
+        'encryptWithKey' in encryptor &&
+        typeof encryptor.encryptWithKey === 'function')) {
+        throw new Error(constants_1.KeyringControllerError.UnsupportedEncryptionKeyExport);
+    }
+}
+/**
+ * Checks if the provided value is a serialized keyrings array.
+ *
+ * @param array - The value to check.
+ * @returns True if the value is a serialized keyrings array.
+ */
+function isSerializedKeyringsArray(array) {
+    return (typeof array === 'object' &&
+        Array.isArray(array) &&
+        array.every((value) => value.type && (0, utils_1.isValidJson)(value.data)));
+}
+/**
+ * Display For Keyring
+ *
+ * Is used for adding the current keyrings to the state object.
+ *
+ * @param keyring - The keyring to display.
+ * @returns A keyring display object, with type and accounts properties.
+ */
+function displayForKeyring(keyring) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const accounts = yield keyring.getAccounts();
+        return {
+            type: keyring.type,
+            // Cast to `Hex[]` here is safe here because `accounts` has no nullish
+            // values, and `normalize` returns `Hex` unless given a nullish value
+            accounts: accounts.map(eth_sig_util_1.normalize),
+        };
+    });
+}
 /**
  * Controller responsible for establishing and managing user identity.
  *
@@ -115,10 +199,6 @@ class KeyringController extends base_controller_1.BaseController {
      * Creates a KeyringController instance.
      *
      * @param options - Initial options used to configure this controller
-     * @param options.syncIdentities - Sync identities with the given list of addresses.
-     * @param options.updateIdentities - Generate an identity for each address given that doesn't already have an identity.
-     * @param options.setSelectedAddress - Set the selected address.
-     * @param options.setAccountLabel - Set a new name for account.
      * @param options.encryptor - An optional object for defining encryption schemes.
      * @param options.keyringBuilders - Set a new name for account.
      * @param options.cacheEncryptionKey - Whether to cache or not encryption key.
@@ -126,8 +206,7 @@ class KeyringController extends base_controller_1.BaseController {
      * @param options.state - Initial state to set on this controller.
      */
     constructor(options) {
-        var _a;
-        const { syncIdentities, updateIdentities, setSelectedAddress, setAccountLabel, keyringBuilders, messenger, state, } = options;
+        const { encryptor = encryptorUtils, keyringBuilders, messenger, state, } = options;
         super({
             name,
             metadata: {
@@ -138,36 +217,29 @@ class KeyringController extends base_controller_1.BaseController {
                 encryptionSalt: { persist: false, anonymous: false },
             },
             messenger,
-            state: Object.assign(Object.assign({}, defaultState), state),
+            state: Object.assign(Object.assign({}, (0, exports.getDefaultKeyringState)()), state),
         });
         _KeyringController_instances.add(this);
         this.mutex = new async_mutex_1.Mutex();
-        _KeyringController_keyring.set(this, void 0);
+        _KeyringController_keyringBuilders.set(this, void 0);
+        _KeyringController_keyrings.set(this, void 0);
+        _KeyringController_unsupportedKeyrings.set(this, void 0);
+        _KeyringController_password.set(this, void 0);
+        _KeyringController_encryptor.set(this, void 0);
+        _KeyringController_cacheEncryptionKey.set(this, void 0);
         _KeyringController_qrKeyringStateListener.set(this, void 0);
-        if (options.cacheEncryptionKey) {
-            __classPrivateFieldSet(this, _KeyringController_keyring, new eth_keyring_controller_1.KeyringController({
-                initState: state,
-                encryptor: options.encryptor,
-                keyringBuilders,
-                cacheEncryptionKey: options.cacheEncryptionKey,
-            }), "f");
+        __classPrivateFieldSet(this, _KeyringController_keyringBuilders, keyringBuilders
+            ? defaultKeyringBuilders.concat(keyringBuilders)
+            : defaultKeyringBuilders, "f");
+        __classPrivateFieldSet(this, _KeyringController_encryptor, encryptor, "f");
+        __classPrivateFieldSet(this, _KeyringController_keyrings, [], "f");
+        __classPrivateFieldSet(this, _KeyringController_unsupportedKeyrings, [], "f");
+        // This option allows the controller to cache an exported key
+        // for use in decrypting and encrypting data without password
+        __classPrivateFieldSet(this, _KeyringController_cacheEncryptionKey, Boolean(options.cacheEncryptionKey), "f");
+        if (__classPrivateFieldGet(this, _KeyringController_cacheEncryptionKey, "f")) {
+            assertIsExportableKeyEncryptor(encryptor);
         }
-        else {
-            __classPrivateFieldSet(this, _KeyringController_keyring, new eth_keyring_controller_1.KeyringController({
-                initState: state,
-                encryptor: options.encryptor,
-                keyringBuilders,
-                cacheEncryptionKey: (_a = options.cacheEncryptionKey) !== null && _a !== void 0 ? _a : false,
-            }), "f");
-        }
-        __classPrivateFieldGet(this, _KeyringController_keyring, "f").memStore.subscribe(__classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_fullUpdate).bind(this));
-        __classPrivateFieldGet(this, _KeyringController_keyring, "f").store.subscribe(__classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_fullUpdate).bind(this));
-        __classPrivateFieldGet(this, _KeyringController_keyring, "f").on('lock', __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_handleLock).bind(this));
-        __classPrivateFieldGet(this, _KeyringController_keyring, "f").on('unlock', __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_handleUnlock).bind(this));
-        this.syncIdentities = syncIdentities;
-        this.updateIdentities = updateIdentities;
-        this.setSelectedAddress = setSelectedAddress;
-        this.setAccountLabel = setAccountLabel;
         __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_registerMessageHandlers).call(this);
     }
     /**
@@ -180,12 +252,11 @@ class KeyringController extends base_controller_1.BaseController {
      */
     addNewAccount(accountCount) {
         return __awaiter(this, void 0, void 0, function* () {
-            const primaryKeyring = __classPrivateFieldGet(this, _KeyringController_keyring, "f").getKeyringsByType('HD Key Tree')[0];
-            /* istanbul ignore if */
+            const primaryKeyring = this.getKeyringsByType('HD Key Tree')[0];
             if (!primaryKeyring) {
                 throw new Error('No HD keyring found');
             }
-            const oldAccounts = yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").getAccounts();
+            const oldAccounts = yield this.getAccounts();
             if (accountCount && oldAccounts.length !== accountCount) {
                 if (accountCount > oldAccounts.length) {
                     throw new Error('Account out of sequence');
@@ -197,12 +268,8 @@ class KeyringController extends base_controller_1.BaseController {
                     addedAccountAddress: primaryKeyringAccounts[accountCount],
                 };
             }
-            yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").addNewAccount(primaryKeyring);
-            const newAccounts = yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").getAccounts();
+            const addedAccountAddress = yield this.addNewAccountForKeyring(primaryKeyring);
             yield this.verifySeedPhrase();
-            this.updateIdentities(newAccounts);
-            const addedAccountAddress = newAccounts.find((selectedAddress) => !oldAccounts.includes(selectedAddress));
-            (0, utils_1.assertIsStrictHexString)(addedAccountAddress);
             return {
                 keyringState: __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getMemState).call(this),
                 addedAccountAddress,
@@ -227,10 +294,10 @@ class KeyringController extends base_controller_1.BaseController {
                 (0, utils_1.assertIsStrictHexString)(existingAccount);
                 return existingAccount;
             }
-            yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").addNewAccount(keyring);
+            yield keyring.addAccounts(1);
+            yield this.persistAllKeyrings();
             const addedAccountAddress = (yield this.getAccounts()).find((selectedAddress) => !oldAccounts.includes(selectedAddress));
             (0, utils_1.assertIsStrictHexString)(addedAccountAddress);
-            this.updateIdentities(yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").getAccounts());
             return addedAccountAddress;
         });
     }
@@ -241,12 +308,12 @@ class KeyringController extends base_controller_1.BaseController {
      */
     addNewAccountWithoutUpdate() {
         return __awaiter(this, void 0, void 0, function* () {
-            const primaryKeyring = __classPrivateFieldGet(this, _KeyringController_keyring, "f").getKeyringsByType('HD Key Tree')[0];
-            /* istanbul ignore if */
+            const primaryKeyring = this.getKeyringsByType('HD Key Tree')[0];
             if (!primaryKeyring) {
                 throw new Error('No HD keyring found');
             }
-            yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").addNewAccount(primaryKeyring);
+            yield primaryKeyring.addAccounts(1);
+            yield this.persistAllKeyrings();
             yield this.verifySeedPhrase();
             return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getMemState).call(this);
         });
@@ -267,9 +334,13 @@ class KeyringController extends base_controller_1.BaseController {
                 throw new Error('Invalid password');
             }
             try {
-                this.updateIdentities([]);
-                yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").createNewVaultAndRestore(password, seed);
-                this.updateIdentities(yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").getAccounts());
+                yield __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_createNewVaultWithKeyring).call(this, password, {
+                    type: KeyringTypes.hd,
+                    opts: {
+                        mnemonic: seed,
+                        numberOfAccounts: 1,
+                    },
+                });
                 return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getMemState).call(this);
             }
             finally {
@@ -289,8 +360,9 @@ class KeyringController extends base_controller_1.BaseController {
             try {
                 const accounts = yield this.getAccounts();
                 if (!accounts.length) {
-                    yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").createNewVaultAndKeychain(password);
-                    this.updateIdentities(yield this.getAccounts());
+                    yield __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_createNewVaultWithKeyring).call(this, password, {
+                        type: KeyringTypes.hd,
+                    });
                 }
                 return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getMemState).call(this);
             }
@@ -312,7 +384,19 @@ class KeyringController extends base_controller_1.BaseController {
             if (type === KeyringTypes.qr) {
                 return this.getOrAddQRKeyring();
             }
-            return __classPrivateFieldGet(this, _KeyringController_keyring, "f").addNewKeyring(type, opts);
+            const keyring = yield __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_newKeyring).call(this, type, opts);
+            if (type === KeyringTypes.hd && (!(0, utils_1.isObject)(opts) || !opts.mnemonic)) {
+                if (!keyring.generateRandomMnemonic) {
+                    throw new Error(constants_1.KeyringControllerError.UnsupportedGenerateRandomMnemonic);
+                }
+                keyring.generateRandomMnemonic();
+                yield keyring.addAccounts(1);
+            }
+            const accounts = yield keyring.getAccounts();
+            yield __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_checkForDuplicate).call(this, type, accounts);
+            __classPrivateFieldGet(this, _KeyringController_keyrings, "f").push(keyring);
+            yield this.persistAllKeyrings();
+            return keyring;
         });
     }
     /**
@@ -323,7 +407,10 @@ class KeyringController extends base_controller_1.BaseController {
      */
     verifyPassword(password) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").verifyPassword(password);
+            if (!this.state.vault) {
+                throw new Error(constants_1.KeyringControllerError.VaultError);
+            }
+            yield __classPrivateFieldGet(this, _KeyringController_encryptor, "f").decrypt(password, this.state.vault);
         });
     }
     /**
@@ -343,8 +430,8 @@ class KeyringController extends base_controller_1.BaseController {
     exportSeedPhrase(password) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.verifyPassword(password);
-            assertHasUint8ArrayMnemonic(__classPrivateFieldGet(this, _KeyringController_keyring, "f").keyrings[0]);
-            return __classPrivateFieldGet(this, _KeyringController_keyring, "f").keyrings[0].mnemonic;
+            assertHasUint8ArrayMnemonic(__classPrivateFieldGet(this, _KeyringController_keyrings, "f")[0]);
+            return __classPrivateFieldGet(this, _KeyringController_keyrings, "f")[0].mnemonic;
         });
     }
     /**
@@ -357,7 +444,11 @@ class KeyringController extends base_controller_1.BaseController {
     exportAccount(password, address) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.verifyPassword(password);
-            return __classPrivateFieldGet(this, _KeyringController_keyring, "f").exportAccount(address);
+            const keyring = (yield this.getKeyringForAccount(address));
+            if (!keyring.exportAccount) {
+                throw new Error(constants_1.KeyringControllerError.UnsupportedExportAccount);
+            }
+            return yield keyring.exportAccount((0, eth_sig_util_1.normalize)(address));
         });
     }
     /**
@@ -366,7 +457,16 @@ class KeyringController extends base_controller_1.BaseController {
      * @returns A promise resolving to an array of addresses.
      */
     getAccounts() {
-        return __classPrivateFieldGet(this, _KeyringController_keyring, "f").getAccounts();
+        return __awaiter(this, void 0, void 0, function* () {
+            const keyrings = __classPrivateFieldGet(this, _KeyringController_keyrings, "f");
+            const keyringArrays = yield Promise.all(keyrings.map((keyring) => __awaiter(this, void 0, void 0, function* () { return keyring.getAccounts(); })));
+            const addresses = keyringArrays.reduce((res, arr) => {
+                return res.concat(arr);
+            }, []);
+            // Cast to `Hex[]` here is safe here because `addresses` has no nullish
+            // values, and `normalize` returns `Hex` unless given a nullish value
+            return addresses.map(eth_sig_util_1.normalize);
+        });
     }
     /**
      * Get encryption public key.
@@ -378,7 +478,12 @@ class KeyringController extends base_controller_1.BaseController {
      */
     getEncryptionPublicKey(account, opts) {
         return __awaiter(this, void 0, void 0, function* () {
-            return __classPrivateFieldGet(this, _KeyringController_keyring, "f").getEncryptionPublicKey(account, opts);
+            const normalizedAddress = (0, eth_sig_util_1.normalize)(account);
+            const keyring = (yield this.getKeyringForAccount(account));
+            if (!keyring.getEncryptionPublicKey) {
+                throw new Error(constants_1.KeyringControllerError.UnsupportedGetEncryptionPublicKey);
+            }
+            return yield keyring.getEncryptionPublicKey(normalizedAddress, opts);
         });
     }
     /**
@@ -391,7 +496,12 @@ class KeyringController extends base_controller_1.BaseController {
      */
     decryptMessage(messageParams) {
         return __awaiter(this, void 0, void 0, function* () {
-            return __classPrivateFieldGet(this, _KeyringController_keyring, "f").decryptMessage(messageParams);
+            const address = (0, eth_sig_util_1.normalize)(messageParams.from);
+            const keyring = (yield this.getKeyringForAccount(address));
+            if (!keyring.decryptMessage) {
+                throw new Error(constants_1.KeyringControllerError.UnsupportedDecryptMessage);
+            }
+            return keyring.decryptMessage(address, messageParams.data);
         });
     }
     /**
@@ -405,8 +515,33 @@ class KeyringController extends base_controller_1.BaseController {
      * @returns Promise resolving to keyring of the `account` if one exists.
      */
     getKeyringForAccount(account) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            return __classPrivateFieldGet(this, _KeyringController_keyring, "f").getKeyringForAccount(account);
+            // Cast to `Hex` here is safe here because `address` is not nullish.
+            // `normalizeToHex` returns `Hex` unless given a nullish value.
+            const hexed = (0, eth_sig_util_1.normalize)(account);
+            const candidates = yield Promise.all(__classPrivateFieldGet(this, _KeyringController_keyrings, "f").map((keyring) => __awaiter(this, void 0, void 0, function* () {
+                return Promise.all([keyring, keyring.getAccounts()]);
+            })));
+            const winners = candidates.filter((candidate) => {
+                const accounts = candidate[1].map(eth_sig_util_1.normalize);
+                return accounts.includes(hexed);
+            });
+            if (winners.length && ((_a = winners[0]) === null || _a === void 0 ? void 0 : _a.length)) {
+                return winners[0][0];
+            }
+            // Adding more info to the error
+            let errorInfo = '';
+            if (!(0, utils_1.isValidHexAddress)(hexed)) {
+                errorInfo = 'The address passed in is invalid/empty';
+            }
+            else if (!candidates.length) {
+                errorInfo = 'There are no keyrings';
+            }
+            else if (!winners.length) {
+                errorInfo = 'There are keyrings, but none match the address';
+            }
+            throw new Error(`${constants_1.KeyringControllerError.NoKeyring}. Error info: ${errorInfo}`);
         });
     }
     /**
@@ -419,7 +554,7 @@ class KeyringController extends base_controller_1.BaseController {
      * @returns An array of keyrings of the given type.
      */
     getKeyringsByType(type) {
-        return __classPrivateFieldGet(this, _KeyringController_keyring, "f").getKeyringsByType(type);
+        return __classPrivateFieldGet(this, _KeyringController_keyrings, "f").filter((keyring) => keyring.type === type);
     }
     /**
      * Persist all serialized keyrings in the vault.
@@ -429,7 +564,58 @@ class KeyringController extends base_controller_1.BaseController {
      */
     persistAllKeyrings() {
         return __awaiter(this, void 0, void 0, function* () {
-            return __classPrivateFieldGet(this, _KeyringController_keyring, "f").persistAllKeyrings();
+            const { encryptionKey, encryptionSalt } = this.state;
+            if (!__classPrivateFieldGet(this, _KeyringController_password, "f") && !encryptionKey) {
+                throw new Error(constants_1.KeyringControllerError.MissingCredentials);
+            }
+            const serializedKeyrings = yield Promise.all(__classPrivateFieldGet(this, _KeyringController_keyrings, "f").map((keyring) => __awaiter(this, void 0, void 0, function* () {
+                const [type, data] = yield Promise.all([
+                    keyring.type,
+                    keyring.serialize(),
+                ]);
+                return { type, data };
+            })));
+            serializedKeyrings.push(...__classPrivateFieldGet(this, _KeyringController_unsupportedKeyrings, "f"));
+            let vault;
+            let newEncryptionKey;
+            if (__classPrivateFieldGet(this, _KeyringController_cacheEncryptionKey, "f")) {
+                assertIsExportableKeyEncryptor(__classPrivateFieldGet(this, _KeyringController_encryptor, "f"));
+                if (encryptionKey) {
+                    const key = yield __classPrivateFieldGet(this, _KeyringController_encryptor, "f").importKey(encryptionKey);
+                    const vaultJSON = yield __classPrivateFieldGet(this, _KeyringController_encryptor, "f").encryptWithKey(key, serializedKeyrings);
+                    vaultJSON.salt = encryptionSalt;
+                    vault = JSON.stringify(vaultJSON);
+                }
+                else if (__classPrivateFieldGet(this, _KeyringController_password, "f")) {
+                    const { vault: newVault, exportedKeyString } = yield __classPrivateFieldGet(this, _KeyringController_encryptor, "f").encryptWithDetail(__classPrivateFieldGet(this, _KeyringController_password, "f"), serializedKeyrings);
+                    vault = newVault;
+                    newEncryptionKey = exportedKeyString;
+                }
+            }
+            else {
+                if (typeof __classPrivateFieldGet(this, _KeyringController_password, "f") !== 'string') {
+                    throw new TypeError(constants_1.KeyringControllerError.WrongPasswordType);
+                }
+                vault = yield __classPrivateFieldGet(this, _KeyringController_encryptor, "f").encrypt(__classPrivateFieldGet(this, _KeyringController_password, "f"), serializedKeyrings);
+            }
+            if (!vault) {
+                throw new Error(constants_1.KeyringControllerError.MissingVaultData);
+            }
+            this.update((state) => {
+                state.vault = vault;
+            });
+            // The keyring updates need to be announced before updating the encryptionKey
+            // so that the updated keyring gets propagated to the extension first.
+            // Not calling {@link updateKeyringsInState} results in the wrong account being selected
+            // in the extension.
+            yield __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_updateKeyringsInState).call(this);
+            if (newEncryptionKey) {
+                this.update((state) => {
+                    state.encryptionKey = newEncryptionKey;
+                    state.encryptionSalt = JSON.parse(vault).salt;
+                });
+            }
+            return true;
         });
     }
     /**
@@ -453,21 +639,20 @@ class KeyringController extends base_controller_1.BaseController {
                     if (!importedKey) {
                         throw new Error('Cannot import an empty key.');
                     }
-                    const prefixed = (0, ethereumjs_util_1.addHexPrefix)(importedKey);
+                    const prefixed = (0, utils_1.add0x)(importedKey);
                     let bufferedPrivateKey;
                     try {
-                        bufferedPrivateKey = (0, ethereumjs_util_1.toBuffer)(prefixed);
+                        bufferedPrivateKey = (0, util_1.toBuffer)(prefixed);
                     }
                     catch (_a) {
                         throw new Error('Cannot import invalid private key.');
                     }
-                    /* istanbul ignore if */
-                    if (!(0, ethereumjs_util_1.isValidPrivate)(bufferedPrivateKey) ||
+                    if (!(0, util_1.isValidPrivate)(bufferedPrivateKey) ||
                         // ensures that the key is 64 bytes long
-                        (0, ethereumjs_util_1.getBinarySize)(prefixed) !== 64 + '0x'.length) {
+                        (0, util_1.getBinarySize)(prefixed) !== 64 + '0x'.length) {
                         throw new Error('Cannot import invalid private key.');
                     }
-                    privateKey = (0, ethereumjs_util_1.stripHexPrefix)(prefixed);
+                    privateKey = (0, utils_1.remove0x)(prefixed);
                     break;
                 case 'json':
                     let wallet;
@@ -478,17 +663,15 @@ class KeyringController extends base_controller_1.BaseController {
                     catch (e) {
                         wallet = wallet || (yield ethereumjs_wallet_1.default.fromV3(input, password, true));
                     }
-                    privateKey = (0, ethereumjs_util_1.bufferToHex)(wallet.getPrivateKey());
+                    privateKey = (0, utils_1.bytesToHex)(wallet.getPrivateKey());
                     break;
                 default:
                     throw new Error(`Unexpected import strategy: '${strategy}'`);
             }
-            const newKeyring = yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").addNewKeyring(KeyringTypes.simple, [
+            const newKeyring = (yield this.addNewKeyring(KeyringTypes.simple, [
                 privateKey,
-            ]);
+            ]));
             const accounts = yield newKeyring.getAccounts();
-            const allAccounts = yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").getAccounts();
-            this.updateIdentities(allAccounts);
             return {
                 keyringState: __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getMemState).call(this),
                 importedAccountAddress: accounts[0],
@@ -504,7 +687,21 @@ class KeyringController extends base_controller_1.BaseController {
      */
     removeAccount(address) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").removeAccount(address);
+            const keyring = (yield this.getKeyringForAccount(address));
+            // Not all the keyrings support this, so we have to check
+            if (!keyring.removeAccount) {
+                throw new Error(constants_1.KeyringControllerError.UnsupportedRemoveAccount);
+            }
+            // The `removeAccount` method of snaps keyring is async. We have to update
+            // the interface of the other keyrings to be async as well.
+            // eslint-disable-next-line @typescript-eslint/await-thenable
+            yield keyring.removeAccount(address);
+            const accounts = yield keyring.getAccounts();
+            // Check if this was the last/only account
+            if (accounts.length === 0) {
+                yield __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_removeEmptyKeyrings).call(this);
+            }
+            yield this.persistAllKeyrings();
             this.messagingSystem.publish(`${name}:accountRemoved`, address);
             return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getMemState).call(this);
         });
@@ -517,7 +714,13 @@ class KeyringController extends base_controller_1.BaseController {
     setLocked() {
         return __awaiter(this, void 0, void 0, function* () {
             __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_unsubscribeFromQRKeyringsEvents).call(this);
-            yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").setLocked();
+            __classPrivateFieldSet(this, _KeyringController_password, undefined, "f");
+            this.update((state) => {
+                state.isUnlocked = false;
+                state.keyrings = [];
+            });
+            yield __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_clearKeyrings).call(this);
+            this.messagingSystem.publish(`${name}:lock`);
             return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getMemState).call(this);
         });
     }
@@ -528,10 +731,17 @@ class KeyringController extends base_controller_1.BaseController {
      * @returns Promise resolving to a signed message string.
      */
     signMessage(messageParams) {
-        if (!messageParams.data) {
-            throw new Error("Can't sign an empty message");
-        }
-        return __classPrivateFieldGet(this, _KeyringController_keyring, "f").signMessage(messageParams);
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!messageParams.data) {
+                throw new Error("Can't sign an empty message");
+            }
+            const address = (0, eth_sig_util_1.normalize)(messageParams.from);
+            const keyring = (yield this.getKeyringForAccount(address));
+            if (!keyring.signMessage) {
+                throw new Error(constants_1.KeyringControllerError.UnsupportedSignMessage);
+            }
+            return yield keyring.signMessage(address, messageParams.data);
+        });
     }
     /**
      * Signs personal message by calling down into a specific keyring.
@@ -540,7 +750,15 @@ class KeyringController extends base_controller_1.BaseController {
      * @returns Promise resolving to a signed message string.
      */
     signPersonalMessage(messageParams) {
-        return __classPrivateFieldGet(this, _KeyringController_keyring, "f").signPersonalMessage(messageParams);
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = (0, eth_sig_util_1.normalize)(messageParams.from);
+            const keyring = (yield this.getKeyringForAccount(address));
+            if (!keyring.signPersonalMessage) {
+                throw new Error(constants_1.KeyringControllerError.UnsupportedSignPersonalMessage);
+            }
+            const normalizedData = (0, eth_sig_util_1.normalize)(messageParams.data);
+            return yield keyring.signPersonalMessage(address, normalizedData);
+        });
     }
     /**
      * Signs typed message by calling down into a specific keyring.
@@ -560,13 +778,17 @@ class KeyringController extends base_controller_1.BaseController {
                 ].includes(version)) {
                     throw new Error(`Unexpected signTypedMessage version: '${version}'`);
                 }
-                return yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").signTypedMessage({
-                    from: messageParams.from,
-                    data: version !== SignTypedDataVersion.V1 &&
-                        typeof messageParams.data === 'string'
-                        ? JSON.parse(messageParams.data)
-                        : messageParams.data,
-                }, { version });
+                // Cast to `Hex` here is safe here because `messageParams.from` is not nullish.
+                // `normalize` returns `Hex` unless given a nullish value.
+                const address = (0, eth_sig_util_1.normalize)(messageParams.from);
+                const keyring = (yield this.getKeyringForAccount(address));
+                if (!keyring.signTypedData) {
+                    throw new Error(constants_1.KeyringControllerError.UnsupportedSignTypedMessage);
+                }
+                return yield keyring.signTypedData(address, version !== SignTypedDataVersion.V1 &&
+                    typeof messageParams.data === 'string'
+                    ? JSON.parse(messageParams.data)
+                    : messageParams.data, { version });
             }
             catch (error) {
                 throw new Error(`Keyring Controller signTypedMessage: ${error}`);
@@ -582,7 +804,66 @@ class KeyringController extends base_controller_1.BaseController {
      * @returns Promise resolving to a signed transaction string.
      */
     signTransaction(transaction, from, opts) {
-        return __classPrivateFieldGet(this, _KeyringController_keyring, "f").signTransaction(transaction, from, opts);
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = (0, eth_sig_util_1.normalize)(from);
+            const keyring = (yield this.getKeyringForAccount(address));
+            if (!keyring.signTransaction) {
+                throw new Error(constants_1.KeyringControllerError.UnsupportedSignTransaction);
+            }
+            return yield keyring.signTransaction(address, transaction, opts);
+        });
+    }
+    /**
+     * Convert a base transaction to a base UserOperation.
+     *
+     * @param from - Address of the sender.
+     * @param transactions - Base transactions to include in the UserOperation.
+     * @returns A pseudo-UserOperation that can be used to construct a real.
+     */
+    prepareUserOperation(from, transactions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = (0, eth_sig_util_1.normalize)(from);
+            const keyring = (yield this.getKeyringForAccount(address));
+            if (!keyring.prepareUserOperation) {
+                throw new Error(constants_1.KeyringControllerError.UnsupportedPrepareUserOperation);
+            }
+            return yield keyring.prepareUserOperation(address, transactions);
+        });
+    }
+    /**
+     * Patches properties of a UserOperation. Currently, only the
+     * `paymasterAndData` can be patched.
+     *
+     * @param from - Address of the sender.
+     * @param userOp - UserOperation to patch.
+     * @returns A patch to apply to the UserOperation.
+     */
+    patchUserOperation(from, userOp) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = (0, eth_sig_util_1.normalize)(from);
+            const keyring = (yield this.getKeyringForAccount(address));
+            if (!keyring.patchUserOperation) {
+                throw new Error(constants_1.KeyringControllerError.UnsupportedPatchUserOperation);
+            }
+            return yield keyring.patchUserOperation(address, userOp);
+        });
+    }
+    /**
+     * Signs an UserOperation.
+     *
+     * @param from - Address of the sender.
+     * @param userOp - UserOperation to sign.
+     * @returns The signature of the UserOperation.
+     */
+    signUserOperation(from, userOp) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = (0, eth_sig_util_1.normalize)(from);
+            const keyring = (yield this.getKeyringForAccount(address));
+            if (!keyring.signUserOperation) {
+                throw new Error(constants_1.KeyringControllerError.UnsupportedSignUserOperation);
+            }
+            return yield keyring.signUserOperation(address, userOp);
+        });
     }
     /**
      * Attempts to decrypt the current vault and load its keyrings,
@@ -594,7 +875,8 @@ class KeyringController extends base_controller_1.BaseController {
      */
     submitEncryptionKey(encryptionKey, encryptionSalt) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").submitEncryptionKey(encryptionKey, encryptionSalt);
+            __classPrivateFieldSet(this, _KeyringController_keyrings, yield __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_unlockKeyrings).call(this, undefined, encryptionKey, encryptionSalt), "f");
+            __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_setUnlocked).call(this);
             const qrKeyring = this.getQRKeyring();
             if (qrKeyring) {
                 // if there is a QR keyring, we need to subscribe
@@ -613,15 +895,14 @@ class KeyringController extends base_controller_1.BaseController {
      */
     submitPassword(password) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").submitPassword(password);
-            const accounts = yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").getAccounts();
+            __classPrivateFieldSet(this, _KeyringController_keyrings, yield __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_unlockKeyrings).call(this, password), "f");
+            __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_setUnlocked).call(this);
             const qrKeyring = this.getQRKeyring();
             if (qrKeyring) {
                 // if there is a QR keyring, we need to subscribe
                 // to its events after unlocking the vault
                 __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_subscribeToQRKeyringEvents).call(this, qrKeyring);
             }
-            yield this.syncIdentities(accounts);
             return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getMemState).call(this);
         });
     }
@@ -632,8 +913,7 @@ class KeyringController extends base_controller_1.BaseController {
      */
     verifySeedPhrase() {
         return __awaiter(this, void 0, void 0, function* () {
-            const primaryKeyring = __classPrivateFieldGet(this, _KeyringController_keyring, "f").getKeyringsByType(KeyringTypes.hd)[0];
-            /* istanbul ignore if */
+            const primaryKeyring = this.getKeyringsByType(KeyringTypes.hd)[0];
             if (!primaryKeyring) {
                 throw new Error('No HD keyring found.');
             }
@@ -646,11 +926,11 @@ class KeyringController extends base_controller_1.BaseController {
             }
             // The HD Keyring Builder is a default keyring builder
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const hdKeyringBuilder = __classPrivateFieldGet(this, _KeyringController_keyring, "f").getKeyringBuilderForType(KeyringTypes.hd);
+            const hdKeyringBuilder = __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getKeyringBuilderForType).call(this, KeyringTypes.hd);
             const hdKeyring = hdKeyringBuilder();
             // @ts-expect-error @metamask/eth-hd-keyring correctly handles
             // Uint8Array seed phrases in the `deserialize` method.
-            hdKeyring.deserialize({
+            yield hdKeyring.deserialize({
                 mnemonic: seedWords,
                 numberOfAccounts: accounts.length,
             });
@@ -676,7 +956,7 @@ class KeyringController extends base_controller_1.BaseController {
      */
     getQRKeyring() {
         // QRKeyring is not yet compatible with Keyring type from @metamask/utils
-        return __classPrivateFieldGet(this, _KeyringController_keyring, "f").getKeyringsByType(KeyringTypes.qr)[0];
+        return this.getKeyringsByType(KeyringTypes.qr)[0];
     }
     /**
      * Get QR hardware keyring. If it doesn't exist, add it.
@@ -693,8 +973,7 @@ class KeyringController extends base_controller_1.BaseController {
     restoreQRKeyring(serialized) {
         return __awaiter(this, void 0, void 0, function* () {
             (yield this.getOrAddQRKeyring()).deserialize(serialized);
-            yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").persistAllKeyrings();
-            this.updateIdentities(yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").getAccounts());
+            yield this.persistAllKeyrings();
         });
     }
     resetQRKeyringState() {
@@ -768,45 +1047,34 @@ class KeyringController extends base_controller_1.BaseController {
         return __awaiter(this, void 0, void 0, function* () {
             const keyring = yield this.getOrAddQRKeyring();
             keyring.setAccountToUnlock(index);
-            const oldAccounts = yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").getAccounts();
             // QRKeyring is not yet compatible with Keyring from
             // @metamask/utils, but we can use the `addNewAccount` method
             // as it internally calls `addAccounts` from on the keyring instance,
             // which is supported by QRKeyring API.
-            yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").addNewAccount(keyring);
-            const newAccounts = yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").getAccounts();
-            this.updateIdentities(newAccounts);
-            newAccounts.forEach((address) => {
-                if (!oldAccounts.includes(address)) {
-                    if (this.setAccountLabel) {
-                        this.setAccountLabel(address, `${keyring.getName()} ${index}`);
-                    }
-                    this.setSelectedAddress(address);
-                }
-            });
-            yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").persistAllKeyrings();
+            yield this.addNewAccountForKeyring(keyring);
+            yield this.persistAllKeyrings();
         });
     }
     getAccountKeyringType(account) {
         return __awaiter(this, void 0, void 0, function* () {
-            return (yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").getKeyringForAccount(account)).type;
+            const keyring = (yield this.getKeyringForAccount(account));
+            return keyring.type;
         });
     }
     forgetQRDevice() {
         return __awaiter(this, void 0, void 0, function* () {
             const keyring = yield this.getOrAddQRKeyring();
-            const allAccounts = (yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").getAccounts());
+            const allAccounts = (yield this.getAccounts());
             keyring.forgetDevice();
-            const remainingAccounts = (yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").getAccounts());
+            const remainingAccounts = (yield this.getAccounts());
             const removedAccounts = allAccounts.filter((address) => !remainingAccounts.includes(address));
-            this.updateIdentities(remainingAccounts);
-            yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").persistAllKeyrings();
+            yield this.persistAllKeyrings();
             return { removedAccounts, remainingAccounts };
         });
     }
 }
 exports.KeyringController = KeyringController;
-_KeyringController_keyring = new WeakMap(), _KeyringController_qrKeyringStateListener = new WeakMap(), _KeyringController_instances = new WeakSet(), _KeyringController_registerMessageHandlers = function _KeyringController_registerMessageHandlers() {
+_KeyringController_keyringBuilders = new WeakMap(), _KeyringController_keyrings = new WeakMap(), _KeyringController_unsupportedKeyrings = new WeakMap(), _KeyringController_password = new WeakMap(), _KeyringController_encryptor = new WeakMap(), _KeyringController_cacheEncryptionKey = new WeakMap(), _KeyringController_qrKeyringStateListener = new WeakMap(), _KeyringController_instances = new WeakSet(), _KeyringController_registerMessageHandlers = function _KeyringController_registerMessageHandlers() {
     this.messagingSystem.registerActionHandler(`${name}:signMessage`, this.signMessage.bind(this));
     this.messagingSystem.registerActionHandler(`${name}:signPersonalMessage`, this.signPersonalMessage.bind(this));
     this.messagingSystem.registerActionHandler(`${name}:signTypedMessage`, this.signTypedMessage.bind(this));
@@ -816,10 +1084,21 @@ _KeyringController_keyring = new WeakMap(), _KeyringController_qrKeyringStateLis
     this.messagingSystem.registerActionHandler(`${name}:getKeyringsByType`, this.getKeyringsByType.bind(this));
     this.messagingSystem.registerActionHandler(`${name}:getKeyringForAccount`, this.getKeyringForAccount.bind(this));
     this.messagingSystem.registerActionHandler(`${name}:persistAllKeyrings`, this.persistAllKeyrings.bind(this));
+    this.messagingSystem.registerActionHandler(`${name}:prepareUserOperation`, this.prepareUserOperation.bind(this));
+    this.messagingSystem.registerActionHandler(`${name}:patchUserOperation`, this.patchUserOperation.bind(this));
+    this.messagingSystem.registerActionHandler(`${name}:signUserOperation`, this.signUserOperation.bind(this));
+}, _KeyringController_getKeyringBuilderForType = function _KeyringController_getKeyringBuilderForType(type) {
+    return __classPrivateFieldGet(this, _KeyringController_keyringBuilders, "f").find((keyringBuilder) => keyringBuilder.type === type);
 }, _KeyringController_addQRKeyring = function _KeyringController_addQRKeyring() {
     return __awaiter(this, void 0, void 0, function* () {
         // QRKeyring is not yet compatible with Keyring type from @metamask/utils
-        const qrKeyring = (yield __classPrivateFieldGet(this, _KeyringController_keyring, "f").addNewKeyring(KeyringTypes.qr));
+        const qrKeyring = (yield __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_newKeyring).call(this, KeyringTypes.qr, {
+            accounts: [],
+        }));
+        const accounts = yield qrKeyring.getAccounts();
+        yield __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_checkForDuplicate).call(this, KeyringTypes.qr, accounts);
+        __classPrivateFieldGet(this, _KeyringController_keyrings, "f").push(qrKeyring);
+        yield this.persistAllKeyrings();
         __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_subscribeToQRKeyringEvents).call(this, qrKeyring);
         return qrKeyring;
     });
@@ -829,25 +1108,182 @@ _KeyringController_keyring = new WeakMap(), _KeyringController_qrKeyringStateLis
     }, "f");
     qrKeyring.getMemStore().subscribe(__classPrivateFieldGet(this, _KeyringController_qrKeyringStateListener, "f"));
 }, _KeyringController_unsubscribeFromQRKeyringsEvents = function _KeyringController_unsubscribeFromQRKeyringsEvents() {
-    const qrKeyrings = __classPrivateFieldGet(this, _KeyringController_keyring, "f").getKeyringsByType(KeyringTypes.qr);
+    const qrKeyrings = this.getKeyringsByType(KeyringTypes.qr);
     qrKeyrings.forEach((qrKeyring) => {
         if (__classPrivateFieldGet(this, _KeyringController_qrKeyringStateListener, "f")) {
             qrKeyring.getMemStore().unsubscribe(__classPrivateFieldGet(this, _KeyringController_qrKeyringStateListener, "f"));
         }
     });
-}, _KeyringController_fullUpdate = function _KeyringController_fullUpdate() {
-    const { vault } = __classPrivateFieldGet(this, _KeyringController_keyring, "f").store.getState();
-    const { keyrings, isUnlocked, encryptionKey, encryptionSalt } = __classPrivateFieldGet(this, _KeyringController_keyring, "f").memStore.getState();
-    this.update(() => ({
-        vault,
-        keyrings,
-        isUnlocked,
-        encryptionKey,
-        encryptionSalt,
-    }));
-}, _KeyringController_handleLock = function _KeyringController_handleLock() {
-    this.messagingSystem.publish(`${name}:lock`);
-}, _KeyringController_handleUnlock = function _KeyringController_handleUnlock() {
+}, _KeyringController_createNewVaultWithKeyring = function _KeyringController_createNewVaultWithKeyring(password, keyring) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (typeof password !== 'string') {
+            throw new TypeError(constants_1.KeyringControllerError.WrongPasswordType);
+        }
+        __classPrivateFieldSet(this, _KeyringController_password, password, "f");
+        yield __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_clearKeyrings).call(this);
+        yield __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_createKeyringWithFirstAccount).call(this, keyring.type, keyring.opts);
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_setUnlocked).call(this);
+        return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getMemState).call(this);
+    });
+}, _KeyringController_updateKeyringsInState = function _KeyringController_updateKeyringsInState() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const keyrings = yield Promise.all(__classPrivateFieldGet(this, _KeyringController_keyrings, "f").map(displayForKeyring));
+        this.update((state) => {
+            state.keyrings = keyrings;
+        });
+    });
+}, _KeyringController_unlockKeyrings = function _KeyringController_unlockKeyrings(password, encryptionKey, encryptionSalt) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const encryptedVault = this.state.vault;
+        if (!encryptedVault) {
+            throw new Error(constants_1.KeyringControllerError.VaultError);
+        }
+        yield __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_clearKeyrings).call(this);
+        let vault;
+        if (__classPrivateFieldGet(this, _KeyringController_cacheEncryptionKey, "f")) {
+            assertIsExportableKeyEncryptor(__classPrivateFieldGet(this, _KeyringController_encryptor, "f"));
+            if (password) {
+                const result = yield __classPrivateFieldGet(this, _KeyringController_encryptor, "f").decryptWithDetail(password, encryptedVault);
+                vault = result.vault;
+                __classPrivateFieldSet(this, _KeyringController_password, password, "f");
+                this.update((state) => {
+                    state.encryptionKey = result.exportedKeyString;
+                    state.encryptionSalt = result.salt;
+                });
+            }
+            else {
+                const parsedEncryptedVault = JSON.parse(encryptedVault);
+                if (encryptionSalt !== parsedEncryptedVault.salt) {
+                    throw new Error(constants_1.KeyringControllerError.ExpiredCredentials);
+                }
+                if (typeof encryptionKey !== 'string') {
+                    throw new TypeError(constants_1.KeyringControllerError.WrongPasswordType);
+                }
+                const key = yield __classPrivateFieldGet(this, _KeyringController_encryptor, "f").importKey(encryptionKey);
+                vault = yield __classPrivateFieldGet(this, _KeyringController_encryptor, "f").decryptWithKey(key, parsedEncryptedVault);
+                // This call is required on the first call because encryptionKey
+                // is not yet inside the memStore
+                this.update((state) => {
+                    state.encryptionKey = encryptionKey;
+                    // we can safely assume that encryptionSalt is defined here
+                    // because we compare it with the salt from the vault
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    state.encryptionSalt = encryptionSalt;
+                });
+            }
+        }
+        else {
+            if (typeof password !== 'string') {
+                throw new TypeError(constants_1.KeyringControllerError.WrongPasswordType);
+            }
+            vault = yield __classPrivateFieldGet(this, _KeyringController_encryptor, "f").decrypt(password, encryptedVault);
+            __classPrivateFieldSet(this, _KeyringController_password, password, "f");
+        }
+        if (!isSerializedKeyringsArray(vault)) {
+            throw new Error(constants_1.KeyringControllerError.VaultDataError);
+        }
+        yield Promise.all(vault.map(__classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_restoreKeyring).bind(this)));
+        yield __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_updateKeyringsInState).call(this);
+        if (__classPrivateFieldGet(this, _KeyringController_password, "f") &&
+            (!__classPrivateFieldGet(this, _KeyringController_cacheEncryptionKey, "f") || !encryptionKey) &&
+            __classPrivateFieldGet(this, _KeyringController_encryptor, "f").isVaultUpdated &&
+            !__classPrivateFieldGet(this, _KeyringController_encryptor, "f").isVaultUpdated(encryptedVault)) {
+            // Re-encrypt the vault with safer method if one is available
+            yield this.persistAllKeyrings();
+        }
+        return __classPrivateFieldGet(this, _KeyringController_keyrings, "f");
+    });
+}, _KeyringController_createKeyringWithFirstAccount = function _KeyringController_createKeyringWithFirstAccount(type, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const keyring = (yield this.addNewKeyring(type, opts));
+        const [firstAccount] = yield keyring.getAccounts();
+        if (!firstAccount) {
+            throw new Error(constants_1.KeyringControllerError.NoFirstAccount);
+        }
+    });
+}, _KeyringController_newKeyring = function _KeyringController_newKeyring(type, data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const keyringBuilder = __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getKeyringBuilderForType).call(this, type);
+        if (!keyringBuilder) {
+            throw new Error(`${constants_1.KeyringControllerError.NoKeyringBuilder}. Keyring type: ${type}`);
+        }
+        const keyring = keyringBuilder();
+        // @ts-expect-error Enforce data type after updating clients
+        yield keyring.deserialize(data);
+        if (keyring.init) {
+            yield keyring.init();
+        }
+        return keyring;
+    });
+}, _KeyringController_clearKeyrings = function _KeyringController_clearKeyrings() {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (const keyring of __classPrivateFieldGet(this, _KeyringController_keyrings, "f")) {
+            yield __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_destroyKeyring).call(this, keyring);
+        }
+        __classPrivateFieldSet(this, _KeyringController_keyrings, [], "f");
+        this.update((state) => {
+            state.keyrings = [];
+        });
+    });
+}, _KeyringController_restoreKeyring = function _KeyringController_restoreKeyring(serialized) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const { type, data } = serialized;
+            const keyring = yield __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_newKeyring).call(this, type, data);
+            // getAccounts also validates the accounts for some keyrings
+            yield keyring.getAccounts();
+            __classPrivateFieldGet(this, _KeyringController_keyrings, "f").push(keyring);
+            return keyring;
+        }
+        catch (_) {
+            __classPrivateFieldGet(this, _KeyringController_unsupportedKeyrings, "f").push(serialized);
+            return undefined;
+        }
+    });
+}, _KeyringController_destroyKeyring = function _KeyringController_destroyKeyring(keyring) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        yield ((_a = keyring.destroy) === null || _a === void 0 ? void 0 : _a.call(keyring));
+    });
+}, _KeyringController_removeEmptyKeyrings = function _KeyringController_removeEmptyKeyrings() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const validKeyrings = [];
+        // Since getAccounts returns a Promise
+        // We need to wait to hear back form each keyring
+        // in order to decide which ones are now valid (accounts.length > 0)
+        yield Promise.all(__classPrivateFieldGet(this, _KeyringController_keyrings, "f").map((keyring) => __awaiter(this, void 0, void 0, function* () {
+            const accounts = yield keyring.getAccounts();
+            if (accounts.length > 0) {
+                validKeyrings.push(keyring);
+            }
+            else {
+                yield __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_destroyKeyring).call(this, keyring);
+            }
+        })));
+        __classPrivateFieldSet(this, _KeyringController_keyrings, validKeyrings, "f");
+    });
+}, _KeyringController_checkForDuplicate = function _KeyringController_checkForDuplicate(type, newAccountArray) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const accounts = yield this.getAccounts();
+        switch (type) {
+            case KeyringTypes.simple: {
+                const isIncluded = Boolean(accounts.find((key) => newAccountArray[0] &&
+                    (key === newAccountArray[0] ||
+                        key === (0, utils_1.remove0x)(newAccountArray[0]))));
+                if (isIncluded) {
+                    throw new Error(constants_1.KeyringControllerError.DuplicatedAccount);
+                }
+                return newAccountArray;
+            }
+            default: {
+                return newAccountArray;
+            }
+        }
+    });
+}, _KeyringController_setUnlocked = function _KeyringController_setUnlocked() {
+    this.update((state) => {
+        state.isUnlocked = true;
+    });
     this.messagingSystem.publish(`${name}:unlock`);
 }, _KeyringController_getMemState = function _KeyringController_getMemState() {
     return {