feat(wallet): wire RemoteFeatureFlagController into default initialization

.github/CODEOWNERS

@@ -134,6 +134,7 @@
 /packages/wallet/src/initialization/instances/approval-controller/ @MetaMask/confirmations
 /packages/wallet/src/initialization/instances/connectivity-controller/ @MetaMask/core-platform
 /packages/wallet/src/initialization/instances/keyring-controller/ @MetaMask/accounts-engineers @MetaMask/core-platform
+/packages/wallet/src/initialization/instances/remote-feature-flag-controller/ @MetaMask/extension-platform @MetaMask/mobile-platform @MetaMask/core-platform
 /packages/wallet/src/initialization/instances/storage-service/ @MetaMask/extension-platform @MetaMask/mobile-platform @MetaMask/core-platform
 
 ## Package Release related

README.md

@@ -595,6 +595,7 @@ linkStyle default opacity:0.5
   wallet --> controller_utils;
   wallet --> keyring_controller;
   wallet --> messenger;
+  wallet --> remote_feature_flag_controller;
   wallet --> storage_service;
 ```
 

packages/wallet/CHANGELOG.md

@@ -12,6 +12,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **BREAKING:** Add `AccountsController` and `ConnectivityController` as default initialized controllers ([#8924](https://github.com/MetaMask/core/pull/8924))
   - Passing `instanceOptions.connectivityController.connectivityAdapter` is now required.
   - Export `AlwaysOnlineAdapter` from the package root for environments without a platform-specific network API (e.g. Node/tests).
+- **BREAKING:** Wire `RemoteFeatureFlagController` into the default wallet initialization ([#8969](https://github.com/MetaMask/core/pull/8969))
+  - The default `Wallet` now constructs a `RemoteFeatureFlagController` and registers its `RemoteFeatureFlagController:*` messenger actions. Consumers that pass their own `messenger` and already wire a `RemoteFeatureFlagController` must remove their own before upgrading, or the duplicate registration will collide.
+  - Adds a required `remoteFeatureFlagController` slot to `instanceOptions`. `clientConfigApiService` is required (each client injects a `ClientConfigApiService` configured for its own client type, distribution, and environment); `getMetaMetricsId`, `clientVersion`, `prevClientVersion`, `fetchInterval`, and `disabled` are optional. `prevClientVersion` lets consumers trigger feature-flag cache invalidation when the client version changes between sessions.
 
 ## [3.0.0]
 

packages/wallet/package.json

@@ -61,6 +61,7 @@
     "@metamask/controller-utils": "^12.1.1",
     "@metamask/keyring-controller": "^27.0.0",
     "@metamask/messenger": "^1.2.0",
+    "@metamask/remote-feature-flag-controller": "^4.2.2",
     "@metamask/scure-bip39": "^2.1.1",
     "@metamask/storage-service": "^1.0.2",
     "@metamask/utils": "^11.9.0"

packages/wallet/src/Wallet.test.ts

@@ -13,6 +13,15 @@ import { Wallet } from './Wallet';
 const TEST_SRP = 'test test test test test test test test test test test ball';
 const TEST_PASSWORD = 'testpass';
 
+const REMOTE_FEATURE_FLAG_OPTIONS = {
+  clientConfigApiService: {
+    fetchRemoteFeatureFlags: async (): Promise<{
+      remoteFeatureFlags: Record<string, boolean>;
+      cacheTimestamp: number;
+    }> => ({ remoteFeatureFlags: {}, cacheTimestamp: Date.now() }),
+  },
+};
+
 async function setupWallet(): Promise<Wallet> {
   const wallet = new Wallet({
     instanceOptions: {
@@ -22,6 +31,7 @@ async function setupWallet(): Promise<Wallet> {
       storageService: {
         storage: new InMemoryStorageAdapter(),
       },
+      remoteFeatureFlagController: REMOTE_FEATURE_FLAG_OPTIONS,
     },
   });
 
@@ -81,6 +91,7 @@ describe('Wallet', () => {
         storageService: {
           storage: new InMemoryStorageAdapter(),
         },
+        remoteFeatureFlagController: REMOTE_FEATURE_FLAG_OPTIONS,
       },
     });
 
@@ -126,6 +137,7 @@ describe('Wallet', () => {
         storageService: {
           storage: new InMemoryStorageAdapter(),
         },
+        remoteFeatureFlagController: REMOTE_FEATURE_FLAG_OPTIONS,
       },
     });
     const { state } = wallet;
@@ -165,6 +177,7 @@ describe('Wallet', () => {
         storageService: {
           storage: new InMemoryStorageAdapter(),
         },
+        remoteFeatureFlagController: REMOTE_FEATURE_FLAG_OPTIONS,
       },
     });
 
@@ -239,6 +252,7 @@ describe('Wallet', () => {
           storageService: {
             storage: new InMemoryStorageAdapter(),
           },
+          remoteFeatureFlagController: REMOTE_FEATURE_FLAG_OPTIONS,
         },
       });
 
@@ -275,6 +289,7 @@ describe('Wallet', () => {
           storageService: {
             storage: new InMemoryStorageAdapter(),
           },
+          remoteFeatureFlagController: REMOTE_FEATURE_FLAG_OPTIONS,
         },
       });
 
@@ -324,4 +339,53 @@ describe('Wallet', () => {
       ).toBe('bar');
     });
   });
+
+  describe('RemoteFeatureFlagController', () => {
+    it('is wired and exposes its state on the wallet messenger', async () => {
+      const wallet = await setupWallet();
+      const { messenger } = wallet;
+
+      expect(
+        messenger.call('RemoteFeatureFlagController:getState'),
+      ).toStrictEqual({
+        remoteFeatureFlags: {},
+        localOverrides: {},
+        rawRemoteFeatureFlags: {},
+        cacheTimestamp: 0,
+      });
+    });
+
+    it('routes injected instanceOptions through to the controller', async () => {
+      const wallet = new Wallet({
+        instanceOptions: {
+          connectivityController: {
+            connectivityAdapter: new AlwaysOnlineAdapter(),
+          },
+          keyringController: { encryptor: new MockEncryptor() },
+          storageService: { storage: new InMemoryStorageAdapter() },
+          remoteFeatureFlagController: {
+            clientConfigApiService: {
+              fetchRemoteFeatureFlags: async (): Promise<{
+                remoteFeatureFlags: Record<string, boolean>;
+                cacheTimestamp: number;
+              }> => ({
+                remoteFeatureFlags: { testFlag: true },
+                cacheTimestamp: Date.now(),
+              }),
+            },
+          },
+        },
+      });
+      const { messenger } = wallet;
+
+      await messenger.call(
+        'RemoteFeatureFlagController:updateRemoteFeatureFlags',
+      );
+
+      expect(
+        messenger.call('RemoteFeatureFlagController:getState')
+          .remoteFeatureFlags,
+      ).toStrictEqual({ testFlag: true });
+    });
+  });
 });

packages/wallet/src/initialization/instances/index.ts

@@ -2,4 +2,5 @@ export { accountsController } from './accounts-controller/accounts-controller';
 export { approvalController } from './approval-controller/approval-controller';
 export { connectivityController } from './connectivity-controller/connectivity-controller';
 export { keyringController } from './keyring-controller/keyring-controller';
+export { remoteFeatureFlagController } from './remote-feature-flag-controller/remote-feature-flag-controller';
 export { storageService } from './storage-service/storage-service';

packages/wallet/src/initialization/instances/remote-feature-flag-controller/remote-feature-flag-controller.test.ts

@@ -0,0 +1,234 @@
+import { Messenger } from '@metamask/messenger';
+import { RemoteFeatureFlagController } from '@metamask/remote-feature-flag-controller';
+
+import { defaultConfigurations } from '../../defaults';
+import type {
+  DefaultActions,
+  DefaultEvents,
+  RootMessenger,
+} from '../../defaults';
+import { remoteFeatureFlagController } from './remote-feature-flag-controller';
+
+/**
+ * Creates a root messenger for use in tests.
+ *
+ * @returns A root messenger.
+ */
+function getRootMessenger(): RootMessenger<DefaultActions, DefaultEvents> {
+  return new Messenger({ namespace: 'Root' });
+}
+
+/**
+ * Creates a stub client-config API service whose `fetchRemoteFeatureFlags`
+ * resolves to an empty flag set.
+ *
+ * @returns A stub client-config API service.
+ */
+function getClientConfigApiService(): { fetchRemoteFeatureFlags: jest.Mock } {
+  return {
+    fetchRemoteFeatureFlags: jest.fn().mockResolvedValue({
+      remoteFeatureFlags: {},
+      cacheTimestamp: Date.now(),
+    }),
+  };
+}
+
+describe('remoteFeatureFlagController', () => {
+  it('is registered as a default initialization configuration', () => {
+    expect(Object.values(defaultConfigurations)).toContain(
+      remoteFeatureFlagController,
+    );
+  });
+
+  it('initializes a RemoteFeatureFlagController with default state', () => {
+    const messenger =
+      remoteFeatureFlagController.getMessenger(getRootMessenger());
+
+    const instance = remoteFeatureFlagController.init({
+      state: undefined,
+      messenger,
+      options: { clientConfigApiService: getClientConfigApiService() },
+    });
+
+    expect(instance).toBeInstanceOf(RemoteFeatureFlagController);
+    expect(instance.state).toStrictEqual({
+      remoteFeatureFlags: {},
+      localOverrides: {},
+      rawRemoteFeatureFlags: {},
+      cacheTimestamp: 0,
+    });
+  });
+
+  it('forwards the provided state to the controller', () => {
+    const messenger =
+      remoteFeatureFlagController.getMessenger(getRootMessenger());
+
+    const instance = remoteFeatureFlagController.init({
+      state: {
+        remoteFeatureFlags: { testFlag: true },
+        cacheTimestamp: 12345,
+      },
+      messenger,
+      options: { clientConfigApiService: getClientConfigApiService() },
+    });
+
+    expect(instance.state.remoteFeatureFlags).toStrictEqual({ testFlag: true });
+  });
+
+  it('applies default getMetaMetricsId and clientVersion when omitted', async () => {
+    const clientConfigApiService = getClientConfigApiService();
+    const messenger =
+      remoteFeatureFlagController.getMessenger(getRootMessenger());
+
+    const instance = remoteFeatureFlagController.init({
+      state: undefined,
+      messenger,
+      options: { clientConfigApiService },
+    });
+
+    await instance.updateRemoteFeatureFlags();
+
+    expect(
+      clientConfigApiService.fetchRemoteFeatureFlags,
+    ).toHaveBeenCalledTimes(1);
+    expect(instance.state.remoteFeatureFlags).toStrictEqual({});
+  });
+
+  it('uses the injected clientConfigApiService, getMetaMetricsId, and clientVersion', async () => {
+    const fetchRemoteFeatureFlags = jest.fn().mockResolvedValue({
+      remoteFeatureFlags: { testFlag: true },
+      cacheTimestamp: Date.now(),
+    });
+    const getMetaMetricsId = jest.fn(() => 'test-metrics-id');
+    const messenger =
+      remoteFeatureFlagController.getMessenger(getRootMessenger());
+
+    const instance = remoteFeatureFlagController.init({
+      state: undefined,
+      messenger,
+      options: {
+        clientConfigApiService: { fetchRemoteFeatureFlags },
+        getMetaMetricsId,
+        clientVersion: '1.2.3',
+      },
+    });
+
+    await instance.updateRemoteFeatureFlags();
+
+    expect(fetchRemoteFeatureFlags).toHaveBeenCalledTimes(1);
+    expect(getMetaMetricsId).toHaveBeenCalled();
+    expect(instance.state.remoteFeatureFlags).toStrictEqual({ testFlag: true });
+  });
+
+  it('does not fetch flags when initialized as disabled', async () => {
+    const clientConfigApiService = getClientConfigApiService();
+    const messenger =
+      remoteFeatureFlagController.getMessenger(getRootMessenger());
+
+    const instance = remoteFeatureFlagController.init({
+      state: undefined,
+      messenger,
+      options: { clientConfigApiService, disabled: true },
+    });
+
+    await instance.updateRemoteFeatureFlags();
+
+    expect(
+      clientConfigApiService.fetchRemoteFeatureFlags,
+    ).not.toHaveBeenCalled();
+  });
+
+  it('invalidates the cache when prevClientVersion differs from clientVersion', () => {
+    const messenger =
+      remoteFeatureFlagController.getMessenger(getRootMessenger());
+
+    const instance = remoteFeatureFlagController.init({
+      state: {
+        remoteFeatureFlags: { testFlag: true },
+        cacheTimestamp: Date.now(),
+      },
+      messenger,
+      options: {
+        clientConfigApiService: getClientConfigApiService(),
+        clientVersion: '2.0.0',
+        prevClientVersion: '1.0.0',
+      },
+    });
+
+    expect(instance.state.cacheTimestamp).toBe(0);
+  });
+
+  it('preserves the cache when prevClientVersion matches clientVersion', () => {
+    const messenger =
+      remoteFeatureFlagController.getMessenger(getRootMessenger());
+
+    const instance = remoteFeatureFlagController.init({
+      state: {
+        remoteFeatureFlags: { testFlag: true },
+        cacheTimestamp: 5000,
+      },
+      messenger,
+      options: {
+        clientConfigApiService: getClientConfigApiService(),
+        clientVersion: '2.0.0',
+        prevClientVersion: '2.0.0',
+      },
+    });
+
+    expect(instance.state.cacheTimestamp).toBe(5000);
+  });
+
+  it('surfaces the controller throw on an invalid clientVersion', () => {
+    const messenger =
+      remoteFeatureFlagController.getMessenger(getRootMessenger());
+
+    expect(() =>
+      remoteFeatureFlagController.init({
+        state: undefined,
+        messenger,
+        options: {
+          clientConfigApiService: getClientConfigApiService(),
+          clientVersion: 'not-semver',
+        },
+      }),
+    ).toThrow('Invalid clientVersion');
+  });
+
+  it('forwards a custom fetchInterval to the controller', async () => {
+    const clientConfigApiService = getClientConfigApiService();
+    const messenger =
+      remoteFeatureFlagController.getMessenger(getRootMessenger());
+
+    const instance = remoteFeatureFlagController.init({
+      state: { remoteFeatureFlags: {}, cacheTimestamp: Date.now() },
+      messenger,
+      options: { clientConfigApiService, fetchInterval: 60 * 60 * 1000 },
+    });
+
+    await instance.updateRemoteFeatureFlags();
+
+    expect(
+      clientConfigApiService.fetchRemoteFeatureFlags,
+    ).not.toHaveBeenCalled();
+  });
+
+  it('exposes its state through the root messenger', () => {
+    const rootMessenger = getRootMessenger();
+    const messenger = remoteFeatureFlagController.getMessenger(rootMessenger);
+
+    remoteFeatureFlagController.init({
+      state: undefined,
+      messenger,
+      options: { clientConfigApiService: getClientConfigApiService() },
+    });
+
+    expect(
+      rootMessenger.call('RemoteFeatureFlagController:getState'),
+    ).toStrictEqual({
+      remoteFeatureFlags: {},
+      localOverrides: {},
+      rawRemoteFeatureFlags: {},
+      cacheTimestamp: 0,
+    });
+  });
+});