@metamask-previews/keyring-controller 19.0.1-preview-470d2e31 → 19.0.1-preview-953c11ad

package/dist/KeyringController.cjs

@@ -48,6 +48,7 @@ const eth_simple_keyring_1 = __importDefault(require("@metamask/eth-simple-keyri
 const utils_1 = require("@metamask/utils");
 const async_mutex_1 = require("async-mutex");
 const ethereumjs_wallet_1 = __importStar(require("ethereumjs-wallet"));
+const ulid_1 = require("ulid");
 const constants_1 = require("./constants.cjs");
 const name = 'KeyringController';
 /**
@@ -199,11 +200,14 @@ function isSerializedKeyringsArray(array) {
  */
 async function displayForKeyring(keyring) {
     const accounts = await keyring.getAccounts();
+    const { opts } = keyring;
     return {
         type: keyring.type,
         // Cast to `string[]` here is safe here because `accounts` has no nullish
         // values, and `normalize` returns `string` unless given a nullish value
         accounts: accounts.map(normalize),
+        typeIndex: opts?.typeIndex,
+        id: opts?.id,
     };
 }
 /**
@@ -300,16 +304,23 @@ class KeyringController extends base_controller_1.BaseController {
      * Adds a new account to the default (first) HD seed phrase keyring.
      *
      * @param accountCount - Number of accounts before adding a new one, used to
+     * @param keyringId - The id of the keyring to add the account to.
      * make the method idempotent.
      * @returns Promise resolving to the added account address.
      */
-    async addNewAccount(accountCount) {
+    async addNewAccount(accountCount, keyringId) {
         return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_persistOrRollback).call(this, async () => {
-            const primaryKeyring = this.getKeyringsByType('HD Key Tree')[0];
-            if (!primaryKeyring) {
+            let selectedKeyring;
+            if (keyringId) {
+                selectedKeyring = this.getKeyringById(keyringId);
+            }
+            else {
+                selectedKeyring = this.getKeyringsByType(KeyringTypes.hd)[0];
+            }
+            if (!selectedKeyring) {
                 throw new Error('No HD keyring found');
             }
-            const oldAccounts = await primaryKeyring.getAccounts();
+            const oldAccounts = await selectedKeyring.getAccounts();
             if (accountCount && oldAccounts.length !== accountCount) {
                 if (accountCount > oldAccounts.length) {
                     throw new Error('Account out of sequence');
@@ -321,7 +332,7 @@ class KeyringController extends base_controller_1.BaseController {
                 }
                 return existingAccount;
             }
-            const [addedAccountAddress] = await primaryKeyring.addAccounts(1);
+            const [addedAccountAddress] = await selectedKeyring.addAccounts(1);
             await this.verifySeedPhrase();
             return addedAccountAddress;
         });
@@ -375,6 +386,14 @@ class KeyringController extends base_controller_1.BaseController {
             });
         });
     }
+    async createKeyringFromMnemonic(mnemonic) {
+        return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_persistOrRollback).call(this, async () => {
+            return await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_createKeyringWithFirstAccount).call(this, KeyringTypes.hd, {
+                mnemonic,
+                numberOfAccounts: 1,
+            });
+        });
+    }
     /**
      * Create a new vault and primary keyring.
      *
@@ -431,12 +450,18 @@ class KeyringController extends base_controller_1.BaseController {
      * Gets the seed phrase of the HD keyring.
      *
      * @param password - Password of the keyring.
+     * @param typeIndex - Hd keyring identifier
      * @returns Promise resolving to the seed phrase.
      */
-    async exportSeedPhrase(password) {
+    async exportSeedPhrase(password, typeIndex) {
         await this.verifyPassword(password);
-        assertHasUint8ArrayMnemonic(__classPrivateFieldGet(this, _KeyringController_keyrings, "f")[0]);
-        return __classPrivateFieldGet(this, _KeyringController_keyrings, "f")[0].mnemonic;
+        const keyring = this.getKeyringsByType(KeyringTypes.hd).find((innerKeyring) => innerKeyring
+            .opts.typeIndex === typeIndex);
+        if (!keyring) {
+            throw new Error(constants_1.KeyringControllerError.KeyringNotFound);
+        }
+        assertHasUint8ArrayMnemonic(keyring);
+        return keyring.mnemonic;
     }
     /**
      * Gets the private key from the keyring controlling an address.
@@ -456,10 +481,13 @@ class KeyringController extends base_controller_1.BaseController {
     /**
      * Returns the public addresses of all accounts from every keyring.
      *
+     * @param keyringId - The id of the keyring to get the accounts from.
      * @returns A promise resolving to an array of addresses.
      */
-    async getAccounts() {
-        return this.state.keyrings.reduce((accounts, keyring) => accounts.concat(keyring.accounts), []);
+    async getAccounts(keyringId) {
+        return this.state.keyrings
+            .filter((keyring) => (keyringId ? keyring.id === keyringId : true))
+            .reduce((accounts, keyring) => accounts.concat(keyring.accounts), []);
     }
     /**
      * Get encryption public key.
@@ -493,6 +521,19 @@ class KeyringController extends base_controller_1.BaseController {
         }
         return keyring.decryptMessage(address, messageParams.data);
     }
+    /**
+     * Returns the keyring with the given id.
+     *
+     * @param id - The id of the keyring to return.
+     * @returns The keyring with the given id.
+     */
+    getKeyringById(id) {
+        const keyring = __classPrivateFieldGet(this, _KeyringController_keyrings, "f").find((item) => item.opts.id === id);
+        if (!keyring) {
+            throw new Error(constants_1.KeyringControllerError.KeyringNotFound);
+        }
+        return keyring;
+    }
     /**
      * Returns the currently initialized keyring that manages
      * the specified `address` if one exists.
@@ -882,12 +923,15 @@ class KeyringController extends base_controller_1.BaseController {
             if ('address' in selector) {
                 keyring = (await this.getKeyringForAccount(selector.address));
             }
-            else {
+            else if ('type' in selector) {
                 keyring = this.getKeyringsByType(selector.type)[selector.index || 0];
                 if (!keyring && options.createIfMissing) {
                     keyring = (await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_newKeyring).call(this, selector.type, options.createWithData));
                 }
             }
+            else if ('id' in selector) {
+                keyring = this.getKeyringById(selector.id);
+            }
             if (!keyring) {
                 throw new Error(constants_1.KeyringControllerError.KeyringNotFound);
             }
@@ -1351,6 +1395,7 @@ async function _KeyringController_createKeyringWithFirstAccount(type, opts) {
     if (!firstAccount) {
         throw new Error(constants_1.KeyringControllerError.NoFirstAccount);
     }
+    return firstAccount;
 }, _KeyringController_newKeyring = 
 /**
  * Instantiate, initialize and return a new keyring of the given `type`,
@@ -1370,8 +1415,25 @@ async function _KeyringController_newKeyring(type, data) {
         throw new Error(`${constants_1.KeyringControllerError.NoKeyringBuilder}. Keyring type: ${type}`);
     }
     const keyring = keyringBuilder();
-    // @ts-expect-error Enforce data type after updating clients
-    await keyring.deserialize(data);
+    // find the last index of the type
+    const lastIndexOfType = __classPrivateFieldGet(this, _KeyringController_keyrings, "f").reduce((maxIndex, item) => {
+        if (item.type === type) {
+            return Math.max(maxIndex, item.opts
+                ?.typeIndex ?? 0);
+        }
+        return maxIndex;
+    }, 0);
+    if (type === KeyringTypes.hd) {
+        await keyring.deserialize({
+            ...(data ?? {}),
+            typeIndex: lastIndexOfType + 1,
+            id: (0, ulid_1.ulid)(),
+        });
+    }
+    else {
+        // @ts-expect-error Enforce data type after updating clients
+        await keyring.deserialize(data);
+    }
     if (keyring.init) {
         await keyring.init();
     }