WIP - update controllers

packages/accounts-controller/package.json

@@ -43,10 +43,10 @@
   "dependencies": {
     "@ethereumjs/util": "^8.1.0",
     "@metamask/base-controller": "^5.0.2",
-    "@metamask/eth-snap-keyring": "^4.0.0",
-    "@metamask/keyring-api": "^6.0.0",
-    "@metamask/snaps-sdk": "^4.0.1",
-    "@metamask/snaps-utils": "^7.1.0",
+    "@metamask/eth-snap-keyring": "^4.1.0",
+    "@metamask/keyring-api": "^6.1.0",
+    "@metamask/snaps-sdk": "^4.1.0",
+    "@metamask/snaps-utils": "^7.3.0",
     "@metamask/utils": "^8.3.0",
     "deepmerge": "^4.2.2",
     "ethereum-cryptography": "^2.1.2",

packages/accounts-controller/src/AccountsController.test.ts

@@ -145,6 +145,8 @@ class MockNormalAccountUUID {
  * @param props.keyringType - The type of the keyring associated with the account.
  * @param props.snapId - The id of the snap.
  * @param props.snapEnabled - The status of the snap
+ * @param props.lastSelected - The last selected time of the account.
+ * @param props.importTime - The import time of the account.
  * @returns The `InternalAccount` object created from the normal account properties.
  */
 function createExpectedInternalAccount({
@@ -154,13 +156,17 @@ function createExpectedInternalAccount({
   keyringType,
   snapId,
   snapEnabled = true,
+  importTime,
+  lastSelected,
 }: {
   id: string;
   name: string;
   address: string;
   keyringType: string;
   snapId?: string;
   snapEnabled?: boolean;
+  importTime?: number;
+  lastSelected?: number;
 }): InternalAccount {
   const account: InternalAccount = {
     id,
@@ -171,10 +177,8 @@ function createExpectedInternalAccount({
     metadata: {
       name,
       keyring: { type: keyringType },
-      importTime: expect.any(Number),
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore
-      lastSelected: undefined,
+      importTime: importTime || expect.any(Number),
+      lastSelected: lastSelected || undefined,
     },
   };
 
@@ -703,6 +707,8 @@ describe('AccountsController', () => {
           name: 'Custom Name',
           address: mockAccount2.address,
           keyringType: KeyringTypes.hd,
+          importTime: 1955565967656,
+          lastSelected: 1955565967656,
         });
 
         const mockNewKeyringState = {

packages/accounts-controller/src/AccountsController.ts

@@ -31,7 +31,7 @@ const controllerName = 'AccountsController';
 export type AccountsControllerState = {
   internalAccounts: {
     accounts: Record<string, InternalAccount>;
-    selectedAccount: string; // id of the selected account
+    selectedAccount: string;
   };
 };
 
@@ -75,6 +75,11 @@ export type AccountsControllerGetAccountAction = {
   handler: AccountsController['getAccount'];
 };
 
+export type AccountsControllerGetAccountExpectAction = {
+  type: `${typeof controllerName}:getAccountExpect`;
+  handler: AccountsController['getAccountExpect'];
+};
+
 export type AllowedActions =
   | KeyringControllerGetKeyringForAccountAction
   | KeyringControllerGetKeyringsByTypeAction
@@ -88,7 +93,8 @@ export type AccountsControllerActions =
   | AccountsControllerUpdateAccountsAction
   | AccountsControllerGetAccountByAddressAction
   | AccountsControllerGetSelectedAccountAction
-  | AccountsControllerGetAccountAction;
+  | AccountsControllerGetAccountAction
+  | AccountsControllerGetAccountExpectAction;
 
 export type AccountsControllerChangeEvent = ControllerStateChangeEvent<
   typeof controllerName,
@@ -302,7 +308,21 @@ export class AccountsController extends BaseController<
         ...account,
         metadata: { ...account.metadata, name: accountName },
       };
-      currentState.internalAccounts.accounts[accountId] = internalAccount;
+
+      // deep clone of old state to get around Type instantiation is excessively deep and possibly infinite.
+      const oldState = JSON.parse(JSON.stringify(currentState));
+
+      const newState: AccountsControllerState = {
+        internalAccounts: {
+          ...oldState.internalAccounts,
+          accounts: {
+            ...oldState.internalAccounts.accounts,
+            [accountId]: internalAccount,
+          },
+        },
+      };
+
+      return newState;
     });
   }
 
@@ -363,8 +383,15 @@ export class AccountsController extends BaseController<
     }, {} as Record<string, InternalAccount>);
 
     this.update((currentState: Draft<AccountsControllerState>) => {
-      (currentState as AccountsControllerState).internalAccounts.accounts =
-        accounts;
+      const newState: AccountsControllerState = {
+        ...currentState,
+        internalAccounts: {
+          selectedAccount: currentState.internalAccounts.selectedAccount,
+          accounts,
+        },
+      };
+
+      return newState;
     });
   }
 
@@ -375,9 +402,11 @@ export class AccountsController extends BaseController<
    */
   loadBackup(backup: AccountsControllerState): void {
     if (backup.internalAccounts) {
-      this.update((currentState: Draft<AccountsControllerState>) => {
-        (currentState as AccountsControllerState).internalAccounts =
-          backup.internalAccounts;
+      this.update(() => {
+        const newState: AccountsControllerState = {
+          internalAccounts: backup.internalAccounts,
+        };
+        return newState;
       });
     }
   }
@@ -761,17 +790,29 @@ export class AccountsController extends BaseController<
     const accountName = `${accountPrefix} ${indexToUse}`;
 
     this.update((currentState: Draft<AccountsControllerState>) => {
-      (currentState as AccountsControllerState).internalAccounts.accounts[
-        newAccount.id
-      ] = {
-        ...newAccount,
-        metadata: {
-          ...newAccount.metadata,
-          name: accountName,
-          importTime: Date.now(),
-          lastSelected: Date.now(),
+      // deep clone of old state to get around Type instantiation is excessively deep and possibly infinite.
+      const oldState = JSON.parse(JSON.stringify(currentState));
+
+      const newState: AccountsControllerState = {
+        ...oldState,
+        internalAccounts: {
+          ...oldState.internalAccounts,
+          accounts: {
+            ...oldState.internalAccounts.accounts,
+            [newAccount.id]: {
+              ...newAccount,
+              metadata: {
+                ...newAccount.metadata,
+                name: accountName,
+                importTime: Date.now(),
+                lastSelected: Date.now(),
+              },
+            },
+          },
         },
       };
+
+      return newState;
     });
 
     this.setSelectedAccount(newAccount.id);
@@ -840,5 +881,10 @@ export class AccountsController extends BaseController<
       `AccountsController:getAccount`,
       this.getAccount.bind(this),
     );
+
+    this.messagingSystem.registerActionHandler(
+      `AccountsController:getAccountExpect`,
+      this.getAccountExpect.bind(this),
+    );
   }
 }

packages/accounts-controller/src/index.ts

@@ -8,6 +8,7 @@ export type {
   AccountsControllerGetSelectedAccountAction,
   AccountsControllerGetAccountByAddressAction,
   AccountsControllerGetAccountAction,
+  AccountsControllerGetAccountExpectAction,
   AccountsControllerActions,
   AccountsControllerChangeEvent,
   AccountsControllerSelectedAccountChangeEvent,
@@ -16,3 +17,4 @@ export type {
 } from './AccountsController';
 export { AccountsController } from './AccountsController';
 export { keyringTypeToName, getUUIDFromAddressOfNormalAccount } from './utils';
+export { createMockInternalAccount } from './tests/mocks';

packages/accounts-controller/src/tests/mocks.test.ts

@@ -0,0 +1,77 @@
+import { BtcAccountType, EthAccountType } from '@metamask/keyring-api';
+
+import { createMockInternalAccount } from './mocks';
+
+describe('createMockInternalAccount', () => {
+  it('should create a mock internal account', () => {
+    const account = createMockInternalAccount();
+    expect(account).toStrictEqual({
+      id: expect.any(String),
+      address: expect.any(String),
+      type: expect.any(String),
+      options: expect.any(Object),
+      methods: expect.any(Array),
+      metadata: {
+        name: expect.any(String),
+        keyring: { type: expect.any(String) },
+        importTime: expect.any(Number),
+        lastSelected: expect.any(Number),
+        snap: undefined,
+      },
+    });
+  });
+
+  it('should create a mock internal account with custom values', () => {
+    const customSnap = {
+      id: '1',
+      enabled: true,
+      name: 'Snap 1',
+    };
+    const account = createMockInternalAccount({
+      id: '1',
+      address: '0x123',
+      type: EthAccountType.Erc4337,
+      name: 'Custom Account',
+      snap: customSnap,
+    });
+    expect(account).toStrictEqual({
+      id: '1',
+      address: '0x123',
+      type: EthAccountType.Erc4337,
+      options: expect.any(Object),
+      methods: expect.any(Array),
+      metadata: {
+        name: 'Custom Account',
+        keyring: { type: expect.any(String) },
+        importTime: expect.any(Number),
+        lastSelected: expect.any(Number),
+        snap: customSnap,
+      },
+    });
+  });
+
+  it('should create a nonevm account', () => {
+    const account = createMockInternalAccount({ type: BtcAccountType.P2wpkh });
+    expect(account).toStrictEqual({
+      id: expect.any(String),
+      address: expect.any(String),
+      type: BtcAccountType.P2wpkh,
+      options: expect.any(Object),
+      methods: expect.any(Array),
+      metadata: {
+        name: expect.any(String),
+        keyring: { type: expect.any(String) },
+        importTime: expect.any(Number),
+        lastSelected: expect.any(Number),
+        snap: undefined,
+      },
+    });
+  });
+
+  it('will throw if an unknown account type was passed', () => {
+    // @ts-expect-error testing unknown account type
+    expect(() => createMockInternalAccount({ type: 'unknown' })).toThrow(
+      'Unknown account type: unknown',
+    );
+  });
+});

packages/accounts-controller/src/tests/mocks.ts

@@ -0,0 +1,79 @@
+import type {
+  InternalAccount,
+  InternalAccountType,
+} from '@metamask/keyring-api';
+import {
+  BtcAccountType,
+  BtcMethod,
+  EthAccountType,
+  EthErc4337Method,
+  EthMethod,
+} from '@metamask/keyring-api';
+import { KeyringTypes } from '@metamask/keyring-controller';
+import { v4 } from 'uuid';
+
+export const createMockInternalAccount = ({
+  id = v4(),
+  address = '0x2990079bcdee240329a520d2444386fc119da21a',
+  type = EthAccountType.Eoa,
+  name = 'Account 1',
+  keyringType = KeyringTypes.hd,
+  snap,
+  importTime = Date.now(),
+  lastSelected = Date.now(),
+}: {
+  id?: string;
+  address?: string;
+  type?: InternalAccountType;
+  name?: string;
+  keyringType?: KeyringTypes;
+  snap?: {
+    id: string;
+    enabled: boolean;
+    name: string;
+  };
+  importTime?: number;
+  lastSelected?: number;
+} = {}): InternalAccount => {
+  let methods;
+
+  switch (type) {
+    case EthAccountType.Eoa:
+      methods = [
+        EthMethod.PersonalSign,
+        EthMethod.Sign,
+        EthMethod.SignTransaction,
+        EthMethod.SignTypedDataV1,
+        EthMethod.SignTypedDataV3,
+        EthMethod.SignTypedDataV4,
+      ];
+      break;
+    case EthAccountType.Erc4337:
+      methods = [
+        EthErc4337Method.PatchUserOperation,
+        EthErc4337Method.PrepareUserOperation,
+        EthErc4337Method.SignUserOperation,
+      ];
+      break;
+    case BtcAccountType.P2wpkh:
+      methods = [BtcMethod.SendMany];
+      break;
+    default:
+      throw new Error(`Unknown account type: ${type as string}`);
+  }
+
+  return {
+    id,
+    address,
+    options: {},
+    methods,
+    type,
+    metadata: {
+      name,
+      keyring: { type: keyringType },
+      importTime,
+      lastSelected,
+      snap: snap && snap,
+    },
+  } as InternalAccount;
+};

packages/assets-controllers/package.json

@@ -53,6 +53,7 @@
     "@metamask/contract-metadata": "^2.4.0",
     "@metamask/controller-utils": "^9.1.0",
     "@metamask/eth-query": "^4.0.0",
+    "@metamask/keyring-api": "^6.1.0",
     "@metamask/keyring-controller": "^16.0.0",
     "@metamask/metamask-eth-abis": "^3.1.1",
     "@metamask/network-controller": "^18.1.0",
@@ -73,7 +74,6 @@
   "devDependencies": {
     "@metamask/auto-changelog": "^3.4.4",
     "@metamask/ethjs-provider-http": "^0.3.0",
-    "@metamask/keyring-api": "^6.0.0",
     "@types/jest": "^27.4.1",
     "@types/lodash": "^4.14.191",
     "@types/node": "^16.18.54",