@metamask-previews/keyring-controller 14.0.1-preview-f04be62f → 15.0.0-preview-fb52b9eb

package/dist/{chunk-6HZWCYLD.mjs → chunk-RVCG63UG.mjs}

@@ -3,7 +3,7 @@ import {
   __privateGet,
   __privateMethod,
   __privateSet
-} from "./chunk-NAAWD7HX.mjs";
+} from "./chunk-HT7WOORD.mjs";
 
 // src/KeyringController.ts
 import { isValidPrivate, toBuffer, getBinarySize } from "@ethereumjs/util";
@@ -86,7 +86,7 @@ async function displayForKeyring(keyring) {
     accounts: accounts.map(normalize)
   };
 }
-var _keyringBuilders, _keyrings, _unsupportedKeyrings, _password, _encryptor, _cacheEncryptionKey, _qrKeyringStateListener, _registerMessageHandlers, registerMessageHandlers_fn, _getKeyringBuilderForType, getKeyringBuilderForType_fn, _addQRKeyring, addQRKeyring_fn, _subscribeToQRKeyringEvents, subscribeToQRKeyringEvents_fn, _unsubscribeFromQRKeyringsEvents, unsubscribeFromQRKeyringsEvents_fn, _createNewVaultWithKeyring, createNewVaultWithKeyring_fn, _updateKeyringsInState, updateKeyringsInState_fn, _unlockKeyrings, unlockKeyrings_fn, _createKeyringWithFirstAccount, createKeyringWithFirstAccount_fn, _newKeyring, newKeyring_fn, _clearKeyrings, clearKeyrings_fn, _restoreKeyring, restoreKeyring_fn, _destroyKeyring, destroyKeyring_fn, _removeEmptyKeyrings, removeEmptyKeyrings_fn, _checkForDuplicate, checkForDuplicate_fn, _setUnlocked, setUnlocked_fn, _getMemState, getMemState_fn;
+var _controllerOperationMutex, _vaultOperationMutex, _keyringBuilders, _keyrings, _unsupportedKeyrings, _password, _encryptor, _cacheEncryptionKey, _qrKeyringStateListener, _registerMessageHandlers, registerMessageHandlers_fn, _getKeyringBuilderForType, getKeyringBuilderForType_fn, _addQRKeyring, addQRKeyring_fn, _subscribeToQRKeyringEvents, subscribeToQRKeyringEvents_fn, _unsubscribeFromQRKeyringsEvents, unsubscribeFromQRKeyringsEvents_fn, _createNewVaultWithKeyring, createNewVaultWithKeyring_fn, _getUpdatedKeyrings, getUpdatedKeyrings_fn, _unlockKeyrings, unlockKeyrings_fn, _updateVault, updateVault_fn, _getAccountsFromKeyrings, getAccountsFromKeyrings_fn, _createKeyringWithFirstAccount, createKeyringWithFirstAccount_fn, _newKeyring, newKeyring_fn, _clearKeyrings, clearKeyrings_fn, _restoreKeyring, restoreKeyring_fn, _destroyKeyring, destroyKeyring_fn, _removeEmptyKeyrings, removeEmptyKeyrings_fn, _checkForDuplicate, checkForDuplicate_fn, _setUnlocked, setUnlocked_fn, _assertControllerMutexIsLocked, assertControllerMutexIsLocked_fn, _withControllerLock, withControllerLock_fn, _withVaultLock, withVaultLock_fn;
 var KeyringController = class extends BaseController {
   /**
    * Creates a KeyringController instance.
@@ -164,9 +164,12 @@ var KeyringController = class extends BaseController {
      */
     __privateAdd(this, _createNewVaultWithKeyring);
     /**
-     * Update the controller state with its current keyrings.
+     * Get the updated array of each keyring's type and
+     * accounts list.
+     *
+     * @returns A promise resolving to the updated keyrings array.
      */
-    __privateAdd(this, _updateKeyringsInState);
+    __privateAdd(this, _getUpdatedKeyrings);
     /**
      * Unlock Keyrings, decrypting the vault and deserializing all
      * keyrings contained in it, using a password or an encryption key with salt.
@@ -177,6 +180,19 @@ var KeyringController = class extends BaseController {
      * @returns A promise resolving to the deserialized keyrings array.
      */
     __privateAdd(this, _unlockKeyrings);
+    /**
+     * Update the vault with the current keyrings.
+     *
+     * @returns A promise resolving to `true` if the operation is successful.
+     */
+    __privateAdd(this, _updateVault);
+    /**
+     * Retrieves all the accounts from keyrings instances
+     * that are currently in memory.
+     *
+     * @returns A promise resolving to an array of accounts.
+     */
+    __privateAdd(this, _getAccountsFromKeyrings);
     /**
      * Create a new keyring, ensuring that the first account is
      * also created.
@@ -191,14 +207,20 @@ var KeyringController = class extends BaseController {
      * using the given `opts`. The keyring is built using the keyring builder
      * registered for the given `type`.
      *
+     *
      * @param type - The type of keyring to add.
      * @param data - The data to restore a previously serialized keyring.
+     * @param persist - Whether to persist the keyring to the vault.
      * @returns The new keyring.
+     * @throws If the keyring includes duplicated accounts.
      */
     __privateAdd(this, _newKeyring);
     /**
      * Remove all managed keyrings, destroying all their
      * instances in memory.
+     *
+     * @param options - Operations options.
+     * @param options.skipStateUpdate - Whether to skip updating the controller state.
      */
     __privateAdd(this, _clearKeyrings);
     /**
@@ -244,8 +266,39 @@ var KeyringController = class extends BaseController {
      * @fires KeyringController:unlock
      */
     __privateAdd(this, _setUnlocked);
-    __privateAdd(this, _getMemState);
-    this.mutex = new Mutex();
+    /**
+     * Assert that the controller mutex is locked.
+     *
+     * @throws If the controller mutex is not locked.
+     */
+    __privateAdd(this, _assertControllerMutexIsLocked);
+    /**
+     * Lock the controller mutex before executing the given function,
+     * and release it after the function is resolved or after an
+     * error is thrown.
+     *
+     * This wrapper ensures that each mutable operation that interacts with the
+     * controller and that changes its state is executed in a mutually exclusive way,
+     * preventing unsafe concurrent access that could lead to unpredictable behavior.
+     *
+     * @param fn - The function to execute while the controller mutex is locked.
+     * @returns The result of the function.
+     */
+    __privateAdd(this, _withControllerLock);
+    /**
+     * Lock the vault mutex before executing the given function,
+     * and release it after the function is resolved or after an
+     * error is thrown.
+     *
+     * This ensures that each operation that interacts with the vault
+     * is executed in a mutually exclusive way.
+     *
+     * @param fn - The function to execute while the vault mutex is locked.
+     * @returns The result of the function.
+     */
+    __privateAdd(this, _withVaultLock);
+    __privateAdd(this, _controllerOperationMutex, new Mutex());
+    __privateAdd(this, _vaultOperationMutex, new Mutex());
     __privateAdd(this, _keyringBuilders, void 0);
     __privateAdd(this, _keyrings, void 0);
     __privateAdd(this, _unsupportedKeyrings, void 0);
@@ -268,73 +321,74 @@ var KeyringController = class extends BaseController {
    *
    * @param accountCount - Number of accounts before adding a new one, used to
    * make the method idempotent.
-   * @returns Promise resolving to keyring current state and added account
-   * address.
+   * @returns Promise resolving to the added account address.
    */
   async addNewAccount(accountCount) {
-    const primaryKeyring = this.getKeyringsByType("HD Key Tree")[0];
-    if (!primaryKeyring) {
-      throw new Error("No HD keyring found");
-    }
-    const oldAccounts = await this.getAccounts();
-    if (accountCount && oldAccounts.length !== accountCount) {
-      if (accountCount > oldAccounts.length) {
-        throw new Error("Account out of sequence");
+    return __privateMethod(this, _withControllerLock, withControllerLock_fn).call(this, async () => {
+      const primaryKeyring = this.getKeyringsByType("HD Key Tree")[0];
+      if (!primaryKeyring) {
+        throw new Error("No HD keyring found");
       }
-      const primaryKeyringAccounts = await primaryKeyring.getAccounts();
-      return {
-        keyringState: __privateMethod(this, _getMemState, getMemState_fn).call(this),
-        addedAccountAddress: primaryKeyringAccounts[accountCount]
-      };
-    }
-    const addedAccountAddress = await this.addNewAccountForKeyring(
-      primaryKeyring
-    );
-    await this.verifySeedPhrase();
-    return {
-      keyringState: __privateMethod(this, _getMemState, getMemState_fn).call(this),
-      addedAccountAddress
-    };
+      const oldAccounts = await primaryKeyring.getAccounts();
+      if (accountCount && oldAccounts.length !== accountCount) {
+        if (accountCount > oldAccounts.length) {
+          throw new Error("Account out of sequence");
+        }
+        const existingAccount = oldAccounts[accountCount];
+        if (!existingAccount) {
+          throw new Error(`Can't find account at index ${accountCount}`);
+        }
+        return existingAccount;
+      }
+      const [addedAccountAddress] = await primaryKeyring.addAccounts(1);
+      await this.verifySeedPhrase();
+      await __privateMethod(this, _updateVault, updateVault_fn).call(this);
+      return addedAccountAddress;
+    });
   }
   /**
    * Adds a new account to the specified keyring.
    *
    * @param keyring - Keyring to add the account to.
    * @param accountCount - Number of accounts before adding a new one, used to make the method idempotent.
-   * @returns Promise resolving to keyring current state and added account
+   * @returns Promise resolving to the added account address
    */
   async addNewAccountForKeyring(keyring, accountCount) {
-    const oldAccounts = await this.getAccounts();
-    if (accountCount && oldAccounts.length !== accountCount) {
-      if (accountCount > oldAccounts.length) {
-        throw new Error("Account out of sequence");
+    return __privateMethod(this, _withControllerLock, withControllerLock_fn).call(this, async () => {
+      const oldAccounts = await __privateMethod(this, _getAccountsFromKeyrings, getAccountsFromKeyrings_fn).call(this);
+      if (accountCount && oldAccounts.length !== accountCount) {
+        if (accountCount > oldAccounts.length) {
+          throw new Error("Account out of sequence");
+        }
+        const existingAccount = oldAccounts[accountCount];
+        assertIsStrictHexString(existingAccount);
+        return existingAccount;
       }
-      const existingAccount = oldAccounts[accountCount];
-      assertIsStrictHexString(existingAccount);
-      return existingAccount;
-    }
-    await keyring.addAccounts(1);
-    await this.persistAllKeyrings();
-    const addedAccountAddress = (await this.getAccounts()).find(
-      (selectedAddress) => !oldAccounts.includes(selectedAddress)
-    );
-    assertIsStrictHexString(addedAccountAddress);
-    return addedAccountAddress;
+      await keyring.addAccounts(1);
+      await __privateMethod(this, _updateVault, updateVault_fn).call(this);
+      const addedAccountAddress = (await __privateMethod(this, _getAccountsFromKeyrings, getAccountsFromKeyrings_fn).call(this)).find(
+        (selectedAddress) => !oldAccounts.includes(selectedAddress)
+      );
+      assertIsStrictHexString(addedAccountAddress);
+      return addedAccountAddress;
+    });
   }
   /**
    * Adds a new account to the default (first) HD seed phrase keyring without updating identities in preferences.
    *
-   * @returns Promise resolving to current state when the account is added.
+   * @returns Promise resolving to the added account address.
    */
   async addNewAccountWithoutUpdate() {
-    const primaryKeyring = this.getKeyringsByType("HD Key Tree")[0];
-    if (!primaryKeyring) {
-      throw new Error("No HD keyring found");
-    }
-    await primaryKeyring.addAccounts(1);
-    await this.persistAllKeyrings();
-    await this.verifySeedPhrase();
-    return __privateMethod(this, _getMemState, getMemState_fn).call(this);
+    return __privateMethod(this, _withControllerLock, withControllerLock_fn).call(this, async () => {
+      const primaryKeyring = this.getKeyringsByType("HD Key Tree")[0];
+      if (!primaryKeyring) {
+        throw new Error("No HD keyring found");
+      }
+      const [addedAccountAddress] = await primaryKeyring.addAccounts(1);
+      await __privateMethod(this, _updateVault, updateVault_fn).call(this);
+      await this.verifySeedPhrase();
+      return addedAccountAddress;
+    });
   }
   /**
    * Effectively the same as creating a new keychain then populating it
@@ -343,14 +397,13 @@ var KeyringController = class extends BaseController {
    * @param password - Password to unlock keychain.
    * @param seed - A BIP39-compliant seed phrase as Uint8Array,
    * either as a string or an array of UTF-8 bytes that represent the string.
-   * @returns Promise resolving to the restored keychain object.
+   * @returns Promise resolving when the operation ends successfully.
    */
   async createNewVaultAndRestore(password, seed) {
-    const releaseLock = await this.mutex.acquire();
-    if (!password || !password.length) {
-      throw new Error("Invalid password");
-    }
-    try {
+    return __privateMethod(this, _withControllerLock, withControllerLock_fn).call(this, async () => {
+      if (!password || !password.length) {
+        throw new Error("Invalid password");
+      }
       await __privateMethod(this, _createNewVaultWithKeyring, createNewVaultWithKeyring_fn).call(this, password, {
         type: "HD Key Tree" /* hd */,
         opts: {
@@ -358,30 +411,23 @@ var KeyringController = class extends BaseController {
           numberOfAccounts: 1
         }
       });
-      return __privateMethod(this, _getMemState, getMemState_fn).call(this);
-    } finally {
-      releaseLock();
-    }
+    });
   }
   /**
    * Create a new primary keychain and wipe any previous keychains.
    *
    * @param password - Password to unlock the new vault.
-   * @returns Newly-created keychain object.
+   * @returns Promise resolving when the operation ends successfully.
    */
   async createNewVaultAndKeychain(password) {
-    const releaseLock = await this.mutex.acquire();
-    try {
-      const accounts = await this.getAccounts();
+    return __privateMethod(this, _withControllerLock, withControllerLock_fn).call(this, async () => {
+      const accounts = await __privateMethod(this, _getAccountsFromKeyrings, getAccountsFromKeyrings_fn).call(this);
       if (!accounts.length) {
         await __privateMethod(this, _createNewVaultWithKeyring, createNewVaultWithKeyring_fn).call(this, password, {
           type: "HD Key Tree" /* hd */
         });
       }
-      return __privateMethod(this, _getMemState, getMemState_fn).call(this);
-    } finally {
-      releaseLock();
-    }
+    });
   }
   /**
    * Adds a new keyring of the given `type`.
@@ -395,21 +441,7 @@ var KeyringController = class extends BaseController {
     if (type === "QR Hardware Wallet Device" /* qr */) {
       return this.getOrAddQRKeyring();
     }
-    const keyring = await __privateMethod(this, _newKeyring, newKeyring_fn).call(this, type, opts);
-    if (type === "HD Key Tree" /* hd */ && (!isObject(opts) || !opts.mnemonic)) {
-      if (!keyring.generateRandomMnemonic) {
-        throw new Error(
-          "KeyringController - The current keyring does not support the method generateRandomMnemonic." /* UnsupportedGenerateRandomMnemonic */
-        );
-      }
-      keyring.generateRandomMnemonic();
-      await keyring.addAccounts(1);
-    }
-    const accounts = await keyring.getAccounts();
-    await __privateMethod(this, _checkForDuplicate, checkForDuplicate_fn).call(this, type, accounts);
-    __privateGet(this, _keyrings).push(keyring);
-    await this.persistAllKeyrings();
-    return keyring;
+    return __privateMethod(this, _withControllerLock, withControllerLock_fn).call(this, async () => __privateMethod(this, _newKeyring, newKeyring_fn).call(this, type, opts, true));
   }
   /**
    * Method to verify a given password validity. Throws an
@@ -460,19 +492,15 @@ var KeyringController = class extends BaseController {
     return await keyring.exportAccount(normalize(address));
   }
   /**
-   * Returns the public addresses of all accounts for the current keyring.
+   * Returns the public addresses of all accounts from every keyring.
    *
    * @returns A promise resolving to an array of addresses.
    */
   async getAccounts() {
-    const keyrings = __privateGet(this, _keyrings);
-    const keyringArrays = await Promise.all(
-      keyrings.map(async (keyring) => keyring.getAccounts())
+    return this.state.keyrings.reduce(
+      (accounts, keyring) => accounts.concat(keyring.accounts),
+      []
     );
-    const addresses = keyringArrays.reduce((res, arr) => {
-      return res.concat(arr);
-    }, []);
-    return addresses.map(normalize);
   }
   /**
    * Get encryption public key.
@@ -565,60 +593,7 @@ var KeyringController = class extends BaseController {
    * operation completes.
    */
   async persistAllKeyrings() {
-    const { encryptionKey, encryptionSalt } = this.state;
-    if (!__privateGet(this, _password) && !encryptionKey) {
-      throw new Error("KeyringController - Cannot persist vault without password and encryption key" /* MissingCredentials */);
-    }
-    const serializedKeyrings = await Promise.all(
-      __privateGet(this, _keyrings).map(async (keyring) => {
-        const [type, data] = await Promise.all([
-          keyring.type,
-          keyring.serialize()
-        ]);
-        return { type, data };
-      })
-    );
-    serializedKeyrings.push(...__privateGet(this, _unsupportedKeyrings));
-    let vault;
-    let newEncryptionKey;
-    if (__privateGet(this, _cacheEncryptionKey)) {
-      assertIsExportableKeyEncryptor(__privateGet(this, _encryptor));
-      if (encryptionKey) {
-        const key = await __privateGet(this, _encryptor).importKey(encryptionKey);
-        const vaultJSON = await __privateGet(this, _encryptor).encryptWithKey(
-          key,
-          serializedKeyrings
-        );
-        vaultJSON.salt = encryptionSalt;
-        vault = JSON.stringify(vaultJSON);
-      } else if (__privateGet(this, _password)) {
-        const { vault: newVault, exportedKeyString } = await __privateGet(this, _encryptor).encryptWithDetail(
-          __privateGet(this, _password),
-          serializedKeyrings
-        );
-        vault = newVault;
-        newEncryptionKey = exportedKeyString;
-      }
-    } else {
-      if (typeof __privateGet(this, _password) !== "string") {
-        throw new TypeError("KeyringController - Password must be of type string." /* WrongPasswordType */);
-      }
-      vault = await __privateGet(this, _encryptor).encrypt(__privateGet(this, _password), serializedKeyrings);
-    }
-    if (!vault) {
-      throw new Error("KeyringController - Cannot persist vault without vault information" /* MissingVaultData */);
-    }
-    this.update((state) => {
-      state.vault = vault;
-    });
-    await __privateMethod(this, _updateKeyringsInState, updateKeyringsInState_fn).call(this);
-    if (newEncryptionKey) {
-      this.update((state) => {
-        state.encryptionKey = newEncryptionKey;
-        state.encryptionSalt = JSON.parse(vault).salt;
-      });
-    }
-    return true;
+    return __privateMethod(this, _withControllerLock, withControllerLock_fn).call(this, async () => __privateMethod(this, _updateVault, updateVault_fn).call(this));
   }
   /**
    * Imports an account with the specified import strategy.
@@ -626,90 +601,88 @@ var KeyringController = class extends BaseController {
    * @param strategy - Import strategy name.
    * @param args - Array of arguments to pass to the underlying stategy.
    * @throws Will throw when passed an unrecognized strategy.
-   * @returns Promise resolving to keyring current state and imported account
-   * address.
+   * @returns Promise resolving to the imported account address.
    */
   async importAccountWithStrategy(strategy, args) {
-    let privateKey;
-    switch (strategy) {
-      case "privateKey":
-        const [importedKey] = args;
-        if (!importedKey) {
-          throw new Error("Cannot import an empty key.");
-        }
-        const prefixed = add0x(importedKey);
-        let bufferedPrivateKey;
-        try {
-          bufferedPrivateKey = toBuffer(prefixed);
-        } catch {
-          throw new Error("Cannot import invalid private key.");
-        }
-        if (!isValidPrivate(bufferedPrivateKey) || // ensures that the key is 64 bytes long
-        getBinarySize(prefixed) !== 64 + "0x".length) {
-          throw new Error("Cannot import invalid private key.");
-        }
-        privateKey = remove0x(prefixed);
-        break;
-      case "json":
-        let wallet;
-        const [input, password] = args;
-        try {
-          wallet = importers.fromEtherWallet(input, password);
-        } catch (e) {
-          wallet = wallet || await Wallet.fromV3(input, password, true);
-        }
-        privateKey = bytesToHex(wallet.getPrivateKey());
-        break;
-      default:
-        throw new Error(`Unexpected import strategy: '${strategy}'`);
-    }
-    const newKeyring = await this.addNewKeyring("Simple Key Pair" /* simple */, [
-      privateKey
-    ]);
-    const accounts = await newKeyring.getAccounts();
-    return {
-      keyringState: __privateMethod(this, _getMemState, getMemState_fn).call(this),
-      importedAccountAddress: accounts[0]
-    };
+    return __privateMethod(this, _withControllerLock, withControllerLock_fn).call(this, async () => {
+      let privateKey;
+      switch (strategy) {
+        case "privateKey":
+          const [importedKey] = args;
+          if (!importedKey) {
+            throw new Error("Cannot import an empty key.");
+          }
+          const prefixed = add0x(importedKey);
+          let bufferedPrivateKey;
+          try {
+            bufferedPrivateKey = toBuffer(prefixed);
+          } catch {
+            throw new Error("Cannot import invalid private key.");
+          }
+          if (!isValidPrivate(bufferedPrivateKey) || // ensures that the key is 64 bytes long
+          getBinarySize(prefixed) !== 64 + "0x".length) {
+            throw new Error("Cannot import invalid private key.");
+          }
+          privateKey = remove0x(prefixed);
+          break;
+        case "json":
+          let wallet;
+          const [input, password] = args;
+          try {
+            wallet = importers.fromEtherWallet(input, password);
+          } catch (e) {
+            wallet = wallet || await Wallet.fromV3(input, password, true);
+          }
+          privateKey = bytesToHex(wallet.getPrivateKey());
+          break;
+        default:
+          throw new Error(`Unexpected import strategy: '${strategy}'`);
+      }
+      const newKeyring = await __privateMethod(this, _newKeyring, newKeyring_fn).call(this, "Simple Key Pair" /* simple */, [privateKey], true);
+      const accounts = await newKeyring.getAccounts();
+      return accounts[0];
+    });
   }
   /**
    * Removes an account from keyring state.
    *
    * @param address - Address of the account to remove.
    * @fires KeyringController:accountRemoved
-   * @returns Promise resolving current state when this account removal completes.
+   * @returns Promise resolving when the account is removed.
    */
   async removeAccount(address) {
-    const keyring = await this.getKeyringForAccount(
-      address
-    );
-    if (!keyring.removeAccount) {
-      throw new Error("`KeyringController - The keyring for the current address does not support the method removeAccount" /* UnsupportedRemoveAccount */);
-    }
-    await keyring.removeAccount(address);
-    const accounts = await keyring.getAccounts();
-    if (accounts.length === 0) {
-      await __privateMethod(this, _removeEmptyKeyrings, removeEmptyKeyrings_fn).call(this);
-    }
-    await this.persistAllKeyrings();
+    await __privateMethod(this, _withControllerLock, withControllerLock_fn).call(this, async () => {
+      const keyring = await this.getKeyringForAccount(
+        address
+      );
+      if (!keyring.removeAccount) {
+        throw new Error("`KeyringController - The keyring for the current address does not support the method removeAccount" /* UnsupportedRemoveAccount */);
+      }
+      await keyring.removeAccount(address);
+      const accounts = await keyring.getAccounts();
+      if (accounts.length === 0) {
+        await __privateMethod(this, _removeEmptyKeyrings, removeEmptyKeyrings_fn).call(this);
+      }
+      await __privateMethod(this, _updateVault, updateVault_fn).call(this);
+    });
     this.messagingSystem.publish(`${name}:accountRemoved`, address);
-    return __privateMethod(this, _getMemState, getMemState_fn).call(this);
   }
   /**
    * Deallocates all secrets and locks the wallet.
    *
-   * @returns Promise resolving to current state.
+   * @returns Promise resolving when the operation completes.
    */
   async setLocked() {
-    __privateMethod(this, _unsubscribeFromQRKeyringsEvents, unsubscribeFromQRKeyringsEvents_fn).call(this);
-    __privateSet(this, _password, void 0);
-    this.update((state) => {
-      state.isUnlocked = false;
-      state.keyrings = [];
+    return __privateMethod(this, _withControllerLock, withControllerLock_fn).call(this, async () => {
+      __privateMethod(this, _unsubscribeFromQRKeyringsEvents, unsubscribeFromQRKeyringsEvents_fn).call(this);
+      __privateSet(this, _password, void 0);
+      this.update((state) => {
+        state.isUnlocked = false;
+        state.keyrings = [];
+      });
+      await __privateMethod(this, _clearKeyrings, clearKeyrings_fn).call(this);
+      this.messagingSystem.publish(`${name}:lock`);
     });
-    await __privateMethod(this, _clearKeyrings, clearKeyrings_fn).call(this);
-    this.messagingSystem.publish(`${name}:lock`);
-    return __privateMethod(this, _getMemState, getMemState_fn).call(this);
   }
   /**
    * Signs message by calling down into a specific keyring.
@@ -803,9 +776,10 @@ var KeyringController = class extends BaseController {
    *
    * @param from - Address of the sender.
    * @param transactions - Base transactions to include in the UserOperation.
+   * @param executionContext - The execution context to use for the UserOperation.
    * @returns A pseudo-UserOperation that can be used to construct a real.
    */
-  async prepareUserOperation(from, transactions) {
+  async prepareUserOperation(from, transactions, executionContext) {
     const address = normalize(from);
     const keyring = await this.getKeyringForAccount(
       address
@@ -813,7 +787,11 @@ var KeyringController = class extends BaseController {
     if (!keyring.prepareUserOperation) {
       throw new Error("KeyringController - The keyring for the current address does not support the method prepareUserOperation." /* UnsupportedPrepareUserOperation */);
     }
-    return await keyring.prepareUserOperation(address, transactions);
+    return await keyring.prepareUserOperation(
+      address,
+      transactions,
+      executionContext
+    );
   }
   /**
    * Patches properties of a UserOperation. Currently, only the
@@ -821,9 +799,10 @@ var KeyringController = class extends BaseController {
    *
    * @param from - Address of the sender.
    * @param userOp - UserOperation to patch.
+   * @param executionContext - The execution context to use for the UserOperation.
    * @returns A patch to apply to the UserOperation.
    */
-  async patchUserOperation(from, userOp) {
+  async patchUserOperation(from, userOp, executionContext) {
     const address = normalize(from);
     const keyring = await this.getKeyringForAccount(
       address
@@ -831,16 +810,17 @@ var KeyringController = class extends BaseController {
     if (!keyring.patchUserOperation) {
       throw new Error("KeyringController - The keyring for the current address does not support the method patchUserOperation." /* UnsupportedPatchUserOperation */);
     }
-    return await keyring.patchUserOperation(address, userOp);
+    return await keyring.patchUserOperation(address, userOp, executionContext);
   }
   /**
    * Signs an UserOperation.
    *
    * @param from - Address of the sender.
    * @param userOp - UserOperation to sign.
+   * @param executionContext - The execution context to use for the UserOperation.
    * @returns The signature of the UserOperation.
    */
-  async signUserOperation(from, userOp) {
+  async signUserOperation(from, userOp, executionContext) {
     const address = normalize(from);
     const keyring = await this.getKeyringForAccount(
       address
@@ -848,7 +828,7 @@ var KeyringController = class extends BaseController {
     if (!keyring.signUserOperation) {
       throw new Error("KeyringController - The keyring for the current address does not support the method signUserOperation." /* UnsupportedSignUserOperation */);
     }
-    return await keyring.signUserOperation(address, userOp);
+    return await keyring.signUserOperation(address, userOp, executionContext);
   }
   /**
    * Attempts to decrypt the current vault and load its keyrings,
@@ -856,32 +836,34 @@ var KeyringController = class extends BaseController {
    *
    * @param encryptionKey - Key to unlock the keychain.
    * @param encryptionSalt - Salt to unlock the keychain.
-   * @returns Promise resolving to the current state.
+   * @returns Promise resolving when the operation completes.
    */
   async submitEncryptionKey(encryptionKey, encryptionSalt) {
-    __privateSet(this, _keyrings, await __privateMethod(this, _unlockKeyrings, unlockKeyrings_fn).call(this, void 0, encryptionKey, encryptionSalt));
-    __privateMethod(this, _setUnlocked, setUnlocked_fn).call(this);
-    const qrKeyring = this.getQRKeyring();
-    if (qrKeyring) {
-      __privateMethod(this, _subscribeToQRKeyringEvents, subscribeToQRKeyringEvents_fn).call(this, qrKeyring);
-    }
-    return __privateMethod(this, _getMemState, getMemState_fn).call(this);
+    return __privateMethod(this, _withControllerLock, withControllerLock_fn).call(this, async () => {
+      __privateSet(this, _keyrings, await __privateMethod(this, _unlockKeyrings, unlockKeyrings_fn).call(this, void 0, encryptionKey, encryptionSalt));
+      __privateMethod(this, _setUnlocked, setUnlocked_fn).call(this);
+      const qrKeyring = this.getQRKeyring();
+      if (qrKeyring) {
+        __privateMethod(this, _subscribeToQRKeyringEvents, subscribeToQRKeyringEvents_fn).call(this, qrKeyring);
+      }
+    });
   }
   /**
    * Attempts to decrypt the current vault and load its keyrings,
    * using the given password.
    *
    * @param password - Password to unlock the keychain.
-   * @returns Promise resolving to the current state.
+   * @returns Promise resolving when the operation completes.
    */
   async submitPassword(password) {
-    __privateSet(this, _keyrings, await __privateMethod(this, _unlockKeyrings, unlockKeyrings_fn).call(this, password));
-    __privateMethod(this, _setUnlocked, setUnlocked_fn).call(this);
-    const qrKeyring = this.getQRKeyring();
-    if (qrKeyring) {
-      __privateMethod(this, _subscribeToQRKeyringEvents, subscribeToQRKeyringEvents_fn).call(this, qrKeyring);
-    }
-    return __privateMethod(this, _getMemState, getMemState_fn).call(this);
+    return __privateMethod(this, _withControllerLock, withControllerLock_fn).call(this, async () => {
+      __privateSet(this, _keyrings, await __privateMethod(this, _unlockKeyrings, unlockKeyrings_fn).call(this, password));
+      __privateMethod(this, _setUnlocked, setUnlocked_fn).call(this);
+      const qrKeyring = this.getQRKeyring();
+      if (qrKeyring) {
+        __privateMethod(this, _subscribeToQRKeyringEvents, subscribeToQRKeyringEvents_fn).call(this, qrKeyring);
+      }
+    });
   }
   /**
    * Verifies the that the seed phrase restores the current keychain's accounts.
@@ -931,13 +913,16 @@ var KeyringController = class extends BaseController {
    * @returns The added keyring
    */
   async getOrAddQRKeyring() {
-    return this.getQRKeyring() || await __privateMethod(this, _addQRKeyring, addQRKeyring_fn).call(this);
+    return this.getQRKeyring() || await __privateMethod(this, _withControllerLock, withControllerLock_fn).call(this, async () => __privateMethod(this, _addQRKeyring, addQRKeyring_fn).call(this));
   }
   // TODO: Replace `any` with type
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   async restoreQRKeyring(serialized) {
-    (await this.getOrAddQRKeyring()).deserialize(serialized);
-    await this.persistAllKeyrings();
+    return __privateMethod(this, _withControllerLock, withControllerLock_fn).call(this, async () => {
+      const keyring = this.getQRKeyring() || await __privateMethod(this, _addQRKeyring, addQRKeyring_fn).call(this);
+      keyring.deserialize(serialized);
+      await __privateMethod(this, _updateVault, updateVault_fn).call(this);
+    });
   }
   async resetQRKeyringState() {
     (await this.getOrAddQRKeyring()).resetStore();
@@ -964,34 +949,38 @@ var KeyringController = class extends BaseController {
     (await this.getOrAddQRKeyring()).cancelSync();
   }
   async connectQRHardware(page) {
-    try {
-      const keyring = await this.getOrAddQRKeyring();
-      let accounts;
-      switch (page) {
-        case -1:
-          accounts = await keyring.getPreviousPage();
-          break;
-        case 1:
-          accounts = await keyring.getNextPage();
-          break;
-        default:
-          accounts = await keyring.getFirstPage();
+    return __privateMethod(this, _withControllerLock, withControllerLock_fn).call(this, async () => {
+      try {
+        const keyring = this.getQRKeyring() || await __privateMethod(this, _addQRKeyring, addQRKeyring_fn).call(this);
+        let accounts;
+        switch (page) {
+          case -1:
+            accounts = await keyring.getPreviousPage();
+            break;
+          case 1:
+            accounts = await keyring.getNextPage();
+            break;
+          default:
+            accounts = await keyring.getFirstPage();
+        }
+        return accounts.map((account) => {
+          return {
+            ...account,
+            balance: "0x0"
+          };
+        });
+      } catch (e) {
+        throw new Error(`Unspecified error when connect QR Hardware, ${e}`);
       }
-      return accounts.map((account) => {
-        return {
-          ...account,
-          balance: "0x0"
-        };
-      });
-    } catch (e) {
-      throw new Error(`Unspecified error when connect QR Hardware, ${e}`);
-    }
+    });
   }
   async unlockQRHardwareWalletAccount(index) {
-    const keyring = await this.getOrAddQRKeyring();
-    keyring.setAccountToUnlock(index);
-    await this.addNewAccountForKeyring(keyring);
-    await this.persistAllKeyrings();
+    return __privateMethod(this, _withControllerLock, withControllerLock_fn).call(this, async () => {
+      const keyring = this.getQRKeyring() || await __privateMethod(this, _addQRKeyring, addQRKeyring_fn).call(this);
+      keyring.setAccountToUnlock(index);
+      await keyring.addAccounts(1);
+      await __privateMethod(this, _updateVault, updateVault_fn).call(this);
+    });
   }
   async getAccountKeyringType(account) {
     const keyring = await this.getKeyringForAccount(
@@ -1000,17 +989,24 @@ var KeyringController = class extends BaseController {
     return keyring.type;
   }
   async forgetQRDevice() {
-    const keyring = await this.getOrAddQRKeyring();
-    const allAccounts = await this.getAccounts();
-    keyring.forgetDevice();
-    const remainingAccounts = await this.getAccounts();
-    const removedAccounts = allAccounts.filter(
-      (address) => !remainingAccounts.includes(address)
-    );
-    await this.persistAllKeyrings();
-    return { removedAccounts, remainingAccounts };
+    return __privateMethod(this, _withControllerLock, withControllerLock_fn).call(this, async () => {
+      const keyring = this.getQRKeyring();
+      if (!keyring) {
+        return { removedAccounts: [], remainingAccounts: [] };
+      }
+      const allAccounts = await __privateMethod(this, _getAccountsFromKeyrings, getAccountsFromKeyrings_fn).call(this);
+      keyring.forgetDevice();
+      const remainingAccounts = await __privateMethod(this, _getAccountsFromKeyrings, getAccountsFromKeyrings_fn).call(this);
+      const removedAccounts = allAccounts.filter(
+        (address) => !remainingAccounts.includes(address)
+      );
+      await __privateMethod(this, _updateVault, updateVault_fn).call(this);
+      return { removedAccounts, remainingAccounts };
+    });
   }
 };
+_controllerOperationMutex = new WeakMap();
+_vaultOperationMutex = new WeakMap();
 _keyringBuilders = new WeakMap();
 _keyrings = new WeakMap();
 _unsupportedKeyrings = new WeakMap();
@@ -1077,13 +1073,14 @@ getKeyringBuilderForType_fn = function(type) {
 };
 _addQRKeyring = new WeakSet();
 addQRKeyring_fn = async function() {
+  __privateMethod(this, _assertControllerMutexIsLocked, assertControllerMutexIsLocked_fn).call(this);
   const qrKeyring = await __privateMethod(this, _newKeyring, newKeyring_fn).call(this, "QR Hardware Wallet Device" /* qr */, {
     accounts: []
   });
   const accounts = await qrKeyring.getAccounts();
   await __privateMethod(this, _checkForDuplicate, checkForDuplicate_fn).call(this, "QR Hardware Wallet Device" /* qr */, accounts);
   __privateGet(this, _keyrings).push(qrKeyring);
-  await this.persistAllKeyrings();
+  await __privateMethod(this, _updateVault, updateVault_fn).call(this);
   __privateMethod(this, _subscribeToQRKeyringEvents, subscribeToQRKeyringEvents_fn).call(this, qrKeyring);
   return qrKeyring;
 };
@@ -1107,6 +1104,7 @@ unsubscribeFromQRKeyringsEvents_fn = function() {
 };
 _createNewVaultWithKeyring = new WeakSet();
 createNewVaultWithKeyring_fn = async function(password, keyring) {
+  __privateMethod(this, _assertControllerMutexIsLocked, assertControllerMutexIsLocked_fn).call(this);
   if (typeof password !== "string") {
     throw new TypeError("KeyringController - Password must be of type string." /* WrongPasswordType */);
   }
@@ -1114,78 +1112,160 @@ createNewVaultWithKeyring_fn = async function(password, keyring) {
   await __privateMethod(this, _clearKeyrings, clearKeyrings_fn).call(this);
   await __privateMethod(this, _createKeyringWithFirstAccount, createKeyringWithFirstAccount_fn).call(this, keyring.type, keyring.opts);
   __privateMethod(this, _setUnlocked, setUnlocked_fn).call(this);
-  return __privateMethod(this, _getMemState, getMemState_fn).call(this);
 };
-_updateKeyringsInState = new WeakSet();
-updateKeyringsInState_fn = async function() {
-  const keyrings = await Promise.all(__privateGet(this, _keyrings).map(displayForKeyring));
-  this.update((state) => {
-    state.keyrings = keyrings;
-  });
+_getUpdatedKeyrings = new WeakSet();
+getUpdatedKeyrings_fn = async function() {
+  return Promise.all(__privateGet(this, _keyrings).map(displayForKeyring));
 };
 _unlockKeyrings = new WeakSet();
 unlockKeyrings_fn = async function(password, encryptionKey, encryptionSalt) {
-  const encryptedVault = this.state.vault;
-  if (!encryptedVault) {
-    throw new Error("KeyringController - Cannot unlock without a previous vault." /* VaultError */);
-  }
-  await __privateMethod(this, _clearKeyrings, clearKeyrings_fn).call(this);
-  let vault;
-  if (__privateGet(this, _cacheEncryptionKey)) {
-    assertIsExportableKeyEncryptor(__privateGet(this, _encryptor));
-    if (password) {
-      const result = await __privateGet(this, _encryptor).decryptWithDetail(
-        password,
-        encryptedVault
-      );
-      vault = result.vault;
-      __privateSet(this, _password, password);
-      this.update((state) => {
-        state.encryptionKey = result.exportedKeyString;
-        state.encryptionSalt = result.salt;
-      });
+  return __privateMethod(this, _withVaultLock, withVaultLock_fn).call(this, async ({ releaseLock }) => {
+    const encryptedVault = this.state.vault;
+    if (!encryptedVault) {
+      throw new Error("KeyringController - Cannot unlock without a previous vault." /* VaultError */);
+    }
+    await __privateMethod(this, _clearKeyrings, clearKeyrings_fn).call(this, { skipStateUpdate: true });
+    let vault;
+    const updatedState = {};
+    if (__privateGet(this, _cacheEncryptionKey)) {
+      assertIsExportableKeyEncryptor(__privateGet(this, _encryptor));
+      if (password) {
+        const result = await __privateGet(this, _encryptor).decryptWithDetail(
+          password,
+          encryptedVault
+        );
+        vault = result.vault;
+        __privateSet(this, _password, password);
+        updatedState.encryptionKey = result.exportedKeyString;
+        updatedState.encryptionSalt = result.salt;
+      } else {
+        const parsedEncryptedVault = JSON.parse(encryptedVault);
+        if (encryptionSalt !== parsedEncryptedVault.salt) {
+          throw new Error("KeyringController - Encryption key and salt provided are expired" /* ExpiredCredentials */);
+        }
+        if (typeof encryptionKey !== "string") {
+          throw new TypeError("KeyringController - Password must be of type string." /* WrongPasswordType */);
+        }
+        const key = await __privateGet(this, _encryptor).importKey(encryptionKey);
+        vault = await __privateGet(this, _encryptor).decryptWithKey(
+          key,
+          parsedEncryptedVault
+        );
+        updatedState.encryptionKey = encryptionKey;
+        updatedState.encryptionSalt = encryptionSalt;
+      }
     } else {
-      const parsedEncryptedVault = JSON.parse(encryptedVault);
-      if (encryptionSalt !== parsedEncryptedVault.salt) {
-        throw new Error("KeyringController - Encryption key and salt provided are expired" /* ExpiredCredentials */);
+      if (typeof password !== "string") {
+        throw new TypeError("KeyringController - Password must be of type string." /* WrongPasswordType */);
       }
-      if (typeof encryptionKey !== "string") {
+      vault = await __privateGet(this, _encryptor).decrypt(password, encryptedVault);
+      __privateSet(this, _password, password);
+    }
+    if (!isSerializedKeyringsArray(vault)) {
+      throw new Error("KeyringController - The decrypted vault has an unexpected shape." /* VaultDataError */);
+    }
+    await Promise.all(vault.map(__privateMethod(this, _restoreKeyring, restoreKeyring_fn).bind(this)));
+    const updatedKeyrings = await __privateMethod(this, _getUpdatedKeyrings, getUpdatedKeyrings_fn).call(this);
+    this.update((state) => {
+      state.keyrings = updatedKeyrings;
+      if (updatedState.encryptionKey || updatedState.encryptionSalt) {
+        state.encryptionKey = updatedState.encryptionKey;
+        state.encryptionSalt = updatedState.encryptionSalt;
+      }
+    });
+    if (__privateGet(this, _password) && (!__privateGet(this, _cacheEncryptionKey) || !encryptionKey) && __privateGet(this, _encryptor).isVaultUpdated && !__privateGet(this, _encryptor).isVaultUpdated(encryptedVault)) {
+      releaseLock();
+      await __privateMethod(this, _updateVault, updateVault_fn).call(this);
+    }
+    return __privateGet(this, _keyrings);
+  });
+};
+_updateVault = new WeakSet();
+updateVault_fn = function() {
+  return __privateMethod(this, _withVaultLock, withVaultLock_fn).call(this, async () => {
+    const { encryptionKey, encryptionSalt } = this.state;
+    if (!__privateGet(this, _password) && !encryptionKey) {
+      throw new Error("KeyringController - Cannot persist vault without password and encryption key" /* MissingCredentials */);
+    }
+    const serializedKeyrings = await Promise.all(
+      __privateGet(this, _keyrings).map(async (keyring) => {
+        const [type, data] = await Promise.all([
+          keyring.type,
+          keyring.serialize()
+        ]);
+        return { type, data };
+      })
+    );
+    serializedKeyrings.push(...__privateGet(this, _unsupportedKeyrings));
+    if (!serializedKeyrings.some((keyring) => keyring.type === "HD Key Tree" /* hd */)) {
+      throw new Error("KeyringController - No HD Keyring found" /* NoHdKeyring */);
+    }
+    const updatedState = {};
+    if (__privateGet(this, _cacheEncryptionKey)) {
+      assertIsExportableKeyEncryptor(__privateGet(this, _encryptor));
+      if (encryptionKey) {
+        const key = await __privateGet(this, _encryptor).importKey(encryptionKey);
+        const vaultJSON = await __privateGet(this, _encryptor).encryptWithKey(
+          key,
+          serializedKeyrings
+        );
+        vaultJSON.salt = encryptionSalt;
+        updatedState.vault = JSON.stringify(vaultJSON);
+      } else if (__privateGet(this, _password)) {
+        const { vault: newVault, exportedKeyString } = await __privateGet(this, _encryptor).encryptWithDetail(
+          __privateGet(this, _password),
+          serializedKeyrings
+        );
+        updatedState.vault = newVault;
+        updatedState.encryptionKey = exportedKeyString;
+      }
+    } else {
+      if (typeof __privateGet(this, _password) !== "string") {
         throw new TypeError("KeyringController - Password must be of type string." /* WrongPasswordType */);
       }
-      const key = await __privateGet(this, _encryptor).importKey(encryptionKey);
-      vault = await __privateGet(this, _encryptor).decryptWithKey(key, parsedEncryptedVault);
-      this.update((state) => {
-        state.encryptionKey = encryptionKey;
-        state.encryptionSalt = encryptionSalt;
-      });
+      updatedState.vault = await __privateGet(this, _encryptor).encrypt(
+        __privateGet(this, _password),
+        serializedKeyrings
+      );
     }
-  } else {
-    if (typeof password !== "string") {
-      throw new TypeError("KeyringController - Password must be of type string." /* WrongPasswordType */);
+    if (!updatedState.vault) {
+      throw new Error("KeyringController - Cannot persist vault without vault information" /* MissingVaultData */);
     }
-    vault = await __privateGet(this, _encryptor).decrypt(password, encryptedVault);
-    __privateSet(this, _password, password);
-  }
-  if (!isSerializedKeyringsArray(vault)) {
-    throw new Error("KeyringController - The decrypted vault has an unexpected shape." /* VaultDataError */);
-  }
-  await Promise.all(vault.map(__privateMethod(this, _restoreKeyring, restoreKeyring_fn).bind(this)));
-  await __privateMethod(this, _updateKeyringsInState, updateKeyringsInState_fn).call(this);
-  if (__privateGet(this, _password) && (!__privateGet(this, _cacheEncryptionKey) || !encryptionKey) && __privateGet(this, _encryptor).isVaultUpdated && !__privateGet(this, _encryptor).isVaultUpdated(encryptedVault)) {
-    await this.persistAllKeyrings();
-  }
-  return __privateGet(this, _keyrings);
+    const updatedKeyrings = await __privateMethod(this, _getUpdatedKeyrings, getUpdatedKeyrings_fn).call(this);
+    this.update((state) => {
+      state.vault = updatedState.vault;
+      state.keyrings = updatedKeyrings;
+      if (updatedState.encryptionKey) {
+        state.encryptionKey = updatedState.encryptionKey;
+        state.encryptionSalt = JSON.parse(updatedState.vault).salt;
+      }
+    });
+    return true;
+  });
+};
+_getAccountsFromKeyrings = new WeakSet();
+getAccountsFromKeyrings_fn = async function() {
+  const keyrings = __privateGet(this, _keyrings);
+  const keyringArrays = await Promise.all(
+    keyrings.map(async (keyring) => keyring.getAccounts())
+  );
+  const addresses = keyringArrays.reduce((res, arr) => {
+    return res.concat(arr);
+  }, []);
+  return addresses.map(normalize);
 };
 _createKeyringWithFirstAccount = new WeakSet();
 createKeyringWithFirstAccount_fn = async function(type, opts) {
-  const keyring = await this.addNewKeyring(type, opts);
+  __privateMethod(this, _assertControllerMutexIsLocked, assertControllerMutexIsLocked_fn).call(this);
+  const keyring = await __privateMethod(this, _newKeyring, newKeyring_fn).call(this, type, opts, true);
   const [firstAccount] = await keyring.getAccounts();
   if (!firstAccount) {
     throw new Error("KeyringController - First Account not found." /* NoFirstAccount */);
   }
 };
 _newKeyring = new WeakSet();
-newKeyring_fn = async function(type, data) {
+newKeyring_fn = async function(type, data, persist = false) {
+  __privateMethod(this, _assertControllerMutexIsLocked, assertControllerMutexIsLocked_fn).call(this);
   const keyringBuilder = __privateMethod(this, _getKeyringBuilderForType, getKeyringBuilderForType_fn).call(this, type);
   if (!keyringBuilder) {
     throw new Error(
@@ -1197,20 +1277,38 @@ newKeyring_fn = async function(type, data) {
   if (keyring.init) {
     await keyring.init();
   }
+  if (type === "HD Key Tree" /* hd */ && (!isObject(data) || !data.mnemonic)) {
+    if (!keyring.generateRandomMnemonic) {
+      throw new Error(
+        "KeyringController - The current keyring does not support the method generateRandomMnemonic." /* UnsupportedGenerateRandomMnemonic */
+      );
+    }
+    keyring.generateRandomMnemonic();
+    await keyring.addAccounts(1);
+  }
+  await __privateMethod(this, _checkForDuplicate, checkForDuplicate_fn).call(this, type, await keyring.getAccounts());
+  if (persist) {
+    __privateGet(this, _keyrings).push(keyring);
+    await __privateMethod(this, _updateVault, updateVault_fn).call(this);
+  }
   return keyring;
 };
 _clearKeyrings = new WeakSet();
-clearKeyrings_fn = async function() {
+clearKeyrings_fn = async function(options = { skipStateUpdate: false }) {
+  __privateMethod(this, _assertControllerMutexIsLocked, assertControllerMutexIsLocked_fn).call(this);
   for (const keyring of __privateGet(this, _keyrings)) {
     await __privateMethod(this, _destroyKeyring, destroyKeyring_fn).call(this, keyring);
   }
   __privateSet(this, _keyrings, []);
-  this.update((state) => {
-    state.keyrings = [];
-  });
+  if (!options.skipStateUpdate) {
+    this.update((state) => {
+      state.keyrings = [];
+    });
+  }
 };
 _restoreKeyring = new WeakSet();
 restoreKeyring_fn = async function(serialized) {
+  __privateMethod(this, _assertControllerMutexIsLocked, assertControllerMutexIsLocked_fn).call(this);
   try {
     const { type, data } = serialized;
     const keyring = await __privateMethod(this, _newKeyring, newKeyring_fn).call(this, type, data);
@@ -1228,6 +1326,7 @@ destroyKeyring_fn = async function(keyring) {
 };
 _removeEmptyKeyrings = new WeakSet();
 removeEmptyKeyrings_fn = async function() {
+  __privateMethod(this, _assertControllerMutexIsLocked, assertControllerMutexIsLocked_fn).call(this);
   const validKeyrings = [];
   await Promise.all(
     __privateGet(this, _keyrings).map(async (keyring) => {
@@ -1243,7 +1342,7 @@ removeEmptyKeyrings_fn = async function() {
 };
 _checkForDuplicate = new WeakSet();
 checkForDuplicate_fn = async function(type, newAccountArray) {
-  const accounts = await this.getAccounts();
+  const accounts = await __privateMethod(this, _getAccountsFromKeyrings, getAccountsFromKeyrings_fn).call(this);
   switch (type) {
     case "Simple Key Pair" /* simple */: {
       const isIncluded = Boolean(
@@ -1263,18 +1362,35 @@ checkForDuplicate_fn = async function(type, newAccountArray) {
 };
 _setUnlocked = new WeakSet();
 setUnlocked_fn = function() {
+  __privateMethod(this, _assertControllerMutexIsLocked, assertControllerMutexIsLocked_fn).call(this);
   this.update((state) => {
     state.isUnlocked = true;
   });
   this.messagingSystem.publish(`${name}:unlock`);
 };
-_getMemState = new WeakSet();
-getMemState_fn = function() {
-  return {
-    isUnlocked: this.state.isUnlocked,
-    keyrings: this.state.keyrings
-  };
+_assertControllerMutexIsLocked = new WeakSet();
+assertControllerMutexIsLocked_fn = function() {
+  if (!__privateGet(this, _controllerOperationMutex).isLocked()) {
+    throw new Error("KeyringController - attempt to update vault during a non mutually exclusive operation" /* ControllerLockRequired */);
+  }
+};
+_withControllerLock = new WeakSet();
+withControllerLock_fn = async function(fn) {
+  return withLock(__privateGet(this, _controllerOperationMutex), fn);
+};
+_withVaultLock = new WeakSet();
+withVaultLock_fn = async function(fn) {
+  __privateMethod(this, _assertControllerMutexIsLocked, assertControllerMutexIsLocked_fn).call(this);
+  return withLock(__privateGet(this, _vaultOperationMutex), fn);
 };
+async function withLock(mutex, fn) {
+  const releaseLock = await mutex.acquire();
+  try {
+    return await fn({ releaseLock });
+  } finally {
+    releaseLock();
+  }
+}
 var KeyringController_default = KeyringController;
 
 export {
@@ -1287,4 +1403,4 @@ export {
   KeyringController,
   KeyringController_default
 };
-//# sourceMappingURL=chunk-6HZWCYLD.mjs.map
+//# sourceMappingURL=chunk-RVCG63UG.mjs.map