feat: add account discovery to MultichainAccountWallet and providers

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

@@ -326,4 +326,101 @@ export class MultichainAccountWallet<
       await group.align();
     }
   }
+
+  /**
+   * Discover and create accounts for all providers.
+   *
+   * NOTE: This method should only be called on a newly created wallet.
+   *
+   * @param opts - The options for the discovery and creation of accounts.
+   * @param opts.skippedProviders - The providers to skip.
+   * @returns The accounts for each provider.
+   */
+  async discoverAndCreateAccounts({
+    skippedProviders = [],
+  }: {
+    skippedProviders: AccountProviderType[];
+  }): Promise<{
+    [AccountProviderType]: Bip44Account<KeyringAccount>[];
+  }> {
+    const providers = this.#providers.filter(
+      (provider) => !skippedProviders.includes(provider.providerType),
+    );
+
+    const results: Record<AccountProviderType, Bip44Account<KeyringAccount>[]> =
+      {};
+    const nextIndex = new Map<Bip44Provider, number>(
+      providers.map((p) => [p, 0]),
+    );
+    const stopped = new Set<Bip44Provider>();
+    const inFlight = new Map<Bip44Provider, Promise<void>>();
+
+    let high = 0;
+
+    const schedule = (p: Bip44Provider, index: number) => {
+      const run = (async () => {
+        try {
+          const accounts = await p.discoverAndCreateAccounts({
+            entropySource: this.#entropySource,
+            groupIndex: index,
+          });
+
+          inFlight.delete(p);
+
+          if (accounts.length > 0) {
+            stopped.add(p);
+          } else {
+            results[p.providerType] = [
+              ...(results[p.providerType] ?? []),
+              ...accounts,
+            ];
+
+            const next = index + 1;
+            nextIndex.set(p, next);
+            if (next > high) {
+              high = next;
+
+              for (const q of providers) {
+                if (
+                  !stopped.has(q) &&
+                  !inFlight.has(q) &&
+                  (nextIndex.get(q) ?? 0) < high
+                ) {
+                  schedule(q, high);
+                }
+              }
+            }
+
+            if (!stopped.has(p)) {
+              const target = Math.max(high, nextIndex.get(p) ?? 0);
+              schedule(p, target);
+            }
+          }
+        } catch {
+          inFlight.delete(p);
+          stopped.add(p);
+        }
+      })();
+
+      inFlight.set(p, run);
+    };
+
+    for (const p of providers) {
+      schedule(p, 0);
+    }
+
+    while (inFlight.size > 0) {
+      await Promise.race(inFlight.values());
+    }
+
+    await this.alignGroups();
+
+    const out: Record<AccountProviderType, Bip44Account<KeyringAccount>[]> = {};
+
+    for (const p of providers) {
+      out[p.providerType] = results[p.providerType] ?? [];
+    }
+
+    return out;
+  }
 }

packages/multichain-account-service/src/providers/BaseAccountProvider.ts

@@ -42,8 +42,14 @@ export abstract class BaseAccountProvider
 {
   protected readonly messenger: MultichainAccountServiceMessenger;
 
-  constructor(messenger: MultichainAccountServiceMessenger) {
+  readonly providerType: AccountProviderType;
+
+  constructor(
+    messenger: MultichainAccountServiceMessenger,
+    providerType: AccountProviderType,
+  ) {
     this.messenger = messenger;
+    this.providerType = providerType;
   }
 
   #getAccounts(

packages/multichain-account-service/src/providers/EvmAccountProvider.ts

@@ -6,10 +6,13 @@ import type {
   EthKeyring,
   InternalAccount,
 } from '@metamask/keyring-internal-api';
+import type { Provider } from '@metamask/network-controller';
 import type { Hex } from '@metamask/utils';
+import type { MultichainAccountServiceMessenger } from 'src/types';
 
 import {
   assertAreBip44Accounts,
+  assertIsBip44Account,
   BaseAccountProvider,
 } from './BaseAccountProvider';
 
@@ -28,13 +31,34 @@ function assertInternalAccountExists(
 }
 
 export class EvmAccountProvider extends BaseAccountProvider {
+  constructor(messenger: MultichainAccountServiceMessenger) {
+    super(messenger, AccountProviderType.Evm);
+  }
+
   isAccountCompatible(account: Bip44Account<InternalAccount>): boolean {
     return (
       account.type === EthAccountType.Eoa &&
       account.metadata.keyring.type === (KeyringTypes.hd as string)
     );
   }
 
+  /**
+   * Get the Evm provider.
+   *
+   * @returns The Evm provider.
+   */
+  getEvmProvider(): Provider {
+    const networkClientId = this.messenger.call(
+      'NetworkController:findNetworkClientIdByChainId',
+      '0x1',
+    );
+    const { provider } = this.messenger.call(
+      'NetworkController:getNetworkClientById',
+      networkClientId,
+    );
+    return provider;
+  }
+
   async createAccounts({
     entropySource,
     groupIndex,
@@ -76,10 +100,62 @@ export class EvmAccountProvider extends BaseAccountProvider {
     return accountsArray;
   }
 
-  async discoverAndCreateAccounts(_: {
+  /**
+   * Discover and create accounts for the Evm provider.
+   *
+   * NOTE: This method should only be called on a newly created wallet.
+   * There should be already one existing account on this associated entropy source.
+   *
+   * @param opts - The options for the discovery and creation of accounts.
+   * @param opts.entropySource - The entropy source to use for the discovery and creation of accounts.
+   * @param opts.groupIndex - The index of the group to create the accounts for.
+   * @returns The accounts for the Evm provider.
+   */
+  async discoverAndCreateAccounts(opts: {
     entropySource: EntropySourceId;
     groupIndex: number;
   }) {
-    return []; // TODO: Implement account discovery.
+    const provider = this.getEvmProvider();
+    const { entropySource, groupIndex } = opts;
+    // groupIndex starts as +1, because we already have one account in the associated keyring.
+    const actualGroupIndex = groupIndex + 1;
+
+    const [address, didCreate] = await this.withKeyring<
+      EthKeyring,
+      [Hex, boolean]
+    >({ id: entropySource }, async ({ keyring }) => {
+      const existing = await keyring.getAccounts();
+      if (actualGroupIndex < existing.length) {
+        return [existing[actualGroupIndex], false];
+      }
+      const need = actualGroupIndex - existing.length + 1;
+      const added = await keyring.addAccounts(need);
+      const target = added[added.length - 1];
+      return [target, true];
+    });
+
+    const countHex = (await provider.request({
+      method: 'eth_getTransactionCount',
+      params: [address, 'latest'],
+    })) as Hex;
+    const count = parseInt(countHex, 16);
+
+    if (count === 0 && didCreate) {
+      await this.withKeyring<EthKeyring>(
+        { id: entropySource },
+        async ({ keyring }) => {
+          keyring.removeAccount?.(address);
+        },
+      );
+      return [];
+    }
+
+    const account = this.messenger.call(
+      'AccountsController:getAccountByAddress',
+      address,
+    );
+    assertInternalAccountExists(account);
+    assertIsBip44Account(account);
+    return [account];
   }
 }

packages/multichain-account-service/src/providers/SnapAccountProvider.ts

@@ -15,8 +15,12 @@ export type RestrictedSnapKeyringCreateAccount = (
 export abstract class SnapAccountProvider extends BaseAccountProvider {
   readonly snapId: SnapId;
 
-  constructor(snapId: SnapId, messenger: MultichainAccountServiceMessenger) {
-    super(messenger);
+  constructor(
+    snapId: SnapId,
+    messenger: MultichainAccountServiceMessenger,
+    providerType: AccountProviderType,
+  ) {
+    super(messenger, providerType);
 
     this.snapId = snapId;
   }

packages/multichain-account-service/src/providers/SolAccountProvider.ts

@@ -16,7 +16,11 @@ export class SolAccountProvider extends SnapAccountProvider {
   static SOLANA_SNAP_ID = 'npm:@metamask/solana-wallet-snap' as SnapId;
 
   constructor(messenger: MultichainAccountServiceMessenger) {
-    super(SolAccountProvider.SOLANA_SNAP_ID, messenger);
+    super(
+      SolAccountProvider.SOLANA_SNAP_ID,
+      messenger,
+      AccountProviderType.Solana,
+    );
   }
 
   isAccountCompatible(account: Bip44Account<InternalAccount>): boolean {

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

@@ -11,6 +11,10 @@ import type {
   KeyringControllerStateChangeEvent,
   KeyringControllerWithKeyringAction,
 } from '@metamask/keyring-controller';
+import type {
+  NetworkControllerFindNetworkClientIdByChainIdAction,
+  NetworkControllerGetNetworkClientByIdAction,
+} from '@metamask/network-controller';
 import type { HandleSnapRequest as SnapControllerHandleSnapRequestAction } from '@metamask/snaps-controllers';
 
 import type {
@@ -88,7 +92,9 @@ export type AllowedActions =
   | AccountsControllerGetAccountByAddressAction
   | SnapControllerHandleSnapRequestAction
   | KeyringControllerWithKeyringAction
-  | KeyringControllerGetStateAction;
+  | KeyringControllerGetStateAction
+  | NetworkControllerGetNetworkClientByIdAction
+  | NetworkControllerFindNetworkClientIdByChainIdAction;
 
 /**
  * All events published by other modules that {@link MultichainAccountService}