@metamask-previews/keyring-controller 15.0.0-preview-fb52b9eb → 15.0.0-preview-2036edd1

package/dist/{chunk-RVCG63UG.mjs → chunk-5QTEIEPG.mjs}

@@ -3,7 +3,7 @@ import {
   __privateGet,
   __privateMethod,
   __privateSet
-} from "./chunk-HT7WOORD.mjs";
+} from "./chunk-XPARO3LL.mjs";
 
 // src/KeyringController.ts
 import { isValidPrivate, toBuffer, getBinarySize } from "@ethereumjs/util";
@@ -86,7 +86,7 @@ async function displayForKeyring(keyring) {
     accounts: accounts.map(normalize)
   };
 }
-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 _initVaultMutex, _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, _getMemState, getMemState_fn, _withVaultLock, withVaultLock_fn;
 var KeyringController = class extends BaseController {
   /**
    * Creates a KeyringController instance.
@@ -266,25 +266,7 @@ var KeyringController = class extends BaseController {
      * @fires KeyringController:unlock
      */
     __privateAdd(this, _setUnlocked);
-    /**
-     * 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);
+    __privateAdd(this, _getMemState);
     /**
      * Lock the vault mutex before executing the given function,
      * and release it after the function is resolved or after an
@@ -297,7 +279,7 @@ var KeyringController = class extends BaseController {
      * @returns The result of the function.
      */
     __privateAdd(this, _withVaultLock);
-    __privateAdd(this, _controllerOperationMutex, new Mutex());
+    __privateAdd(this, _initVaultMutex, new Mutex());
     __privateAdd(this, _vaultOperationMutex, new Mutex());
     __privateAdd(this, _keyringBuilders, void 0);
     __privateAdd(this, _keyrings, void 0);
@@ -321,74 +303,75 @@ 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 the added account address.
+   * @returns Promise resolving to keyring current state and added account
+   * address.
    */
   async addNewAccount(accountCount) {
-    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 primaryKeyring = this.getKeyringsByType("HD Key Tree")[0];
+    if (!primaryKeyring) {
+      throw new Error("No HD keyring found");
+    }
+    const oldAccounts = await primaryKeyring.getAccounts();
+    if (accountCount && oldAccounts.length !== accountCount) {
+      if (accountCount > oldAccounts.length) {
+        throw new Error("Account out of sequence");
       }
-      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 existingAccount = oldAccounts[accountCount];
+      if (!existingAccount) {
+        throw new Error(`Can't find account at index ${accountCount}`);
       }
-      const [addedAccountAddress] = await primaryKeyring.addAccounts(1);
-      await this.verifySeedPhrase();
-      await __privateMethod(this, _updateVault, updateVault_fn).call(this);
-      return addedAccountAddress;
-    });
+      return {
+        keyringState: __privateMethod(this, _getMemState, getMemState_fn).call(this),
+        addedAccountAddress: existingAccount
+      };
+    }
+    const [addedAccountAddress] = await primaryKeyring.addAccounts(1);
+    await this.verifySeedPhrase();
+    await __privateMethod(this, _updateVault, updateVault_fn).call(this);
+    return {
+      keyringState: __privateMethod(this, _getMemState, getMemState_fn).call(this),
+      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 the added account address
+   * @returns Promise resolving to keyring current state and added account
    */
   async addNewAccountForKeyring(keyring, accountCount) {
-    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 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");
       }
-      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;
-    });
+      const existingAccount = oldAccounts[accountCount];
+      assertIsStrictHexString(existingAccount);
+      return existingAccount;
+    }
+    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 the added account address.
+   * @returns Promise resolving to current state when the account is added.
    */
   async addNewAccountWithoutUpdate() {
-    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;
-    });
+    const primaryKeyring = this.getKeyringsByType("HD Key Tree")[0];
+    if (!primaryKeyring) {
+      throw new Error("No HD keyring found");
+    }
+    await primaryKeyring.addAccounts(1);
+    await __privateMethod(this, _updateVault, updateVault_fn).call(this);
+    await this.verifySeedPhrase();
+    return __privateMethod(this, _getMemState, getMemState_fn).call(this);
   }
   /**
    * Effectively the same as creating a new keychain then populating it
@@ -397,13 +380,14 @@ 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 when the operation ends successfully.
+   * @returns Promise resolving to the restored keychain object.
    */
   async createNewVaultAndRestore(password, seed) {
-    return __privateMethod(this, _withControllerLock, withControllerLock_fn).call(this, async () => {
-      if (!password || !password.length) {
-        throw new Error("Invalid password");
-      }
+    const releaseLock = await __privateGet(this, _initVaultMutex).acquire();
+    if (!password || !password.length) {
+      throw new Error("Invalid password");
+    }
+    try {
       await __privateMethod(this, _createNewVaultWithKeyring, createNewVaultWithKeyring_fn).call(this, password, {
         type: "HD Key Tree" /* hd */,
         opts: {
@@ -411,23 +395,30 @@ 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 Promise resolving when the operation ends successfully.
+   * @returns Newly-created keychain object.
    */
   async createNewVaultAndKeychain(password) {
-    return __privateMethod(this, _withControllerLock, withControllerLock_fn).call(this, async () => {
+    const releaseLock = await __privateGet(this, _initVaultMutex).acquire();
+    try {
       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`.
@@ -441,7 +432,7 @@ var KeyringController = class extends BaseController {
     if (type === "QR Hardware Wallet Device" /* qr */) {
       return this.getOrAddQRKeyring();
     }
-    return __privateMethod(this, _withControllerLock, withControllerLock_fn).call(this, async () => __privateMethod(this, _newKeyring, newKeyring_fn).call(this, type, opts, true));
+    return __privateMethod(this, _newKeyring, newKeyring_fn).call(this, type, opts, true);
   }
   /**
    * Method to verify a given password validity. Throws an
@@ -497,10 +488,7 @@ var KeyringController = class extends BaseController {
    * @returns A promise resolving to an array of addresses.
    */
   async getAccounts() {
-    return this.state.keyrings.reduce(
-      (accounts, keyring) => accounts.concat(keyring.accounts),
-      []
-    );
+    return __privateMethod(this, _getAccountsFromKeyrings, getAccountsFromKeyrings_fn).call(this);
   }
   /**
    * Get encryption public key.
@@ -593,7 +581,7 @@ var KeyringController = class extends BaseController {
    * operation completes.
    */
   async persistAllKeyrings() {
-    return __privateMethod(this, _withControllerLock, withControllerLock_fn).call(this, async () => __privateMethod(this, _updateVault, updateVault_fn).call(this));
+    return __privateMethod(this, _updateVault, updateVault_fn).call(this);
   }
   /**
    * Imports an account with the specified import strategy.
@@ -601,88 +589,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 the imported account address.
+   * @returns Promise resolving to keyring current state and imported account
+   * address.
    */
   async importAccountWithStrategy(strategy, args) {
-    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];
-    });
+    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 {
+      keyringState: __privateMethod(this, _getMemState, getMemState_fn).call(this),
+      importedAccountAddress: accounts[0]
+    };
   }
   /**
    * Removes an account from keyring state.
    *
    * @param address - Address of the account to remove.
    * @fires KeyringController:accountRemoved
-   * @returns Promise resolving when the account is removed.
+   * @returns Promise resolving current state when this account removal completes.
    */
   async removeAccount(address) {
-    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);
-    });
+    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 when the operation completes.
+   * @returns Promise resolving to current state.
    */
   async setLocked() {
-    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`);
+    __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`);
+    return __privateMethod(this, _getMemState, getMemState_fn).call(this);
   }
   /**
    * Signs message by calling down into a specific keyring.
@@ -836,34 +824,32 @@ var KeyringController = class extends BaseController {
    *
    * @param encryptionKey - Key to unlock the keychain.
    * @param encryptionSalt - Salt to unlock the keychain.
-   * @returns Promise resolving when the operation completes.
+   * @returns Promise resolving to the current state.
    */
   async submitEncryptionKey(encryptionKey, encryptionSalt) {
-    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);
-      }
-    });
+    __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);
   }
   /**
    * Attempts to decrypt the current vault and load its keyrings,
    * using the given password.
    *
    * @param password - Password to unlock the keychain.
-   * @returns Promise resolving when the operation completes.
+   * @returns Promise resolving to the current state.
    */
   async submitPassword(password) {
-    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);
-      }
-    });
+    __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);
   }
   /**
    * Verifies the that the seed phrase restores the current keychain's accounts.
@@ -913,16 +899,14 @@ var KeyringController = class extends BaseController {
    * @returns The added keyring
    */
   async getOrAddQRKeyring() {
-    return this.getQRKeyring() || await __privateMethod(this, _withControllerLock, withControllerLock_fn).call(this, async () => __privateMethod(this, _addQRKeyring, addQRKeyring_fn).call(this));
+    return this.getQRKeyring() || await __privateMethod(this, _addQRKeyring, addQRKeyring_fn).call(this);
   }
   // TODO: Replace `any` with type
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   async restoreQRKeyring(serialized) {
-    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);
-    });
+    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();
@@ -949,38 +933,34 @@ var KeyringController = class extends BaseController {
     (await this.getOrAddQRKeyring()).cancelSync();
   }
   async connectQRHardware(page) {
-    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}`);
+    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}`);
+    }
   }
   async unlockQRHardwareWalletAccount(index) {
-    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);
-    });
+    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(
@@ -989,23 +969,21 @@ var KeyringController = class extends BaseController {
     return keyring.type;
   }
   async forgetQRDevice() {
-    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 };
-    });
+    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();
+_initVaultMutex = new WeakMap();
 _vaultOperationMutex = new WeakMap();
 _keyringBuilders = new WeakMap();
 _keyrings = new WeakMap();
@@ -1073,7 +1051,6 @@ 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: []
   });
@@ -1104,7 +1081,6 @@ 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 */);
   }
@@ -1112,6 +1088,7 @@ 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);
 };
 _getUpdatedKeyrings = new WeakSet();
 getUpdatedKeyrings_fn = async function() {
@@ -1256,7 +1233,6 @@ getAccountsFromKeyrings_fn = async function() {
 };
 _createKeyringWithFirstAccount = new WeakSet();
 createKeyringWithFirstAccount_fn = async function(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) {
@@ -1265,7 +1241,6 @@ createKeyringWithFirstAccount_fn = async function(type, opts) {
 };
 _newKeyring = new WeakSet();
 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(
@@ -1295,7 +1270,6 @@ newKeyring_fn = async function(type, data, persist = false) {
 };
 _clearKeyrings = new WeakSet();
 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);
   }
@@ -1308,7 +1282,6 @@ clearKeyrings_fn = async function(options = { skipStateUpdate: false }) {
 };
 _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);
@@ -1326,7 +1299,6 @@ 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) => {
@@ -1362,35 +1334,27 @@ 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`);
 };
-_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);
+_getMemState = new WeakSet();
+getMemState_fn = function() {
+  return {
+    isUnlocked: this.state.isUnlocked,
+    keyrings: this.state.keyrings
+  };
 };
 _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();
+  const releaseLock = await __privateGet(this, _vaultOperationMutex).acquire();
   try {
     return await fn({ releaseLock });
   } finally {
     releaseLock();
   }
-}
+};
 var KeyringController_default = KeyringController;
 
 export {
@@ -1403,4 +1367,4 @@ export {
   KeyringController,
   KeyringController_default
 };
-//# sourceMappingURL=chunk-RVCG63UG.mjs.map
+//# sourceMappingURL=chunk-5QTEIEPG.mjs.map