MetaMask
diff --git a/‎app/core/Engine/Engine.test.ts‎
Lines changed: 13 additions & 0 deletions b/‎app/core/Engine/Engine.test.ts‎
Lines changed: 13 additions & 0 deletions
diff --git a/‎app/core/Engine/Engine.ts‎
Lines changed: 4 additions & 0 deletions b/‎app/core/Engine/Engine.ts‎
Lines changed: 4 additions & 0 deletions
diff --git a/‎app/core/Engine/controllers/keyring-controller/keyring-controller-init.test.ts‎
Lines changed: 1 addition & 24 deletions b/‎app/core/Engine/controllers/keyring-controller/keyring-controller-init.test.ts‎
Lines changed: 1 addition & 24 deletions
diff --git a/‎app/core/Engine/controllers/keyring-controller/keyring-controller-init.ts‎
Lines changed: 27 additions & 33 deletions b/‎app/core/Engine/controllers/keyring-controller/keyring-controller-init.ts‎
Lines changed: 27 additions & 33 deletions
diff --git a/‎app/core/Engine/controllers/money-account-controller-init.test.ts‎
Lines changed: 182 additions & 11 deletions b/‎app/core/Engine/controllers/money-account-controller-init.test.ts‎
Lines changed: 182 additions & 11 deletions
@@ -1368,4 +1368,17 @@ describe('Engine', () => {
       expect(sortedControllersInState).toEqual(sortedExpectedControllers);
     });
   });
+
+  describe('resetState', () => {
+    it('calls MoneyAccountController.clearState', async () => {
+      const engine = Engine.init(TEST_ANALYTICS_ID, backgroundState);
+      const clearStateSpy = jest
+        .spyOn(engine.context.MoneyAccountController, 'clearState')
+        .mockImplementation(() => undefined);
+
+      await engine.resetState();
+
+      expect(clearStateSpy).toHaveBeenCalled();
+    });
+  });
 });
@@ -1159,6 +1159,7 @@ export class Engine {
       SnapController,
       ///: END:ONLY_INCLUDE_IF
       LoggingController,
+      MoneyAccountController,
     } = this.context;
 
     // Remove all permissions.
@@ -1189,6 +1190,9 @@ export class Engine {
     }));
 
     LoggingController.clear();
+
+    // Accounts:
+    MoneyAccountController.clearState();
   };
 
   removeAllListeners() {
 
@@ -1,12 +1,4 @@
 import { buildMessengerClientInitRequestMock } from '../../utils/test-utils';
-
-jest.mock('../../../../lib/Money/feature-flags', () => ({
-  isMoneyAccountEnabled: jest.fn(),
-}));
-
-const mockIsMoneyAccountEnabled = jest.requireMock(
-  '../../../../lib/Money/feature-flags',
-).isMoneyAccountEnabled as jest.Mock;
 import { ExtendedMessenger } from '../../../ExtendedMessenger';
 import { getKeyringControllerMessenger } from '../../messengers/keyring-controller-messenger';
 import { MessengerClientInitRequest } from '../../types';
@@ -72,7 +64,6 @@ function getInitRequestMock(): jest.Mocked<
 describe('keyringControllerInit', () => {
   beforeEach(() => {
     jest.clearAllMocks();
-    mockIsMoneyAccountEnabled.mockReturnValue(true);
   });
 
   it('initializes the controller', () => {
@@ -108,26 +99,12 @@ describe('keyringControllerInit', () => {
       return builder;
     }
 
-    it('includes a MoneyKeyring builder when the flag is enabled', () => {
-      mockIsMoneyAccountEnabled.mockReturnValue(true);
-
+    it('always includes a MoneyKeyring builder', () => {
       const builder = getMoneyKeyringBuilder();
 
       expect(builder).toBeDefined();
     });
 
-    it('does not include a MoneyKeyring builder when the flag is disabled', () => {
-      mockIsMoneyAccountEnabled.mockReturnValue(false);
-
-      keyringControllerInit(getInitRequestMock());
-
-      const { keyringBuilders } = jest.mocked(KeyringController).mock
-        .calls[0][0] as { keyringBuilders: KeyringBuilder[] };
-
-      const builder = keyringBuilders.find((b) => b.type === MoneyKeyring.type);
-      expect(builder).toBeUndefined();
-    });
-
     it('creates a MoneyKeyring instance when invoked', () => {
       const builder = getMoneyKeyringBuilder();
 
 
@@ -1,5 +1,4 @@
 import { MessengerClientInitFunction } from '../../types';
-import { isMoneyAccountEnabled } from '../../../../lib/Money/feature-flags';
 import { CryptographicFunctions } from '@metamask/key-tree';
 import { encodeMnemonic } from '@metamask/keyring-sdk';
 import {
@@ -44,10 +43,6 @@ export const keyringControllerInit: MessengerClientInitFunction<
   qrKeyringScanner,
   getMessengerClient,
 }) => {
-  const { remoteFeatureFlags } = getMessengerClient(
-    'RemoteFeatureFlagController',
-  ).state;
-
   // Required by the HD keyring and money keyring to use native crypto functions.
   const cryptographicFunctions: CryptographicFunctions = {
     pbkdf2Sha512: pbkdf2,
@@ -81,35 +76,34 @@ export const keyringControllerInit: MessengerClientInitFunction<
   hdKeyringBuilder.type = HdKeyring.type;
   additionalKeyrings.push(hdKeyringBuilder);
 
-  // We only need this keyring if Money accounts are enabled.
-  if (isMoneyAccountEnabled(remoteFeatureFlags)) {
-    const moneyKeyringBuilder = () =>
-      new MoneyKeyring({
-        cryptographicFunctions,
-        getMnemonic: async (entropySource: string) =>
-          // This builder needs the controller itself, so we re-use `getMessengerClient` to access
-          // the controller instance as it will be available when this method gets called.
-          // NOTE: This is required since we cannot self-use our own actions with the init messenger.
-          getMessengerClient('KeyringController').withKeyringUnsafe(
-            {
-              filter: (keyring, metadata): keyring is HdKeyring =>
-                keyring.type === KeyringTypes.hd &&
-                metadata.id === entropySource,
-            },
-            async ({ keyring }) => {
-              if (!keyring?.mnemonic) {
-                throw new Error(
-                  `Unable to get mnemonic to initialize MoneyKeyring`,
-                );
-              }
+  // The builder is always registered so the KeyringController can recognise the
+  // MoneyKeyring type during vault deserialization (even if the feature flag is
+  // disabled at that time).
+  const moneyKeyringBuilder = () =>
+    new MoneyKeyring({
+      cryptographicFunctions,
+      getMnemonic: async (entropySource: string) =>
+        // This builder needs the controller itself, so we re-use `getMessengerClient` to access
+        // the controller instance as it will be available when this method gets called.
+        // NOTE: This is required since we cannot self-use our own actions with the init messenger.
+        getMessengerClient('KeyringController').withKeyringUnsafe(
+          {
+            filter: (keyring, metadata): keyring is HdKeyring =>
+              keyring.type === KeyringTypes.hd && metadata.id === entropySource,
+          },
+          async ({ keyring }) => {
+            if (!keyring?.mnemonic) {
+              throw new Error(
+                `Unable to get mnemonic to initialize MoneyKeyring`,
+              );
+            }
 
-              return encodeMnemonic(keyring.mnemonic);
-            },
-          ),
-      });
-    moneyKeyringBuilder.type = MoneyKeyring.type;
-    additionalKeyrings.push(moneyKeyringBuilder);
-  }
+            return encodeMnemonic(keyring.mnemonic);
+          },
+        ),
+    });
+  moneyKeyringBuilder.type = MoneyKeyring.type;
+  additionalKeyrings.push(moneyKeyringBuilder);
 
   ///: BEGIN:ONLY_INCLUDE_IF(keyring-snaps)
   const snapKeyringBuilder = getMessengerClient('SnapKeyringBuilder');
 
@@ -1,43 +1,214 @@
 import { buildMessengerClientInitRequestMock } from '../utils/test-utils';
 import { ExtendedMessenger } from '../../ExtendedMessenger';
-import { getMoneyAccountControllerMessenger } from '../messengers/money-account-controller-messenger';
+import {
+  getMoneyAccountControllerInitMessenger,
+  getMoneyAccountControllerMessenger,
+  MoneyAccountControllerInitMessenger,
+} from '../messengers/money-account-controller-messenger';
 import { MessengerClientInitRequest } from '../types';
 import { moneyAccountControllerInit } from './money-account-controller-init';
 import {
   MoneyAccountController,
   MoneyAccountControllerMessenger,
 } from '@metamask/money-account-controller';
 import { MOCK_ANY_NAMESPACE, MockAnyNamespace } from '@metamask/messenger';
+import { RemoteFeatureFlagControllerStateChangeEvent } from '@metamask/remote-feature-flag-controller';
+import { isMoneyAccountEnabled } from '../../../lib/Money/feature-flags';
+import Logger from '../../../util/Logger';
 
 jest.mock('@metamask/money-account-controller');
+jest.mock('../../../lib/Money/feature-flags');
+jest.mock('../../../util/Logger');
+
+const EMPTY_MONEY_ACCOUNTS = { moneyAccounts: {} };
+const NON_EMPTY_MONEY_ACCOUNTS = { moneyAccounts: { 'mock-account-id': {} } };
 
-function getInitRequestMock(): jest.Mocked<
-  MessengerClientInitRequest<MoneyAccountControllerMessenger>
-> {
-  const baseMessenger = new ExtendedMessenger<MockAnyNamespace, never, never>({
+function buildInitRequestMock<
+  Events extends RemoteFeatureFlagControllerStateChangeEvent = never,
+>(
+  baseMessenger = new ExtendedMessenger<MockAnyNamespace, never, Events>({
     namespace: MOCK_ANY_NAMESPACE,
-  });
+  }),
+): {
+  requestMock: jest.Mocked<
+    MessengerClientInitRequest<
+      MoneyAccountControllerMessenger,
+      MoneyAccountControllerInitMessenger
+    >
+  >;
+  baseMessenger: ExtendedMessenger<MockAnyNamespace, never, Events>;
+} {
+  baseMessenger.registerActionHandler(
+    // @ts-expect-error: Action not allowed on root messenger.
+    'RemoteFeatureFlagController:getState',
+    jest.fn().mockReturnValue({ remoteFeatureFlags: {} }),
+  );
 
-  return {
+  baseMessenger.registerActionHandler(
+    // @ts-expect-error: Action not allowed on root messenger.
+    'KeyringController:getState',
+    jest.fn().mockReturnValue({ isUnlocked: true }),
+  );
+
+  const requestMock = {
     ...buildMessengerClientInitRequestMock(baseMessenger),
     controllerMessenger: getMoneyAccountControllerMessenger(baseMessenger),
-    initMessenger: undefined,
-  };
+    initMessenger: getMoneyAccountControllerInitMessenger(baseMessenger),
+  } as jest.Mocked<
+    MessengerClientInitRequest<
+      MoneyAccountControllerMessenger,
+      MoneyAccountControllerInitMessenger
+    >
+  >;
+
+  return { requestMock, baseMessenger };
+}
+
+function publishStateChange(
+  baseMessenger: ExtendedMessenger<
+    MockAnyNamespace,
+    never,
+    RemoteFeatureFlagControllerStateChangeEvent
+  >,
+) {
+  baseMessenger.publish(
+    'RemoteFeatureFlagController:stateChange',
+    { remoteFeatureFlags: {}, cacheTimestamp: 0 },
+    [],
+  );
 }
 
 describe('moneyAccountControllerInit', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
   it('initializes the controller', () => {
-    const { controller } = moneyAccountControllerInit(getInitRequestMock());
+    const { requestMock } = buildInitRequestMock();
+    const { controller } = moneyAccountControllerInit(requestMock);
     expect(controller).toBeInstanceOf(MoneyAccountController);
   });
 
   it('passes the proper arguments to the controller', () => {
-    moneyAccountControllerInit(getInitRequestMock());
+    const { requestMock } = buildInitRequestMock();
+    moneyAccountControllerInit(requestMock);
 
     const controllerMock = jest.mocked(MoneyAccountController);
     expect(controllerMock).toHaveBeenCalledWith({
       messenger: expect.any(Object),
       state: undefined,
     });
   });
+
+  describe('RemoteFeatureFlagController:stateChange subscription', () => {
+    function buildStateChangeSetup() {
+      const baseMessenger = new ExtendedMessenger<
+        MockAnyNamespace,
+        never,
+        RemoteFeatureFlagControllerStateChangeEvent
+      >({ namespace: MOCK_ANY_NAMESPACE });
+
+      const { requestMock } = buildInitRequestMock(baseMessenger);
+      return { requestMock, baseMessenger };
+    }
+
+    it('calls controller.init() when flag is enabled and keyring is unlocked', async () => {
+      jest.mocked(isMoneyAccountEnabled).mockReturnValue(true);
+
+      const { requestMock, baseMessenger } = buildStateChangeSetup();
+      const { controller } = moneyAccountControllerInit(requestMock);
+      (controller as unknown as { state: unknown }).state =
+        EMPTY_MONEY_ACCOUNTS;
+
+      publishStateChange(baseMessenger);
+      await Promise.resolve();
+
+      expect(jest.mocked(controller.init)).toHaveBeenCalledTimes(1);
+    });
+
+    it('does not call controller.init() when flag is enabled but keyring is locked', async () => {
+      jest.mocked(isMoneyAccountEnabled).mockReturnValue(true);
+
+      const { requestMock, baseMessenger } = buildStateChangeSetup();
+
+      baseMessenger.unregisterActionHandler(
+        // @ts-expect-error: Action not allowed on root messenger.
+        'KeyringController:getState',
+      );
+      baseMessenger.registerActionHandler(
+        // @ts-expect-error: Action not allowed on root messenger.
+        'KeyringController:getState',
+        jest.fn().mockReturnValue({ isUnlocked: false }),
+      );
+
+      const { controller } = moneyAccountControllerInit(requestMock);
+      (controller as unknown as { state: unknown }).state =
+        EMPTY_MONEY_ACCOUNTS;
+
+      publishStateChange(baseMessenger);
+      await Promise.resolve();
+
+      expect(jest.mocked(controller.init)).not.toHaveBeenCalled();
+    });
+
+    it('does not call controller.init() when flag is enabled but money account already exists', async () => {
+      jest.mocked(isMoneyAccountEnabled).mockReturnValue(true);
+
+      const { requestMock, baseMessenger } = buildStateChangeSetup();
+      const { controller } = moneyAccountControllerInit(requestMock);
+      (controller as unknown as { state: unknown }).state =
+        NON_EMPTY_MONEY_ACCOUNTS;
+
+      publishStateChange(baseMessenger);
+      await Promise.resolve();
+
+      expect(jest.mocked(controller.init)).not.toHaveBeenCalled();
+    });
+
+    it('calls controller.clearState() when flag is disabled and money accounts exist', async () => {
+      jest.mocked(isMoneyAccountEnabled).mockReturnValue(false);
+
+      const { requestMock, baseMessenger } = buildStateChangeSetup();
+      const { controller } = moneyAccountControllerInit(requestMock);
+      (controller as unknown as { state: unknown }).state =
+        NON_EMPTY_MONEY_ACCOUNTS;
+
+      publishStateChange(baseMessenger);
+      await Promise.resolve();
+
+      expect(jest.mocked(controller.clearState)).toHaveBeenCalledTimes(1);
+    });
+
+    it('does not call controller.clearState() when flag is disabled and no money accounts exist', async () => {
+      jest.mocked(isMoneyAccountEnabled).mockReturnValue(false);
+
+      const { requestMock, baseMessenger } = buildStateChangeSetup();
+      const { controller } = moneyAccountControllerInit(requestMock);
+      (controller as unknown as { state: unknown }).state =
+        EMPTY_MONEY_ACCOUNTS;
+
+      publishStateChange(baseMessenger);
+      await Promise.resolve();
+
+      expect(jest.mocked(controller.clearState)).not.toHaveBeenCalled();
+    });
+
+    it('logs an error when the stateChange callback throws', async () => {
+      const error = new Error('mock error');
+      jest.mocked(isMoneyAccountEnabled).mockImplementation(() => {
+        throw error;
+      });
+
+      const { requestMock, baseMessenger } = buildStateChangeSetup();
+      moneyAccountControllerInit(requestMock);
+
+      publishStateChange(baseMessenger);
+      await Promise.resolve();
+
+      expect(jest.mocked(Logger.error)).toHaveBeenCalledWith(
+        error,
+        'MoneyAccountController: error handling RemoteFeatureFlagController state change',
+      );
+    });
+  });
 });