feat: add scopes field to KeyringAccount

app/scripts/background.js

@@ -617,6 +617,13 @@ export async function loadStateFromPersistence() {
   versionedData =
     (await localStore.get()) || migrator.generateInitialState(firstTimeState);
 
+  // Force migration 136 to inject scopes on existing accounts:
+  // versionedData.meta.version = 135;
+  // console.log(
+  //  'HACK -- Forcing version to force account.scopes migration, using: ',
+  //  versionedData.meta.version,
+  // );
+
   // check if somehow state is empty
   // this should never happen but new error reporting suggests that it has
   // for a small number of users

app/scripts/controllers/alert-controller.test.ts

@@ -163,6 +163,7 @@ describe('AlertController', () => {
           address: '0x1234567',
           options: {},
           methods: [],
+          scopes: ['eip155'],
           type: 'eip155:eoa',
           metadata: {
             name: '',

app/scripts/lib/snap-keyring/snap-keyring.test.ts

@@ -40,6 +40,7 @@ const mockAccount = {
   id: '3afa663e-0600-4d93-868a-61c2e553013b',
   address,
   methods: [],
+  scopes: ['eip155'],
   options: {},
 };
 const mockInternalAccount = {

app/scripts/migrations/105.test.ts

@@ -1,8 +1,8 @@
 import { v4 as uuid } from 'uuid';
 import { sha256FromString } from 'ethereumjs-util';
-import { InternalAccount } from '@metamask/keyring-internal-api';
 import { ETH_EOA_METHODS } from '../../../shared/constants/eth-methods';
 import { migrate } from './105';
+import type { Identity, InternalAccount } from './105';
 
 const MOCK_ADDRESS = '0x0';
 const MOCK_ADDRESS_2 = '0x1';
@@ -22,12 +22,6 @@ function addressToUUID(address: string): string {
   });
 }
 
-type Identity = {
-  name: string;
-  address: string;
-  lastSelected?: number;
-};
-
 type Identities = {
   [key: string]: Identity;
 };

app/scripts/migrations/105.ts

@@ -1,21 +1,37 @@
 import { EthAccountType } from '@metamask/keyring-api';
-import { InternalAccount } from '@metamask/keyring-internal-api';
 import { sha256FromString } from 'ethereumjs-util';
 import { v4 as uuid } from 'uuid';
 import { cloneDeep } from 'lodash';
+import { Json } from '@metamask/utils';
 import { ETH_EOA_METHODS } from '../../../shared/constants/eth-methods';
 
 type VersionedData = {
   meta: { version: number };
   data: Record<string, unknown>;
 };
 
-type Identity = {
+export type Identity = {
   name: string;
   address: string;
   lastSelected?: number;
 };
 
+export type InternalAccount = {
+  type: string;
+  id: string;
+  options: Record<string, Json>;
+  metadata: {
+    name: string;
+    importTime: number;
+    keyring: {
+      type: string;
+    };
+    lastSelected?: number;
+  };
+  address: string;
+  methods: string[];
+};
+
 export const version = 105;
 
 /**

app/scripts/migrations/136.test.ts

@@ -0,0 +1,177 @@
+import { AccountsControllerState } from '@metamask/accounts-controller';
+import { cloneDeep } from 'lodash';
+import { createMockInternalAccount } from '../../../test/jest/mocks';
+import { migrate, version } from './136';
+
+const sentryCaptureExceptionMock = jest.fn();
+
+global.sentry = {
+  captureException: sentryCaptureExceptionMock,
+};
+
+const oldVersion = 134;
+
+const mockInternalAccount = createMockInternalAccount();
+const mockAccountsControllerState: AccountsControllerState = {
+  internalAccounts: {
+    accounts: {
+      [mockInternalAccount.id]: mockInternalAccount,
+    },
+    selectedAccount: mockInternalAccount.id,
+  },
+};
+
+describe(`migration #${version}`, () => {
+  afterEach(() => jest.resetAllMocks());
+
+  it('updates the version metadata', async () => {
+    const oldStorage = {
+      meta: { version: oldVersion },
+      data: {
+        AccountsController: mockAccountsControllerState,
+      },
+    };
+
+    const newStorage = await migrate(cloneDeep(oldStorage));
+    expect(newStorage.meta).toStrictEqual({ version });
+  });
+
+  it('does nothing if all accounts have scopes already', async () => {
+    const oldStorage = {
+      meta: { version: oldVersion },
+      data: {
+        AccountsController: mockAccountsControllerState,
+      },
+    };
+
+    const newStorage = await migrate(cloneDeep(oldStorage));
+    expect(newStorage.data).toStrictEqual(oldStorage.data);
+  });
+
+  it('does nothing if AccountsController state is missing', async () => {
+    const oldStorage = {
+      meta: { version: oldVersion },
+      data: {
+        OtherController: {},
+      },
+    };
+
+    const newStorage = await migrate(cloneDeep(oldStorage));
+    expect(newStorage.data).toStrictEqual(oldStorage.data);
+  });
+
+  it.only('adds a scopes if it is missing on an account', async () => {
+    const { scopes: _, ...mockInternalAccountWithoutScopes } =
+      mockInternalAccount;
+    const oldStorage = {
+      meta: { version: oldVersion },
+      data: {
+        AccountsController: {
+          internalAccounts: {
+            accounts: {
+              [mockInternalAccountWithoutScopes.id]:
+                mockInternalAccountWithoutScopes,
+            },
+            selectedAccount: mockInternalAccountWithoutScopes.id,
+          },
+        },
+      },
+    };
+
+    const newStorage = await migrate(cloneDeep(oldStorage));
+    expect(newStorage.data).toStrictEqual({
+      // This mock state already has the expected scope
+      AccountsController: mockAccountsControllerState,
+    });
+  });
+
+  // @ts-expect-error 'each' function missing from type definitions, but it does exist
+  it.each([
+    {
+      label: 'AccountsController type',
+      message: `Migration ${version}: Invalid AccountsController state of type 'string'`,
+      state: { AccountsController: 'invalid' },
+    },
+    {
+      label: 'Missing internalAccounts',
+      message: `Migration ${version}: Invalid AccountsController state, missing internalAccounts`,
+      state: { AccountsController: {} },
+    },
+    {
+      label: 'Invalid internalAccounts',
+      message: `Migration ${version}: Invalid AccountsController internalAccounts state of type 'string'`,
+      state: { AccountsController: { internalAccounts: 'invalid' } },
+    },
+    {
+      label: 'Missing accounts',
+      message: `Migration ${version}: Invalid AccountsController internalAccounts state, missing accounts`,
+      state: {
+        AccountsController: {
+          internalAccounts: {},
+        },
+      },
+    },
+    {
+      label: 'Invalid accounts',
+      message: `Migration ${version}: Invalid AccountsController internalAccounts.accounts state of type 'string'`,
+      state: {
+        AccountsController: {
+          internalAccounts: { accounts: 'invalid' },
+        },
+      },
+    },
+    {
+      label: 'Invalid accounts entry',
+      message: `Migration ${version}: Invalid AccountsController's account (object) type, is 'string'`,
+      state: {
+        AccountsController: {
+          internalAccounts: {
+            accounts: { [mockInternalAccount.id]: 'invalid' },
+          },
+        },
+      },
+    },
+    {
+      label: 'Missing type in accounts entry',
+      message: `Migration ${version}: Invalid AccountsController's account missing 'type' property`,
+      state: {
+        AccountsController: {
+          internalAccounts: {
+            accounts: { [mockInternalAccount.id]: {} },
+          },
+        },
+      },
+    },
+    {
+      label: 'Invalid type for accounts entry',
+      message: `Migration ${version}: Invalid AccountsController's account.type type, is 'object'`,
+      state: {
+        AccountsController: {
+          internalAccounts: {
+            accounts: { [mockInternalAccount.id]: { type: {} } },
+          },
+        },
+      },
+    },
+  ])(
+    'captures error when state is invalid due to: $label',
+    async ({
+      message,
+      state,
+    }: {
+      message: string;
+      state: Record<string, unknown>;
+    }) => {
+      const oldStorage = {
+        meta: { version: oldVersion },
+        data: state,
+      };
+
+      const newStorage = await migrate(cloneDeep(oldStorage));
+      expect(sentryCaptureExceptionMock).toHaveBeenCalledWith(
+        new Error(message),
+      );
+      expect(newStorage.data).toStrictEqual(oldStorage.data);
+    },
+  );
+});