feat: add account discovery to MultichainAccountWallet and providers

packages/multichain-account-service/CHANGELOG.md

@@ -7,6 +7,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Add `discoverAndCreateAccounts` methods for EVM and Solana providers ([#6397](https://github.com/MetaMask/core/pull/6397))
+- Add `discoverAndCreateAccounts` method to `MultichainAccountWallet` to orchestrate provider discovery ([#6397](https://github.com/MetaMask/core/pull/6397))
+- Add `createMultichainAccountWallet` method to create a new multichain account wallet from a mnemonic ([#6397](https://github.com/MetaMask/core/pull/6397))
+  - An action handler was also registered for this method so that it can be called from the clients.
+
 ## [0.6.0]
 
 ### Added

packages/multichain-account-service/src/MultichainAccountGroup.ts

@@ -6,10 +6,10 @@ import {
 } from '@metamask/account-api';
 import type { Bip44Account } from '@metamask/account-api';
 import type { AccountSelector } from '@metamask/account-api';
-import type { AccountProvider } from '@metamask/account-api';
 import { type KeyringAccount } from '@metamask/keyring-api';
 
 import type { MultichainAccountWallet } from './MultichainAccountWallet';
+import type { NamedAccountProvider } from './providers';
 
 /**
  * A multichain account group that holds multiple accounts.
@@ -24,11 +24,17 @@ export class MultichainAccountGroup<
 
   readonly #groupIndex: number;
 
-  readonly #providers: AccountProvider<Account>[];
+  readonly #providers: NamedAccountProvider<Account>[];
 
-  readonly #providerToAccounts: Map<AccountProvider<Account>, Account['id'][]>;
+  readonly #providerToAccounts: Map<
+    NamedAccountProvider<Account>,
+    Account['id'][]
+  >;
 
-  readonly #accountToProvider: Map<Account['id'], AccountProvider<Account>>;
+  readonly #accountToProvider: Map<
+    Account['id'],
+    NamedAccountProvider<Account>
+  >;
 
   constructor({
     groupIndex,
@@ -37,7 +43,7 @@ export class MultichainAccountGroup<
   }: {
     groupIndex: number;
     wallet: MultichainAccountWallet<Account>;
-    providers: AccountProvider<Account>[];
+    providers: NamedAccountProvider<Account>[];
   }) {
     this.#id = toMultichainAccountGroupId(wallet.id, groupIndex);
     this.#groupIndex = groupIndex;

packages/multichain-account-service/src/MultichainAccountService.test.ts

@@ -54,6 +54,7 @@ type Mocks = {
   KeyringController: {
     keyrings: KeyringObject[];
     getState: jest.Mock;
+    withKeyring: jest.Mock;
   };
   AccountsController: {
     listMultichainAccounts: jest.Mock;
@@ -102,13 +103,17 @@ function setup({
     KeyringController: {
       keyrings,
       getState: jest.fn(),
+      withKeyring: jest.fn(),
     },
     AccountsController: {
       listMultichainAccounts: jest.fn(),
     },
     EvmAccountProvider: makeMockAccountProvider(),
     SolAccountProvider: makeMockAccountProvider(),
   };
+  // Default provider names can be overridden per test using mockImplementation
+  mocks.EvmAccountProvider.getName.mockImplementation(() => 'EVM');
+  mocks.SolAccountProvider.getName.mockImplementation(() => 'Solana');
 
   mocks.KeyringController.getState.mockImplementation(() => ({
     isUnlocked: true,
@@ -120,6 +125,11 @@ function setup({
     mocks.KeyringController.getState,
   );
 
+  messenger.registerActionHandler(
+    'KeyringController:withKeyring',
+    mocks.KeyringController.withKeyring,
+  );
+
   if (accounts) {
     mocks.AccountsController.listMultichainAccounts.mockImplementation(
       () => accounts,
@@ -832,6 +842,26 @@ describe('MultichainAccountService', () => {
 
       expect(isInProgress).toBe(false);
     });
+
+    it('creates a multichain account wallet with MultichainAccountService:createMultichainAccountWallet', async () => {
+      const { messenger, mocks } = setup({ accounts: [], keyrings: [] });
+
+      mocks.KeyringController.withKeyring.mockImplementationOnce(
+        async (_selector, op, _opts) => {
+          const keyring = { getAccounts: jest.fn().mockResolvedValue([]) };
+          const metadata = { id: 'abc', type: KeyringTypes.hd };
+          return op({ keyring, metadata });
+        },
+      );
+
+      const [wallet, entropySource] = await messenger.call(
+        'MultichainAccountService:createMultichainAccountWallet',
+        { mnemonic: 'test' },
+      );
+
+      expect(wallet).toBeDefined();
+      expect(entropySource).toBe('abc');
+    });
   });
 
   describe('setBasicFunctionality', () => {
@@ -954,4 +984,48 @@ describe('MultichainAccountService', () => {
       expect(wrapper.isAccountCompatible(MOCK_HD_ACCOUNT_1)).toBe(false);
     });
   });
+
+  describe('createMultichainAccountWallet', () => {
+    it('creates a multichain account wallet with MultichainAccountService:createMultichainAccountWallet', async () => {
+      const { mocks, service } = setup({
+        accounts: [],
+        keyrings: [],
+      });
+
+      // Make the messenger withKeyring call invoke our operation so the service code runs
+      mocks.KeyringController.withKeyring.mockImplementationOnce(
+        async (_selector, op, _opts) => {
+          const keyring = { getAccounts: jest.fn().mockResolvedValue([]) };
+          const metadata = { id: 'abc', type: KeyringTypes.hd };
+          return op({ keyring, metadata });
+        },
+      );
+
+      const [wallet, entropySource] =
+        await service.createMultichainAccountWallet({
+          mnemonic: 'test',
+        });
+
+      expect(wallet).toBeDefined();
+      expect(entropySource).toBe('abc');
+    });
+
+    it("throws an error if there's already an existing keyring with accounts", async () => {
+      const { service, mocks } = setup({ accounts: [], keyrings: [] });
+
+      mocks.KeyringController.withKeyring.mockImplementationOnce(
+        async (_selector, op, _opts) => {
+          const keyring = {
+            getAccounts: jest.fn().mockResolvedValue(['0xabc']),
+          };
+          const metadata = { id: 'abc', type: KeyringTypes.hd };
+          return op({ keyring, metadata });
+        },
+      );
+
+      await expect(
+        service.createMultichainAccountWallet({ mnemonic: 'test' }),
+      ).rejects.toThrow('Expected keyring with no accounts');
+    });
+  });
 });

packages/multichain-account-service/src/MultichainAccountService.ts

@@ -5,13 +5,18 @@ import {
 import type {
   MultichainAccountWalletId,
   Bip44Account,
-  AccountProvider,
 } from '@metamask/account-api';
 import type { EntropySourceId, KeyringAccount } from '@metamask/keyring-api';
-import { KeyringTypes } from '@metamask/keyring-controller';
+import {
+  type KeyringMetadata,
+  KeyringTypes,
+} from '@metamask/keyring-controller';
+import type { EthKeyring } from '@metamask/keyring-internal-api';
+import { type Hex } from '@metamask/utils';
 
 import type { MultichainAccountGroup } from './MultichainAccountGroup';
 import { MultichainAccountWallet } from './MultichainAccountWallet';
+import type { NamedAccountProvider } from './providers';
 import {
   AccountProviderWrapper,
   isAccountProviderWrapper,
@@ -27,7 +32,7 @@ export const serviceName = 'MultichainAccountService';
  */
 type MultichainAccountServiceOptions = {
   messenger: MultichainAccountServiceMessenger;
-  providers?: AccountProvider<Bip44Account<KeyringAccount>>[];
+  providers?: NamedAccountProvider[];
 };
 
 /** Reverse mapping object used to map account IDs and their wallet/multichain account. */
@@ -42,7 +47,7 @@ type AccountContext<Account extends Bip44Account<KeyringAccount>> = {
 export class MultichainAccountService {
   readonly #messenger: MultichainAccountServiceMessenger;
 
-  readonly #providers: AccountProvider<Bip44Account<KeyringAccount>>[];
+  readonly #providers: NamedAccountProvider[];
 
   readonly #wallets: Map<
     MultichainAccountWalletId,
@@ -124,6 +129,10 @@ export class MultichainAccountService {
       'MultichainAccountService:getIsAlignmentInProgress',
       () => this.getIsAlignmentInProgress(),
     );
+    this.#messenger.registerActionHandler(
+      'MultichainAccountService:createMultichainAccountWallet',
+      (...args) => this.createMultichainAccountWallet(...args),
+    );
 
     this.#messenger.subscribe('AccountsController:accountAdded', (account) =>
       this.#handleOnAccountAdded(account),
@@ -293,6 +302,58 @@ export class MultichainAccountService {
     return Array.from(this.#wallets.values());
   }
 
+  /**
+   * Creates a new multichain account wallet with the given mnemonic.
+   *
+   * NOTE: This method should only be called in client code where a mutex lock is acquired.
+   * `discoverAndCreateAccounts` should be called after this method to discover and create accounts.
+   *
+   * @param options - Options.
+   * @param options.mnemonic - The mnemonic to use to create the new wallet.
+   * @returns The a tuple of the new multichain account wallet and the entropy source id.
+   */
+  async createMultichainAccountWallet({
+    mnemonic,
+  }: {
+    mnemonic: string;
+  }): Promise<
+    [MultichainAccountWallet<Bip44Account<KeyringAccount>>, EntropySourceId]
+  > {
+    // create a new wallet with the given mnemonic
+    const result = (await this.#messenger.call(
+      'KeyringController:withKeyring',
+      // We intentionally use index -1 to create a new keyring.
+      { type: KeyringTypes.hd, index: -1 },
+      async ({
+        keyring,
+        metadata,
+      }: {
+        keyring: EthKeyring;
+        metadata: KeyringMetadata;
+      }) => {
+        const accounts = await keyring.getAccounts();
+        return [accounts, metadata];
+      },
+      { createIfMissing: true, createWithData: { mnemonic } },
+    )) as [Hex[], KeyringMetadata];
+
+    const [accounts, metadata] = result;
+
+    // Make sure the keyring has no accounts after creating it.
+    if (accounts.length > 0) {
+      throw new Error('Expected keyring with no accounts');
+    }
+
+    const wallet = new MultichainAccountWallet({
+      providers: this.#providers,
+      entropySource: metadata.id,
+    });
+
+    this.#wallets.set(wallet.id, wallet);
+
+    return [wallet, metadata.id];
+  }
+
   /**
    * Gets a reference to the multichain account group matching this entropy source
    * and a group index.