feat: CAIP Multichain (New)

.circleci/config.yml

@@ -225,6 +225,10 @@ workflows:
           requires:
             - prep-build-test
             - get-changed-files-with-git-diff
+      - test-api-specs-multichain:
+          requires:
+            - prep-build-test-flask
+            - get-changed-files-with-git-diff
       - test-e2e-chrome-multiple-providers:
           requires:
             - prep-build-test
@@ -1096,6 +1100,37 @@ jobs:
       - store_test_results:
           path: test/test-results/e2e
 
+  test-api-specs-multichain:
+    executor: node-browsers-medium-plus
+    steps:
+      - run: *shallow-git-clone-and-enable-vnc
+      - run: sudo corepack enable
+      - attach_workspace:
+          at: .
+      - run:
+          name: Move test build to dist
+          command: mv ./dist-test-flask ./dist
+      - run:
+          name: Move test zips to builds
+          command: mv ./builds-test-flask ./builds
+      - gh/install
+      - run:
+          name: test:api-specs-multichain
+          command: .circleci/scripts/test-run-e2e.sh yarn test:api-specs-multichain
+          no_output_timeout: 5m
+      - run:
+          name: Comment on PR
+          command: |
+            if [  -f html-report-multichain/index.html ]; then
+              gh pr comment "${CIRCLE_PR_NUMBER}" --body ":x: Multichain API Spec Test Failed. View the report [here](https://output.circle-artifacts.com/output/job/${CIRCLE_WORKFLOW_JOB_ID}/artifacts/${CIRCLE_NODE_INDEX}/html-report-multichain/index.html)."
+            else
+              echo "Multichain API Spec Report not found!"
+            fi
+          when: on_fail
+      - store_artifacts:
+          path: html-report-multichain
+          destination: html-report-multichain
+
   test-api-specs:
     executor: node-browsers-medium-plus
     steps:

.gitignore

@@ -78,10 +78,13 @@ lavamoat/**/policy-debug.json
 # Attributions
 licenseInfos.json
 
+# Branding
+/app/images/branding
+
 # API Spec tests
 html-report/
+html-report-multichain/
 
-/app/images/branding
 /changed-files
 
 # UI Integration tests

app/build-types/flask/manifest/_base.json

@@ -11,6 +11,10 @@
     },
     "default_title": "MetaMask Flask"
   },
+  "externally_connectable": {
+    "matches": ["http://*/*", "https://*/*"],
+    "ids": ["*"]
+  },
   "icons": {
     "16": "images/icon-16.png",
     "19": "images/icon-19.png",

app/scripts/background.js

@@ -365,7 +365,9 @@ function overrideContentSecurityPolicyHeader() {
 // These are set after initialization
 let connectRemote;
 let connectExternalExtension;
+///: BEGIN:ONLY_INCLUDE_IF(build-flask)
 let connectExternalCaip;
+///: END:ONLY_INCLUDE_IF
 
 browser.runtime.onConnect.addListener(async (...args) => {
   // Queue up connection attempts here, waiting until after initialization
@@ -378,13 +380,18 @@ browser.runtime.onConnectExternal.addListener(async (...args) => {
   // Queue up connection attempts here, waiting until after initialization
   await isInitialized;
   // This is set in `setupController`, which is called as part of initialization
-  const port = args[0];
 
-  if (port.sender.tab?.id && process.env.BARAD_DUR) {
+  ///: BEGIN:ONLY_INCLUDE_IF(build-main,build-beta,build-mmi)
+  connectExternalExtension(...args);
+  ///: END:ONLY_INCLUDE_IF
+  ///: BEGIN:ONLY_INCLUDE_IF(build-flask)
+  const port = args[0];
+  if (port.sender.tab?.id) {
     connectExternalCaip(...args);
   } else {
     connectExternalExtension(...args);
   }
+  ///: END:ONLY_INCLUDE_IF
 });
 
 function saveTimestamp() {
@@ -1017,6 +1024,7 @@ export function setupController(
     });
   };
 
+  ///: BEGIN:ONLY_INCLUDE_IF(build-flask)
   connectExternalCaip = async (remotePort) => {
     if (metamaskBlockedPorts.includes(remotePort.name)) {
       return;
@@ -1035,6 +1043,7 @@ export function setupController(
       sender: remotePort.sender,
     });
   };
+  ///: END:ONLY_INCLUDE_IF
 
   if (overrides?.registerConnectListeners) {
     overrides.registerConnectListeners(connectRemote, connectExternalExtension);

app/scripts/controllers/permissions/enums.ts

@@ -2,4 +2,5 @@ export enum NOTIFICATION_NAMES {
   accountsChanged = 'metamask_accountsChanged',
   unlockStateChanged = 'metamask_unlockStateChanged',
   chainChanged = 'metamask_chainChanged',
+  sessionChanged = 'wallet_sessionChanged',
 }

app/scripts/controllers/permissions/selectors.js

@@ -44,6 +44,33 @@ export const getPermittedAccountsByOrigin = createSelector(
   },
 );
 
+/**
+ * Get the authorized CAIP-25 scopes for each subject, keyed by origin.
+ * The values of the returned map are immutable values from the
+ * PermissionController state.
+ *
+ * @returns {Map<string, Caip25Authorization>} The current origin:authorization map.
+ */
+export const getAuthorizedScopesByOrigin = createSelector(
+  getSubjects,
+  (subjects) => {
+    return Object.values(subjects).reduce(
+      (originToAuthorizationsMap, subject) => {
+        const caveats =
+          subject.permissions?.[Caip25EndowmentPermissionName]?.caveats || [];
+
+        const caveat = caveats.find(({ type }) => type === Caip25CaveatType);
+
+        if (caveat) {
+          originToAuthorizationsMap.set(subject.origin, caveat.value);
+        }
+        return originToAuthorizationsMap;
+      },
+      new Map(),
+    );
+  },
+);
+
 /**
  * Get the permitted chains for each subject, keyed by origin.
  * The values of the returned map are immutable values from the
@@ -112,3 +139,89 @@ export const diffMap = (currentMap, previousMap) => {
   }
   return changedMap;
 };
+
+/**
+ * Given the current and previous exposed CAIP-25 authorization for each PermissionController
+ * subject, returns a new map containing all authorizations that have changed.
+ * The values of each map must be immutable values directly from the
+ * PermissionController state, or an empty object instantiated in this
+ * function.
+ *
+ * @param {Map<string, Caip25Authorization>} newAuthorizationsMap - The new origin:authorization map.
+ * @param {Map<string, Caip25Authorization>} [previousAuthorizationsMap] - The previous origin:authorization map.
+ * @returns {Map<string, Caip25Authorization>} The origin:authorization map of changed authorizations.
+ */
+export const getChangedAuthorizations = (
+  newAuthorizationsMap,
+  previousAuthorizationsMap,
+) => {
+  if (previousAuthorizationsMap === undefined) {
+    return newAuthorizationsMap;
+  }
+
+  const changedAuthorizations = new Map();
+  if (newAuthorizationsMap === previousAuthorizationsMap) {
+    return changedAuthorizations;
+  }
+
+  const newOrigins = new Set([...newAuthorizationsMap.keys()]);
+
+  for (const origin of previousAuthorizationsMap.keys()) {
+    const newAuthorizations = newAuthorizationsMap.get(origin) ?? {
+      requiredScopes: {},
+      optionalScopes: {},
+    };
+
+    // The values of these maps are references to immutable values, which is why
+    // a strict equality check is enough for diffing. The values are either from
+    // PermissionController state, or an empty object initialized in the previous
+    // call to this function. `newAuthorizationsMap` will never contain any empty
+    // objects.
+    if (previousAuthorizationsMap.get(origin) !== newAuthorizations) {
+      changedAuthorizations.set(origin, newAuthorizations);
+    }
+
+    newOrigins.delete(origin);
+  }
+
+  // By now, newOrigins is either empty or contains some number of previously
+  // unencountered origins, and all of their authorizations have "changed".
+  for (const origin of newOrigins.keys()) {
+    changedAuthorizations.set(origin, newAuthorizationsMap.get(origin));
+  }
+  return changedAuthorizations;
+};
+
+/**
+ *
+ * @param {Map<string, Caip25Authorization>} newAuthorizationsMap - The new origin:authorization map.
+ * @param {Map<string, Caip25Authorization>} [previousAuthorizationsMap] - The previous origin:authorization map.
+ * @returns {Map<string, Caip25Authorization>} The origin:authorization map of changed authorizations.
+ */
+export const getRemovedAuthorizations = (
+  newAuthorizationsMap,
+  previousAuthorizationsMap,
+) => {
+  const removedAuthorizations = new Map();
+
+  // If there are no previous authorizations, there are no removed authorizations.
+  // OR If the new authorizations map is the same as the previous authorizations map,
+  // there are no removed authorizations
+  if (
+    previousAuthorizationsMap === undefined ||
+    newAuthorizationsMap === previousAuthorizationsMap
+  ) {
+    return removedAuthorizations;
+  }
+
+  const previousOrigins = new Set([...previousAuthorizationsMap.keys()]);
+  for (const origin of newAuthorizationsMap.keys()) {
+    previousOrigins.delete(origin);
+  }
+
+  for (const origin of previousOrigins.keys()) {
+    removedAuthorizations.set(origin, previousAuthorizationsMap.get(origin));
+  }
+
+  return removedAuthorizations;
+};

app/scripts/controllers/permissions/selectors.test.js

@@ -7,6 +7,7 @@ import {
   diffMap,
   getPermittedAccountsByOrigin,
   getPermittedChainsByOrigin,
+  getRemovedAuthorizations,
 } from './selectors';
 
 describe('PermissionController selectors', () => {
@@ -167,6 +168,36 @@ describe('PermissionController selectors', () => {
     });
   });
 
+  describe('getRemovedAuthorizations', () => {
+    it('returns an empty map if the new and previous values are the same', () => {
+      const newAuthorizations = new Map();
+      expect(
+        getRemovedAuthorizations(newAuthorizations, newAuthorizations),
+      ).toStrictEqual(new Map());
+    });
+
+    it('returns a new map of the removed authorizations if the new and previous values differ', () => {
+      const mockAuthorization = {
+        requiredScopes: {
+          'eip155:1': {
+            accounts: [],
+          },
+        },
+        optionalScopes: {},
+      };
+      const previousAuthorizations = new Map([
+        ['foo.bar', mockAuthorization],
+        ['bar.baz', mockAuthorization],
+      ]);
+
+      const newAuthorizations = new Map([['foo.bar', mockAuthorization]]);
+
+      expect(
+        getRemovedAuthorizations(newAuthorizations, previousAuthorizations),
+      ).toStrictEqual(new Map([['bar.baz', mockAuthorization]]));
+    });
+  });
+
   describe('getPermittedChainsByOrigin', () => {
     it('memoizes and gets permitted chains by origin', () => {
       const state1 = {

app/scripts/lib/rpc-method-middleware/createMethodMiddleware.js

@@ -28,14 +28,18 @@ export const createEthAccountsMethodMiddleware = makeMethodMiddlewareMaker([
   ethAccountsHandler,
 ]);
 
+// The primary home of RPC method implementations for the MultiChain API.
+export const createMultichainMethodMiddleware =
+  makeMethodMiddlewareMaker(localHandlers);
+
 /**
  * Creates a method middleware factory function given a set of method handlers.
  *
  * @param {Record<string, import('@metamask/permission-controller').PermittedHandlerExport>} handlers - The RPC method
  * handler implementations.
  * @returns The method middleware factory function.
  */
-function makeMethodMiddlewareMaker(handlers) {
+export function makeMethodMiddlewareMaker(handlers) {
   const handlerMap = handlers.reduce((map, handler) => {
     for (const methodName of handler.methodNames) {
       map[methodName] = handler;

app/scripts/lib/rpc-method-middleware/createMethodMiddleware.test.js

@@ -6,6 +6,7 @@ import {
 import {
   createEip1193MethodMiddleware,
   createEthAccountsMethodMiddleware,
+  createMultichainMethodMiddleware,
 } from '.';
 
 const getHandler = () => ({
@@ -60,6 +61,7 @@ jest.mock('./handlers', () => ({
 describe.each([
   ['createEip1193MethodMiddleware', createEip1193MethodMiddleware],
   ['createEthAccountsMethodMiddleware', createEthAccountsMethodMiddleware],
+  ['createMultichainMethodMiddleware', createMultichainMethodMiddleware],
 ])('%s', (_name, createMiddleware) => {
   const method1 = 'method1';
 

app/scripts/lib/rpc-method-middleware/createUnsupportedMethodMiddleware.test.ts

@@ -10,8 +10,8 @@ describe('createUnsupportedMethodMiddleware', () => {
   });
   const getMockResponse = () => ({ jsonrpc: jsonrpc2, id: 'foo' });
 
-  it('forwards requests whose methods are not on the list of unsupported methods', () => {
-    const middleware = createUnsupportedMethodMiddleware();
+  it('forwards requests whose methods are not in the list of unsupported methods', () => {
+    const middleware = createUnsupportedMethodMiddleware([]);
     const nextMock = jest.fn();
     const endMock = jest.fn();
 
@@ -22,10 +22,12 @@ describe('createUnsupportedMethodMiddleware', () => {
   });
 
   // @ts-expect-error This function is missing from the Mocha type definitions
-  it.each([...UNSUPPORTED_RPC_METHODS.keys()])(
-    'ends requests for methods that are on the list of unsupported methods: %s',
+  it.each(UNSUPPORTED_RPC_METHODS)(
+    'ends requests for methods that are in the list of unsupported methods: %s',
     (method: string) => {
-      const middleware = createUnsupportedMethodMiddleware();
+      const middleware = createUnsupportedMethodMiddleware(
+        UNSUPPORTED_RPC_METHODS,
+      );
       const nextMock = jest.fn();
       const endMock = jest.fn();
 

app/scripts/lib/rpc-method-middleware/createUnsupportedMethodMiddleware.ts

@@ -1,18 +1,18 @@
 import type { JsonRpcMiddleware } from '@metamask/json-rpc-engine';
 import type { JsonRpcParams } from '@metamask/utils';
 import { rpcErrors } from '@metamask/rpc-errors';
-import { UNSUPPORTED_RPC_METHODS } from '../../../../shared/constants/network';
 
 /**
  * Creates a middleware that rejects explicitly unsupported RPC methods with the
  * appropriate error.
+ *
+ * @param methods
  */
-export function createUnsupportedMethodMiddleware(): JsonRpcMiddleware<
-  JsonRpcParams,
-  null
-> {
+export function createUnsupportedMethodMiddleware(
+  methods: string[],
+): JsonRpcMiddleware<JsonRpcParams, null> {
   return async function unsupportedMethodMiddleware(req, _res, next, end) {
-    if ((UNSUPPORTED_RPC_METHODS as Set<string>).has(req.method)) {
+    if (methods.includes(req.method)) {
       return end(rpcErrors.methodNotSupported());
     }
     return next();