Merge branch 'feat/kdf-performance-2-dumbed-down' of github.com:MetaMask/core into feat/kdf-performance-2-dumbed-down

Author: mathieuartu

eslint-warning-thresholds.json

@@ -133,12 +133,6 @@
   "packages/base-controller/src/BaseControllerV2.ts": {
     "jsdoc/check-tag-names": 2
   },
-  "packages/base-controller/src/Messenger.test.ts": {
-    "import-x/namespace": 33
-  },
-  "packages/base-controller/src/RestrictedMessenger.test.ts": {
-    "import-x/namespace": 31
-  },
   "packages/build-utils/src/transforms/remove-fenced-code.test.ts": {
     "import-x/order": 1
   },

package.json

@@ -21,11 +21,12 @@
     "changelog:update": "yarn workspaces foreach --all --no-private --parallel --interlaced --verbose run changelog:update",
     "changelog:validate": "yarn workspaces foreach --all --no-private --parallel --interlaced --verbose run changelog:validate",
     "create-package": "ts-node scripts/create-package",
-    "lint": "yarn lint:eslint && echo && yarn lint:misc --check && yarn constraints && yarn lint:dependencies && yarn lint:teams",
+    "generate-method-action-types": "ts-node scripts/generate-method-action-types.ts",
+    "lint": "yarn lint:eslint && echo && yarn lint:misc --check && yarn constraints && yarn lint:dependencies && yarn lint:teams && yarn generate-method-action-types --check",
     "lint:dependencies": "depcheck && yarn dedupe --check",
     "lint:dependencies:fix": "depcheck && yarn dedupe",
     "lint:eslint": "yarn build:only-clean && yarn ts-node ./scripts/run-eslint.ts --cache",
-    "lint:fix": "yarn lint:eslint --fix && echo && yarn lint:misc --write && yarn constraints --fix && yarn lint:dependencies:fix",
+    "lint:fix": "yarn lint:eslint --fix && echo && yarn lint:misc --write && yarn constraints --fix && yarn lint:dependencies:fix && yarn generate-method-action-types --fix",
     "lint:misc": "prettier --no-error-on-unmatched-pattern '**/*.json' '**/*.md' '**/*.yml' '!.yarnrc.yml' '!merged-packages/**' --ignore-path .gitignore",
     "lint:teams": "ts-node scripts/lint-teams-json.ts",
     "prepack": "./scripts/prepack.sh",

packages/accounts-controller/CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Add `groupIndex` to EVM HD account options ([#6122](https://github.com/MetaMask/core/pull/6122))
+
 ### Changed
 
 - **BREAKING:** Bump peer dependency `@metamask/snaps-controllers` from `^12.0.0` to `^14.0.0` ([#6035](https://github.com/MetaMask/core/pull/6035))

packages/accounts-controller/src/AccountsController.ts

@@ -706,6 +706,8 @@ export class AccountsController extends BaseController<
             // getting the keyring instance here feels a bit overkill.
             // This will be naturally fixed once every keyring start using `KeyringAccount` and implement the keyring API.
             derivationPath: getDerivationPathForIndex(accountIndex),
+            // Required now for multichain accounts.
+            groupIndex: accountIndex,
           };
         }
 

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

@@ -111,11 +111,12 @@ export const createMockInternalAccountOptions = (
   keyringIndex: number,
   keyringType: KeyringTypes,
   groupIndex: number,
-): Record<string, string> => {
+): Record<string, string | number> => {
   if (keyringType === KeyringTypes.hd) {
     return {
       entropySource: `mock-keyring-id-${keyringIndex}`,
       derivationPath: `m/44'/60'/0'/0/${groupIndex}`,
+      groupIndex,
     };
   }
 

packages/base-controller/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Add `registerMethodActionHandlers` method to `Messenger`, and `RestrictedMessenger` for simplified bulk action handler registration ([#5927](https://github.com/MetaMask/core/pull/5927))
+  - Allows registering action handlers that map to methods on a messenger client at once by passing an array of method names
+  - Automatically binds action handlers to the given messenger client
+
 ### Changed
 
 - Bump `@metamask/utils` from `^11.2.0` to `^11.4.2` ([#6054](https://github.com/MetaMask/core/pull/6054))

packages/base-controller/src/Messenger.test.ts

@@ -1,5 +1,5 @@
 import type { Patch } from 'immer';
-import * as sinon from 'sinon';
+import sinon from 'sinon';
 
 import { Messenger } from './Messenger';
 
@@ -556,4 +556,172 @@ describe('Messenger', () => {
 
     expect(handler.callCount).toBe(0);
   });
+
+  describe('registerMethodActionHandlers', () => {
+    it('should register action handlers for specified methods on the given messenger client', () => {
+      type TestActions =
+        | { type: 'TestService:getType'; handler: () => string }
+        | {
+            type: 'TestService:getCount';
+            handler: () => number;
+          };
+
+      const messenger = new Messenger<TestActions, never>();
+
+      class TestService {
+        name = 'TestService';
+
+        getType() {
+          return 'api';
+        }
+
+        getCount() {
+          return 42;
+        }
+      }
+
+      const service = new TestService();
+      const methodNames = ['getType', 'getCount'] as const;
+
+      messenger.registerMethodActionHandlers(service, methodNames);
+
+      const state = messenger.call('TestService:getType');
+      expect(state).toBe('api');
+
+      const count = messenger.call('TestService:getCount');
+      expect(count).toBe(42);
+    });
+
+    it('should bind action handlers to the given messenger client', () => {
+      type TestAction = {
+        type: 'TestService:getPrivateValue';
+        handler: () => string;
+      };
+      const messenger = new Messenger<TestAction, never>();
+
+      class TestService {
+        name = 'TestService';
+
+        privateValue = 'secret';
+
+        getPrivateValue() {
+          return this.privateValue;
+        }
+      }
+
+      const service = new TestService();
+      messenger.registerMethodActionHandlers(service, ['getPrivateValue']);
+
+      const result = messenger.call('TestService:getPrivateValue');
+      expect(result).toBe('secret');
+    });
+
+    it('should handle async methods', async () => {
+      type TestAction = {
+        type: 'TestService:fetchData';
+        handler: (id: string) => Promise<string>;
+      };
+      const messenger = new Messenger<TestAction, never>();
+
+      class TestService {
+        name = 'TestService';
+
+        async fetchData(id: string) {
+          return `data-${id}`;
+        }
+      }
+
+      const service = new TestService();
+      messenger.registerMethodActionHandlers(service, ['fetchData']);
+
+      const result = await messenger.call('TestService:fetchData', '123');
+      expect(result).toBe('data-123');
+    });
+
+    it('should not throw when given an empty methodNames array', () => {
+      type TestAction = { type: 'TestController:test'; handler: () => void };
+      const messenger = new Messenger<TestAction, never>();
+
+      class TestController {
+        name = 'TestController';
+      }
+
+      const controller = new TestController();
+      const methodNames: readonly string[] = [];
+
+      expect(() => {
+        messenger.registerMethodActionHandlers(
+          controller,
+          methodNames as never[],
+        );
+      }).not.toThrow();
+    });
+
+    it('should skip non-function properties', () => {
+      type TestAction = {
+        type: 'TestController:getValue';
+        handler: () => string;
+      };
+      const messenger = new Messenger<TestAction, never>();
+
+      class TestController {
+        name = 'TestController';
+
+        readonly nonFunction = 'not a function';
+
+        getValue() {
+          return 'test';
+        }
+      }
+
+      const controller = new TestController();
+      messenger.registerMethodActionHandlers(controller, ['getValue']);
+
+      // getValue should be registered
+      expect(messenger.call('TestController:getValue')).toBe('test');
+
+      // nonFunction should not be registered
+      expect(() => {
+        // @ts-expect-error - This is a test
+        messenger.call('TestController:nonFunction');
+      }).toThrow(
+        'A handler for TestController:nonFunction has not been registered',
+      );
+    });
+
+    it('should work with class inheritance', () => {
+      type TestActions =
+        | { type: 'ChildController:baseMethod'; handler: () => string }
+        | { type: 'ChildController:childMethod'; handler: () => string };
+
+      const messenger = new Messenger<TestActions, never>();
+
+      class BaseController {
+        name = 'BaseController';
+
+        baseMethod() {
+          return 'base method';
+        }
+      }
+
+      class ChildController extends BaseController {
+        name = 'ChildController';
+
+        childMethod() {
+          return 'child method';
+        }
+      }
+
+      const controller = new ChildController();
+      messenger.registerMethodActionHandlers(controller, [
+        'baseMethod',
+        'childMethod',
+      ]);
+
+      expect(messenger.call('ChildController:baseMethod')).toBe('base method');
+      expect(messenger.call('ChildController:childMethod')).toBe(
+        'child method',
+      );
+    });
+  });
 });

packages/base-controller/src/Messenger.ts

@@ -154,7 +154,7 @@ export class Messenger<
    *
    * This will make the registered function available to call via the `call` method.
    *
-   * @param actionType - The action type. This is a unqiue identifier for this action.
+   * @param actionType - The action type. This is a unique identifier for this action.
    * @param handler - The action handler. This function gets called when the `call` method is
    * invoked with the given action type.
    * @throws Will throw when a handler has been registered for this action type already.
@@ -172,12 +172,32 @@ export class Messenger<
     this.#actions.set(actionType, handler);
   }
 
+  /**
+   * Registers action handlers for a list of methods on a messenger client
+   *
+   * @param messengerClient - The object that is expected to make use of the messenger.
+   * @param methodNames - The names of the methods on the messenger client to register as action
+   * handlers
+   */
+  registerMethodActionHandlers<
+    MessengerClient extends { name: string },
+    MethodNames extends keyof MessengerClient & string,
+  >(messengerClient: MessengerClient, methodNames: readonly MethodNames[]) {
+    for (const methodName of methodNames) {
+      const method = messengerClient[methodName];
+      if (typeof method === 'function') {
+        const actionType = `${messengerClient.name}:${methodName}` as const;
+        this.registerActionHandler(actionType, method.bind(messengerClient));
+      }
+    }
+  }
+
   /**
    * Unregister an action handler.
    *
    * This will prevent this action from being called.
    *
-   * @param actionType - The action type. This is a unqiue identifier for this action.
+   * @param actionType - The action type. This is a unique identifier for this action.
    * @template ActionType - A type union of Action type strings.
    */
   unregisterActionHandler<ActionType extends Action['type']>(
@@ -201,7 +221,7 @@ export class Messenger<
    * This function will call the action handler corresponding to the given action type, passing
    * along any parameters given.
    *
-   * @param actionType - The action type. This is a unqiue identifier for this action.
+   * @param actionType - The action type. This is a unique identifier for this action.
    * @param params - The action parameters. These must match the type of the parameters of the
    * registered action handler.
    * @throws Will throw when no handler has been registered for the given type.