feat: Make A/B tests independent

packages/remote-feature-flag-controller/package.json

@@ -52,6 +52,7 @@
     "@metamask/controller-utils": "^11.16.0",
     "@metamask/messenger": "^0.3.0",
     "@metamask/utils": "^11.8.1",
+    "@noble/hashes": "^1.8.0",
     "uuid": "^8.3.2"
   },
   "devDependencies": {

packages/remote-feature-flag-controller/src/remote-feature-flag-controller.test.ts

@@ -321,11 +321,13 @@
       });
       await controller.updateRemoteFeatureFlags();
 
+      // With MOCK_METRICS_ID + 'testFlagForThreshold' hashed:
+      // Threshold = 0.380673, which falls in groupB range (0.3 < t <= 0.5)
       expect(
         controller.state.remoteFeatureFlags.testFlagForThreshold,
       ).toStrictEqual({
-        name: 'groupC',
-        value: 'valueC',
+        name: 'groupB',
+        value: 'valueB',
       });
     });
 
@@ -343,6 +345,71 @@
         controller.state.remoteFeatureFlags;
       expect(nonThresholdFlags).toStrictEqual(MOCK_FLAGS);
     });
+
+    it('assigns users to different groups for different feature flags', async () => {
+      // Arrange
+      const mockFlags = {
+        featureA: [
+          { name: 'groupA1', scope: { type: 'threshold', value: 0.5 }, value: 'A1' },
+          { name: 'groupA2', scope: { type: 'threshold', value: 1.0 }, value: 'A2' },
+        ],
+        featureB: [
+          { name: 'groupB1', scope: { type: 'threshold', value: 0.5 }, value: 'B1' },
+          { name: 'groupB2', scope: { type: 'threshold', value: 1.0 }, value: 'B2' },
+        ],
+      };
+      const clientConfigApiService = buildClientConfigApiService({
+        remoteFeatureFlags: mockFlags,
+      });
+      const controller = createController({
+        clientConfigApiService,
+        getMetaMetricsId: () => MOCK_METRICS_ID,
+      });
+
+      // Act
+      await controller.updateRemoteFeatureFlags();
+
+      // Assert - User gets different groups because each flag uses unique seed
+      const { featureA, featureB } = controller.state.remoteFeatureFlags;
+      // featureA: hash(MOCK_METRICS_ID + 'featureA') → threshold 0.966682 → groupA2
+      expect(featureA).toStrictEqual({ name: 'groupA2', value: 'A2' });
+      // featureB: hash(MOCK_METRICS_ID + 'featureB') → threshold 0.398654 → groupB1
+      expect(featureB).toStrictEqual({ name: 'groupB1', value: 'B1' });
+      // Different groups proves independence!
+    });
+
+    it('assigns users to same group for same feature flag on multiple calls', async () => {
+      // Arrange
+      const mockFlags = {
+        testFlag: [
+          { name: 'control', scope: { type: 'threshold', value: 0.5 }, value: false },
+          { name: 'treatment', scope: { type: 'threshold', value: 1.0 }, value: true },
+        ],
+      };
+      const clientConfigApiService = buildClientConfigApiService({
+        remoteFeatureFlags: mockFlags,
+      });
+
+      // Act - Create two separate controllers with same metaMetricsId
+      const controller1 = createController({
+        clientConfigApiService,
+        getMetaMetricsId: () => MOCK_METRICS_ID,
+      });
+      await controller1.updateRemoteFeatureFlags();
+      const firstResult = controller1.state.remoteFeatureFlags.testFlag;
+
+      const controller2 = createController({
+        clientConfigApiService,
+        getMetaMetricsId: () => MOCK_METRICS_ID,
+      });
+      await controller2.updateRemoteFeatureFlags();
+      const secondResult = controller2.state.remoteFeatureFlags.testFlag;
+
+      // Assert - Same user always gets same group (deterministic)
+      // testFlag: hash(MOCK_METRICS_ID + 'testFlag') → threshold 0.496587 → control
+      expect(firstResult).toStrictEqual(secondResult);
+      expect(firstResult).toStrictEqual({ name: 'control', value: false });
+    });
   });
 
   describe('enable and disable', () => {
@@ -632,10 +699,11 @@
       const { multiVersionABFlag, regularFlag } =
         controller.state.remoteFeatureFlags;
       // Should select 13.1.0 version and then apply A/B testing to that array
-      // With MOCK_METRICS_ID threshold, should select groupC (threshold 1.0)
+      // With MOCK_METRICS_ID + 'multiVersionABFlag' hashed:
+      // Threshold = 0.094878, which falls in groupA range (t <= 0.3)
       expect(multiVersionABFlag).toStrictEqual({
-        name: 'groupC',
-        value: { feature: 'C', enabled: true },
+        name: 'groupA',
+        value: { feature: 'A', enabled: true },
       });
       expect(regularFlag).toBe(true);
     });

packages/remote-feature-flag-controller/src/remote-feature-flag-controller.ts

@@ -14,6 +14,7 @@ import type {
   FeatureFlagScopeValue,
 } from './remote-feature-flag-controller-types';
 import {
+  createDeterministicSeed,
   generateDeterministicRandomNumber,
   isFeatureFlagWithScopeValue,
 } from './utils/user-segmentation-utils';
@@ -278,7 +279,6 @@ export class RemoteFeatureFlagController extends BaseController<
   ): Promise<FeatureFlags> {
     const processedRemoteFeatureFlags: FeatureFlags = {};
     const metaMetricsId = this.#getMetaMetricsId();
-    const thresholdValue = generateDeterministicRandomNumber(metaMetricsId);
 
     for (const [
       remoteFeatureFlagName,
@@ -291,7 +291,12 @@ export class RemoteFeatureFlagController extends BaseController<
         continue;
       }
 
-      if (Array.isArray(processedValue) && thresholdValue) {
+      if (Array.isArray(processedValue)) {
+        const deterministicSeed = createDeterministicSeed(
+          metaMetricsId + remoteFeatureFlagName,
+        );
+        const thresholdValue =
+          generateDeterministicRandomNumber(deterministicSeed);
         const selectedGroup = processedValue.find(
           (featureFlag): featureFlag is FeatureFlagScopeValue => {
             if (!isFeatureFlagWithScopeValue(featureFlag)) {

packages/remote-feature-flag-controller/src/utils/user-segmentation-utils.test.ts

@@ -1,6 +1,7 @@
 import { v4 as uuidV4 } from 'uuid';
 
 import {
+  createDeterministicSeed,
   generateDeterministicRandomNumber,
   isFeatureFlagWithScopeValue,
 } from './user-segmentation-utils';
@@ -41,6 +42,63 @@
 };
 
 describe('user-segmentation-utils', () => {
+  describe('createDeterministicSeed', () => {
+    it('generates deterministic hash from same input', () => {
+      // Arrange
+      const seed = 'testSeed123';
+
+      // Act
+      const hash1 = createDeterministicSeed(seed);
+      const hash2 = createDeterministicSeed(seed);
+
+      // Assert
+      expect(hash1).toBe(hash2);
+      expect(hash1).toMatch(/^0x[0-9a-f]{64}$/);
+    });
+
+    it('generates different hashes for different inputs', () => {
+      // Arrange
+      const seed1 = 'metaMetricsId123';
+      const seed2 = 'metaMetricsId456';
+
+      // Act
+      const hash1 = createDeterministicSeed(seed1);
+      const hash2 = createDeterministicSeed(seed2);
+
+      // Assert
+      expect(hash1).not.toBe(hash2);
+    });
+
+    it('generates different hashes when concatenating different flag names', () => {
+      // Arrange
+      const metaMetricsId = 'f9e8d7c6-b5a4-4210-9876-543210fedcba';
+      const flagName1 = 'featureA';
+      const flagName2 = 'featureB';
+
+      // Act
+      const seed1 = createDeterministicSeed(metaMetricsId + flagName1);
+      const seed2 = createDeterministicSeed(metaMetricsId + flagName2);
+
+      // Assert
+      expect(seed1).not.toBe(seed2);
+      expect(seed1).toMatch(/^0x[0-9a-f]{64}$/);
+      expect(seed2).toMatch(/^0x[0-9a-f]{64}$/);
+    });
+
+    it('produces valid hex format for generateDeterministicRandomNumber', () => {
+      // Arrange
+      const seed = 'anyStringInput123!@#';
+
+      // Act
+      const hash = createDeterministicSeed(seed);
+      const randomNumber = generateDeterministicRandomNumber(hash);
+
+      // Assert
+      expect(randomNumber).toBeGreaterThanOrEqual(0);
+      expect(randomNumber).toBeLessThanOrEqual(1);
+    });
+  });
+
   describe('generateDeterministicRandomNumber', () => {
     describe('Mobile client new implementation (uuidv4)', () => {
       it('generates consistent results for same uuidv4', () => {

packages/remote-feature-flag-controller/src/utils/user-segmentation-utils.ts

@@ -1,5 +1,7 @@
 import type { Json } from '@metamask/utils';
 import { validate as uuidValidate, version as uuidVersion } from 'uuid';
+import { sha256 } from '@noble/hashes/sha256';
+import { bytesToHex } from '@noble/hashes/utils';
 
 import type { FeatureFlagScopeValue } from '../remote-feature-flag-controller-types';
 
@@ -19,6 +21,19 @@
 const MAX_UUID_V4_BIGINT = uuidStringToBigInt(MAX_UUID_V4);
 const UUID_V4_VALUE_RANGE_BIGINT = MAX_UUID_V4_BIGINT - MIN_UUID_V4_BIGINT;
 
+/**
+ * Creates a deterministic hex ID by hashing the input seed.
+ * This ensures consistent group assignment for A/B testing across different feature flags.
+ *
+ * @param seed - The seed string to hash (e.g., metaMetricsId + featureFlagName)
+ * @returns A hex string with '0x' prefix suitable for generateDeterministicRandomNumber
+ */
+export function createDeterministicSeed(seed: string): string {
+  const hashBuffer = sha256(seed);
+  const hash = bytesToHex(hashBuffer);
+  return `0x${hash}`;
+}
+
 /**
  * Generates a deterministic random number between 0 and 1 based on a metaMetricsId.
  * This is useful for A/B testing and feature flag rollouts where we want

yarn.lock

@@ -4632,6 +4632,7 @@ __metadata:
     "@metamask/controller-utils": "npm:^11.16.0"
     "@metamask/messenger": "npm:^0.3.0"
     "@metamask/utils": "npm:^11.8.1"
+    "@noble/hashes": "npm:^1.8.0"
     "@ts-bridge/cli": "npm:^0.6.4"
     "@types/jest": "npm:^27.4.1"
     deepmerge: "npm:^4.2.2"