@metamask-previews/keyring-controller 25.0.0-preview-6bed60a6 → 25.0.0-preview-bbf1f2af

package/CHANGELOG.md

@@ -13,6 +13,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Added an action to call `removeAccount` ([#7241](https://github.com/MetaMask/core/pull/7241))
   - This action is meant to be consumed by the `MultichainAccountService` to encapsulate the act of removing a wallet when seed phrase backup fails in the clients.
 
+### Changed
+
+- Upgrade `@metamask/utils` from `^11.8.1` to `^11.9.0` ([#7511](https://github.com/MetaMask/core/pull/7511))
+
 ## [25.0.0]
 
 ### Added

package/dist/KeyringController.cjs

@@ -51,13 +51,15 @@ const lodash_1 = require("lodash");
 // When generating a ULID within the same millisecond, monotonicFactory provides some guarantees regarding sort order.
 const ulid_1 = require("ulid");
 const constants_1 = require("./constants.cjs");
-const errors_1 = require("./errors.cjs");
 const name = 'KeyringController';
 /**
  * Available keyring types
  */
 var KeyringTypes;
 (function (KeyringTypes) {
+    // Changing this would be a breaking change, and not worth the effort at this
+    // time, so we disable the linting rule for this block.
+    /* eslint-disable @typescript-eslint/naming-convention */
     KeyringTypes["simple"] = "Simple Key Pair";
     KeyringTypes["hd"] = "HD Key Tree";
     KeyringTypes["qr"] = "QR Hardware Wallet Device";
@@ -66,6 +68,7 @@ var KeyringTypes;
     KeyringTypes["ledger"] = "Ledger Hardware";
     KeyringTypes["lattice"] = "Lattice Hardware";
     KeyringTypes["snap"] = "Snap Keyring";
+    /* eslint-enable @typescript-eslint/naming-convention */
 })(KeyringTypes || (exports.KeyringTypes = KeyringTypes = {}));
 /**
  * Custody keyring types are a special case, as they are not a single type
@@ -83,8 +86,12 @@ exports.isCustodyKeyring = isCustodyKeyring;
  */
 var AccountImportStrategy;
 (function (AccountImportStrategy) {
+    // Changing this would be a breaking change, and not worth the effort at this
+    // time, so we disable the linting rule for this block.
+    /* eslint-disable @typescript-eslint/naming-convention */
     AccountImportStrategy["privateKey"] = "privateKey";
     AccountImportStrategy["json"] = "json";
+    /* eslint-enable @typescript-eslint/naming-convention */
 })(AccountImportStrategy || (exports.AccountImportStrategy = AccountImportStrategy = {}));
 /**
  * The `signTypedMessage` version
@@ -133,7 +140,7 @@ exports.getDefaultKeyringState = getDefaultKeyringState;
  */
 function assertHasUint8ArrayMnemonic(keyring) {
     if (!((0, utils_1.hasProperty)(keyring, 'mnemonic') && keyring.mnemonic instanceof Uint8Array)) {
-        throw new errors_1.KeyringControllerError("Can't get mnemonic bytes from keyring");
+        throw new Error("Can't get mnemonic bytes from keyring");
     }
 }
 /**
@@ -144,10 +151,10 @@ function assertHasUint8ArrayMnemonic(keyring) {
  */
 function assertIsValidPassword(password) {
     if (typeof password !== 'string') {
-        throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.WrongPasswordType);
+        throw new Error(constants_1.KeyringControllerError.WrongPasswordType);
     }
     if (!password?.length) {
-        throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.InvalidEmptyPassword);
+        throw new Error(constants_1.KeyringControllerError.InvalidEmptyPassword);
     }
 }
 /**
@@ -158,7 +165,7 @@ function assertIsValidPassword(password) {
  */
 function assertIsEncryptionKeySet(encryptionKey) {
     if (!encryptionKey) {
-        throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.EncryptionKeyNotSet);
+        throw new Error(constants_1.KeyringControllerError.EncryptionKeyNotSet);
     }
 }
 /**
@@ -311,17 +318,17 @@ class KeyringController extends base_controller_1.BaseController {
         return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_persistOrRollback).call(this, async () => {
             const primaryKeyring = this.getKeyringsByType('HD Key Tree')[0];
             if (!primaryKeyring) {
-                throw new errors_1.KeyringControllerError('No HD keyring found');
+                throw new Error('No HD keyring found');
             }
             const oldAccounts = await primaryKeyring.getAccounts();
             if (accountCount && oldAccounts.length !== accountCount) {
                 if (accountCount > oldAccounts.length) {
-                    throw new errors_1.KeyringControllerError('Account out of sequence');
+                    throw new Error('Account out of sequence');
                 }
                 // we return the account already existing at index `accountCount`
                 const existingAccount = oldAccounts[accountCount];
                 if (!existingAccount) {
-                    throw new errors_1.KeyringControllerError(`Can't find account at index ${accountCount}`);
+                    throw new Error(`Can't find account at index ${accountCount}`);
                 }
                 return existingAccount;
             }
@@ -347,7 +354,7 @@ class KeyringController extends base_controller_1.BaseController {
             const oldAccounts = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getAccountsFromKeyrings).call(this);
             if (accountCount && oldAccounts.length !== accountCount) {
                 if (accountCount > oldAccounts.length) {
-                    throw new errors_1.KeyringControllerError('Account out of sequence');
+                    throw new Error('Account out of sequence');
                 }
                 const existingAccount = oldAccounts[accountCount];
                 (0, utils_1.assertIsStrictHexString)(existingAccount);
@@ -419,7 +426,7 @@ class KeyringController extends base_controller_1.BaseController {
      */
     async verifyPassword(password) {
         if (!this.state.vault) {
-            throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.VaultError);
+            throw new Error(constants_1.KeyringControllerError.VaultError);
         }
         await __classPrivateFieldGet(this, _KeyringController_encryptor, "f").decrypt(password, this.state.vault);
     }
@@ -443,7 +450,7 @@ class KeyringController extends base_controller_1.BaseController {
         await this.verifyPassword(password);
         const selectedKeyring = __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getKeyringByIdOrDefault).call(this, keyringId);
         if (!selectedKeyring) {
-            throw new errors_1.KeyringControllerError('Keyring not found');
+            throw new Error('Keyring not found');
         }
         assertHasUint8ArrayMnemonic(selectedKeyring);
         return selectedKeyring.mnemonic;
@@ -459,7 +466,7 @@ class KeyringController extends base_controller_1.BaseController {
         await this.verifyPassword(password);
         const keyring = (await this.getKeyringForAccount(address));
         if (!keyring.exportAccount) {
-            throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.UnsupportedExportAccount);
+            throw new Error(constants_1.KeyringControllerError.UnsupportedExportAccount);
         }
         return await keyring.exportAccount(normalize(address));
     }
@@ -485,7 +492,7 @@ class KeyringController extends base_controller_1.BaseController {
         const address = (0, eth_sig_util_1.normalize)(account);
         const keyring = (await this.getKeyringForAccount(account));
         if (!keyring.getEncryptionPublicKey) {
-            throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.UnsupportedGetEncryptionPublicKey);
+            throw new Error(constants_1.KeyringControllerError.UnsupportedGetEncryptionPublicKey);
         }
         return await keyring.getEncryptionPublicKey(address, opts);
     }
@@ -502,7 +509,7 @@ class KeyringController extends base_controller_1.BaseController {
         const address = (0, eth_sig_util_1.normalize)(messageParams.from);
         const keyring = (await this.getKeyringForAccount(address));
         if (!keyring.decryptMessage) {
-            throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.UnsupportedDecryptMessage);
+            throw new Error(constants_1.KeyringControllerError.UnsupportedDecryptMessage);
         }
         return keyring.decryptMessage(address, messageParams.data);
     }
@@ -537,7 +544,7 @@ class KeyringController extends base_controller_1.BaseController {
         else if (!winners.length) {
             errorInfo = 'There are keyrings, but none match the address';
         }
-        throw new errors_1.KeyringControllerError(`${constants_1.KeyringControllerError.NoKeyring}. Error info: ${errorInfo}`);
+        throw new Error(`${constants_1.KeyringControllerError.NoKeyring}. Error info: ${errorInfo}`);
     }
     /**
      * Returns all keyrings of the given type.
@@ -587,7 +594,7 @@ class KeyringController extends base_controller_1.BaseController {
                 case AccountImportStrategy.privateKey: {
                     const [importedKey] = args;
                     if (!importedKey) {
-                        throw new errors_1.KeyringControllerError('Cannot import an empty key.');
+                        throw new Error('Cannot import an empty key.');
                     }
                     const prefixed = (0, utils_1.add0x)(importedKey);
                     let bufferedPrivateKey;
@@ -595,12 +602,12 @@ class KeyringController extends base_controller_1.BaseController {
                         bufferedPrivateKey = (0, utils_1.hexToBytes)(prefixed);
                     }
                     catch {
-                        throw new errors_1.KeyringControllerError('Cannot import invalid private key.');
+                        throw new Error('Cannot import invalid private key.');
                     }
                     if (!(0, util_1.isValidPrivate)(bufferedPrivateKey) ||
                         // ensures that the key is 64 bytes long
                         (0, util_1.getBinarySize)(prefixed) !== 64 + '0x'.length) {
-                        throw new errors_1.KeyringControllerError('Cannot import invalid private key.');
+                        throw new Error('Cannot import invalid private key.');
                     }
                     privateKey = (0, utils_1.remove0x)(prefixed);
                     break;
@@ -618,7 +625,7 @@ class KeyringController extends base_controller_1.BaseController {
                     break;
                 }
                 default:
-                    throw new errors_1.KeyringControllerError(`Unexpected import strategy: '${String(strategy)}'`);
+                    throw new Error(`Unexpected import strategy: '${String(strategy)}'`);
             }
             const newKeyring = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_newKeyring).call(this, KeyringTypes.simple, [
                 privateKey,
@@ -643,11 +650,11 @@ class KeyringController extends base_controller_1.BaseController {
             const shouldRemoveKeyring = (await keyring.getAccounts()).length === 1;
             // Primary keyring should never be removed, so we need to keep at least one account in it
             if (isPrimaryKeyring && shouldRemoveKeyring) {
-                throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.LastAccountInPrimaryKeyring);
+                throw new Error(constants_1.KeyringControllerError.LastAccountInPrimaryKeyring);
             }
             // Not all the keyrings support this, so we have to check
             if (!keyring.removeAccount) {
-                throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.UnsupportedRemoveAccount);
+                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.
@@ -689,12 +696,12 @@ class KeyringController extends base_controller_1.BaseController {
     async signMessage(messageParams) {
         __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
         if (!messageParams.data) {
-            throw new errors_1.KeyringControllerError("Can't sign an empty message");
+            throw new Error("Can't sign an empty message");
         }
         const address = (0, eth_sig_util_1.normalize)(messageParams.from);
         const keyring = (await this.getKeyringForAccount(address));
         if (!keyring.signMessage) {
-            throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.UnsupportedSignMessage);
+            throw new Error(constants_1.KeyringControllerError.UnsupportedSignMessage);
         }
         return await keyring.signMessage(address, messageParams.data);
     }
@@ -709,12 +716,12 @@ class KeyringController extends base_controller_1.BaseController {
         const from = (0, eth_sig_util_1.normalize)(params.from);
         const keyring = (await this.getKeyringForAccount(from));
         if (!keyring.signEip7702Authorization) {
-            throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.UnsupportedSignEip7702Authorization);
+            throw new Error(constants_1.KeyringControllerError.UnsupportedSignEip7702Authorization);
         }
         const { chainId, nonce } = params;
         const contractAddress = (0, eth_sig_util_1.normalize)(params.contractAddress);
         if (contractAddress === undefined) {
-            throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.MissingEip7702AuthorizationContractAddress);
+            throw new Error(constants_1.KeyringControllerError.MissingEip7702AuthorizationContractAddress);
         }
         return await keyring.signEip7702Authorization(from, [
             chainId,
@@ -733,7 +740,7 @@ class KeyringController extends base_controller_1.BaseController {
         const address = (0, eth_sig_util_1.normalize)(messageParams.from);
         const keyring = (await this.getKeyringForAccount(address));
         if (!keyring.signPersonalMessage) {
-            throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.UnsupportedSignPersonalMessage);
+            throw new Error(constants_1.KeyringControllerError.UnsupportedSignPersonalMessage);
         }
         const normalizedData = normalize(messageParams.data);
         return await keyring.signPersonalMessage(address, normalizedData);
@@ -754,14 +761,14 @@ class KeyringController extends base_controller_1.BaseController {
                 SignTypedDataVersion.V3,
                 SignTypedDataVersion.V4,
             ].includes(version)) {
-                throw new errors_1.KeyringControllerError(`Unexpected signTypedMessage version: '${version}'`);
+                throw new Error(`Unexpected signTypedMessage version: '${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 = (await this.getKeyringForAccount(address));
             if (!keyring.signTypedData) {
-                throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.UnsupportedSignTypedMessage);
+                throw new Error(constants_1.KeyringControllerError.UnsupportedSignTypedMessage);
             }
             return await keyring.signTypedData(address, version !== SignTypedDataVersion.V1 &&
                 typeof messageParams.data === 'string'
@@ -769,10 +776,9 @@ class KeyringController extends base_controller_1.BaseController {
                 : messageParams.data, { version });
         }
         catch (error) {
-            const errorMessage = error instanceof Error
-                ? `${error.name}: ${error.message}`
-                : String(error);
-            throw new errors_1.KeyringControllerError(`Keyring Controller signTypedMessage: ${errorMessage}`, error instanceof Error ? error : undefined);
+            // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+            throw new Error(`Keyring Controller signTypedMessage: ${error}`);
         }
     }
     /**
@@ -788,7 +794,7 @@ class KeyringController extends base_controller_1.BaseController {
         const address = (0, eth_sig_util_1.normalize)(from);
         const keyring = (await this.getKeyringForAccount(address));
         if (!keyring.signTransaction) {
-            throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.UnsupportedSignTransaction);
+            throw new Error(constants_1.KeyringControllerError.UnsupportedSignTransaction);
         }
         return await keyring.signTransaction(address, transaction, opts);
     }
@@ -805,7 +811,7 @@ class KeyringController extends base_controller_1.BaseController {
         const address = (0, eth_sig_util_1.normalize)(from);
         const keyring = (await this.getKeyringForAccount(address));
         if (!keyring.prepareUserOperation) {
-            throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.UnsupportedPrepareUserOperation);
+            throw new Error(constants_1.KeyringControllerError.UnsupportedPrepareUserOperation);
         }
         return await keyring.prepareUserOperation(address, transactions, executionContext);
     }
@@ -823,7 +829,7 @@ class KeyringController extends base_controller_1.BaseController {
         const address = (0, eth_sig_util_1.normalize)(from);
         const keyring = (await this.getKeyringForAccount(address));
         if (!keyring.patchUserOperation) {
-            throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.UnsupportedPatchUserOperation);
+            throw new Error(constants_1.KeyringControllerError.UnsupportedPatchUserOperation);
         }
         return await keyring.patchUserOperation(address, userOp, executionContext);
     }
@@ -840,7 +846,7 @@ class KeyringController extends base_controller_1.BaseController {
         const address = (0, eth_sig_util_1.normalize)(from);
         const keyring = (await this.getKeyringForAccount(address));
         if (!keyring.signUserOperation) {
-            throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.UnsupportedSignUserOperation);
+            throw new Error(constants_1.KeyringControllerError.UnsupportedSignUserOperation);
         }
         return await keyring.signUserOperation(address, userOp, executionContext);
     }
@@ -968,7 +974,7 @@ class KeyringController extends base_controller_1.BaseController {
                 keyring = __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getKeyringById).call(this, selector.id);
             }
             if (!keyring) {
-                throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.KeyringNotFound);
+                throw new Error(constants_1.KeyringControllerError.KeyringNotFound);
             }
             const result = await operation({
                 keyring,
@@ -979,7 +985,7 @@ class KeyringController extends base_controller_1.BaseController {
                 // should be discouraged, as it can lead to unexpected behavior.
                 // This error is thrown to prevent consumers using `withKeyring`
                 // as a way to get a reference to a keyring instance.
-                throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.UnsafeDirectKeyringAccess);
+                throw new Error(constants_1.KeyringControllerError.UnsafeDirectKeyringAccess);
             }
             return result;
         });
@@ -1022,7 +1028,7 @@ _KeyringController_controllerOperationMutex = new WeakMap(), _KeyringController_
 }, _KeyringController_getKeyringMetadata = function _KeyringController_getKeyringMetadata(keyring) {
     const keyringWithMetadata = __classPrivateFieldGet(this, _KeyringController_keyrings, "f").find((candidate) => candidate.keyring === keyring);
     if (!keyringWithMetadata) {
-        throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.KeyringNotFound);
+        throw new Error(constants_1.KeyringControllerError.KeyringNotFound);
     }
     return keyringWithMetadata.metadata;
 }, _KeyringController_getKeyringBuilderForType = function _KeyringController_getKeyringBuilderForType(type) {
@@ -1109,7 +1115,7 @@ async function _KeyringController_deriveAndSetEncryptionKey(password, options =
     }
     const { vault } = this.state;
     if (vault && JSON.parse(vault).salt !== keyDerivationSalt) {
-        throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.ExpiredCredentials);
+        throw new Error(constants_1.KeyringControllerError.ExpiredCredentials);
     }
     __classPrivateFieldSet(this, _KeyringController_encryptionKey, {
         salt: keyDerivationSalt,
@@ -1126,17 +1132,17 @@ async function _KeyringController_verifySeedPhrase(keyringId) {
     __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertControllerMutexIsLocked).call(this);
     const keyring = __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getKeyringByIdOrDefault).call(this, keyringId);
     if (!keyring) {
-        throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.KeyringNotFound);
+        throw new Error(constants_1.KeyringControllerError.KeyringNotFound);
     }
     if (keyring.type !== KeyringTypes.hd) {
-        throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.UnsupportedVerifySeedPhrase);
+        throw new Error(constants_1.KeyringControllerError.UnsupportedVerifySeedPhrase);
     }
     assertHasUint8ArrayMnemonic(keyring);
     const seedWords = keyring.mnemonic;
     const accounts = await keyring.getAccounts();
     /* istanbul ignore if */
     if (accounts.length === 0) {
-        throw new errors_1.KeyringControllerError('Cannot verify an empty keyring.');
+        throw new Error('Cannot verify an empty keyring.');
     }
     // The HD Keyring Builder is a default keyring builder
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -1151,12 +1157,12 @@ async function _KeyringController_verifySeedPhrase(keyringId) {
     const testAccounts = await hdKeyring.getAccounts();
     /* istanbul ignore if */
     if (testAccounts.length !== accounts.length) {
-        throw new errors_1.KeyringControllerError('Seed phrase imported incorrect number of accounts.');
+        throw new Error('Seed phrase imported incorrect number of accounts.');
     }
     testAccounts.forEach((account, i) => {
         /* istanbul ignore if */
         if (account.toLowerCase() !== accounts[i].toLowerCase()) {
-            throw new errors_1.KeyringControllerError('Seed phrase imported different accounts.');
+            throw new Error('Seed phrase imported different accounts.');
         }
     });
     return seedWords;
@@ -1237,7 +1243,7 @@ async function _KeyringController_restoreSerializedKeyrings(serializedKeyrings)
 async function _KeyringController_unlockKeyrings(credentials) {
     return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_withVaultLock).call(this, async () => {
         if (!this.state.vault) {
-            throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.VaultError);
+            throw new Error(constants_1.KeyringControllerError.VaultError);
         }
         const parsedEncryptedVault = JSON.parse(this.state.vault);
         if ('password' in credentials) {
@@ -1248,12 +1254,12 @@ async function _KeyringController_unlockKeyrings(credentials) {
         }
         const encryptionKey = __classPrivateFieldGet(this, _KeyringController_encryptionKey, "f")?.serialized;
         if (!encryptionKey) {
-            throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.MissingCredentials);
+            throw new Error(constants_1.KeyringControllerError.MissingCredentials);
         }
         const key = await __classPrivateFieldGet(this, _KeyringController_encryptor, "f").importKey(encryptionKey);
         const vault = await __classPrivateFieldGet(this, _KeyringController_encryptor, "f").decryptWithKey(key, parsedEncryptedVault);
         if (!isSerializedKeyringsArray(vault)) {
-            throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.VaultDataError);
+            throw new Error(constants_1.KeyringControllerError.VaultDataError);
         }
         const { keyrings, newMetadata } = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_restoreSerializedKeyrings).call(this, vault);
         const updatedKeyrings = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getUpdatedKeyrings).call(this);
@@ -1269,11 +1275,11 @@ async function _KeyringController_unlockKeyrings(credentials) {
         // Ensure no duplicate accounts are persisted.
         await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertNoDuplicateAccounts).call(this);
         if (!__classPrivateFieldGet(this, _KeyringController_encryptionKey, "f")) {
-            throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.MissingCredentials);
+            throw new Error(constants_1.KeyringControllerError.MissingCredentials);
         }
         const serializedKeyrings = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getSerializedKeyrings).call(this);
         if (!serializedKeyrings.some((keyring) => keyring.type === KeyringTypes.hd)) {
-            throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.NoHdKeyring);
+            throw new Error(constants_1.KeyringControllerError.NoHdKeyring);
         }
         const key = await __classPrivateFieldGet(this, _KeyringController_encryptor, "f").importKey(__classPrivateFieldGet(this, _KeyringController_encryptionKey, "f").serialized);
         const encryptedVault = await __classPrivateFieldGet(this, _KeyringController_encryptor, "f").encryptWithKey(key, serializedKeyrings);
@@ -1332,7 +1338,7 @@ async function _KeyringController_createKeyringWithFirstAccount(type, opts) {
     const keyring = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_newKeyring).call(this, type, opts);
     const [firstAccount] = await keyring.getAccounts();
     if (!firstAccount) {
-        throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.NoFirstAccount);
+        throw new Error(constants_1.KeyringControllerError.NoFirstAccount);
     }
     return firstAccount;
 }, _KeyringController_newKeyring = 
@@ -1375,7 +1381,7 @@ async function _KeyringController_createKeyring(type, data) {
     __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertControllerMutexIsLocked).call(this);
     const keyringBuilder = __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getKeyringBuilderForType).call(this, type);
     if (!keyringBuilder) {
-        throw new errors_1.KeyringControllerError(`${constants_1.KeyringControllerError.NoKeyringBuilder}. Keyring type: ${type}`);
+        throw new Error(`${constants_1.KeyringControllerError.NoKeyringBuilder}. Keyring type: ${type}`);
     }
     const keyring = keyringBuilder();
     if (data) {
@@ -1385,10 +1391,9 @@ async function _KeyringController_createKeyring(type, data) {
     if (keyring.init) {
         await keyring.init();
     }
-    if (type === KeyringTypes.hd &&
-        (!(0, utils_1.isObject)(data) || !data.mnemonic)) {
+    if (type === KeyringTypes.hd && (!(0, utils_1.isObject)(data) || !data.mnemonic)) {
         if (!keyring.generateRandomMnemonic) {
-            throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.UnsupportedGenerateRandomMnemonic);
+            throw new Error(constants_1.KeyringControllerError.UnsupportedGenerateRandomMnemonic);
         }
         // NOTE: Not all keyrings implement this method in a asynchronous-way. Using `await` for
         // non-thenable will still be valid (despite not being really useful). It allows us to cover both
@@ -1489,7 +1494,7 @@ async function _KeyringController_removeEmptyKeyrings() {
 async function _KeyringController_assertNoDuplicateAccounts(additionalKeyrings = []) {
     const accounts = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getAccountsFromKeyrings).call(this, additionalKeyrings);
     if (new Set(accounts).size !== accounts.length) {
-        throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.DuplicatedAccount);
+        throw new Error(constants_1.KeyringControllerError.DuplicatedAccount);
     }
 }, _KeyringController_setUnlocked = function _KeyringController_setUnlocked() {
     __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertControllerMutexIsLocked).call(this);
@@ -1499,7 +1504,7 @@ async function _KeyringController_assertNoDuplicateAccounts(additionalKeyrings =
     this.messenger.publish(`${name}:unlock`);
 }, _KeyringController_assertIsUnlocked = function _KeyringController_assertIsUnlocked() {
     if (!this.state.isUnlocked) {
-        throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.ControllerLocked);
+        throw new Error(constants_1.KeyringControllerError.ControllerLocked);
     }
 }, _KeyringController_persistOrRollback = 
 /**
@@ -1545,7 +1550,7 @@ async function _KeyringController_withRollback(callback) {
     });
 }, _KeyringController_assertControllerMutexIsLocked = function _KeyringController_assertControllerMutexIsLocked() {
     if (!__classPrivateFieldGet(this, _KeyringController_controllerOperationMutex, "f").isLocked()) {
-        throw new errors_1.KeyringControllerError(constants_1.KeyringControllerError.ControllerLockRequired);
+        throw new Error(constants_1.KeyringControllerError.ControllerLockRequired);
     }
 }, _KeyringController_withControllerLock = 
 /**