feat: Add Multichain API to Flask

.circleci/config.yml

@@ -159,6 +159,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
@@ -703,6 +707,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:

.depcheckrc.yml

@@ -23,6 +23,7 @@ ignores:
   - '@metamask/forwarder'
   - '@metamask/phishing-warning' # statically hosted as part of some e2e tests
   - '@metamask/test-dapp'
+  - '@metamask/test-dapp-multichain'
   - '@metamask/design-tokens' # Only imported in index.css
   - '@tsconfig/node22' # required dynamically by TS, used in tsconfig.json
   - '@sentry/cli' # invoked as `sentry-cli`

.gitignore

@@ -80,10 +80,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

@@ -406,9 +406,10 @@ 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) {
+  const port = args[0];
+  const isDappConnecting = port.sender.tab?.id;
+  if (isDappConnecting && process.env.MULTICHAIN_API) {
     connectExternalCaip(...args);
   } else {
     connectExternalExtension(...args);
@@ -1036,6 +1037,10 @@ export function setupController(
   };
 
   connectExternalCaip = async (remotePort) => {
+    if (!process.env.MULTICHAIN_API) {
+      return;
+    }
+
     if (metamaskBlockedPorts.includes(remotePort.name)) {
       return;
     }

app/scripts/controllers/permissions/differs.test.ts

@@ -0,0 +1,263 @@
+import {
+  diffMap,
+  getChangedAuthorizations,
+  getRemovedAuthorizations,
+} from './differs';
+
+describe('PermissionController selectors', () => {
+  describe('diffMap', () => {
+    it('returns the new value if the previous value is undefined', () => {
+      const newAccounts = new Map([['foo.bar', ['0x1']]]);
+      expect(diffMap(newAccounts, undefined)).toBe(newAccounts);
+    });
+
+    it('returns an empty map if the new and previous values are the same', () => {
+      const newAccounts = new Map([['foo.bar', ['0x1']]]);
+      expect(diffMap(newAccounts, newAccounts)).toStrictEqual(new Map());
+    });
+
+    it('returns a new map of the changed key/value pairs if the new and previous maps differ', () => {
+      // We set this on the new and previous value under the key 'foo.bar' to
+      // check that identical values are excluded.
+      const identicalValue = ['0x1'];
+
+      const previousAccounts = new Map([
+        ['bar.baz', ['0x1']], // included: different accounts
+        ['fizz.buzz', ['0x1']], // included: removed in new value
+      ]);
+      previousAccounts.set('foo.bar', identicalValue);
+
+      const newAccounts = new Map([
+        ['bar.baz', ['0x1', '0x2']], // included: different accounts
+        ['baz.fizz', ['0x3']], // included: brand new
+      ]);
+      newAccounts.set('foo.bar', identicalValue);
+
+      expect(diffMap(newAccounts, previousAccounts)).toStrictEqual(
+        new Map([
+          ['bar.baz', ['0x1', '0x2']],
+          ['fizz.buzz', []],
+          ['baz.fizz', ['0x3']],
+        ]),
+      );
+    });
+  });
+
+  describe('getChangedAuthorizations', () => {
+    it('returns an empty map if the previous value is undefined', () => {
+      expect(getChangedAuthorizations(new Map(), undefined)).toStrictEqual(
+        new Map(),
+      );
+    });
+
+    it('returns an empty map if the new and previous values are the same', () => {
+      const newAuthorizations = new Map();
+      expect(
+        getChangedAuthorizations(newAuthorizations, newAuthorizations),
+      ).toStrictEqual(new Map());
+    });
+
+    it('returns a new map of the current values of changed scopes but excluding removed scopes in authorizations', () => {
+      const previousAuthorizations = new Map([
+        [
+          'foo.bar',
+          {
+            requiredScopes: {
+              'eip155:1': {
+                accounts: ['eip155:1:0xdead' as const],
+              },
+            },
+            optionalScopes: {
+              'eip155:5': {
+                accounts: [],
+              },
+              'eip155:10': {
+                accounts: [],
+              },
+            },
+            isMultichainOrigin: true,
+          },
+        ],
+      ]);
+
+      const newAuthorizations = new Map([
+        [
+          'foo.bar',
+          {
+            requiredScopes: {
+              'eip155:1': {
+                accounts: ['eip155:1:0xbeef' as const],
+              },
+            },
+            optionalScopes: {
+              'eip155:5': {
+                accounts: ['eip155:5:0x123' as const],
+              },
+            },
+            isMultichainOrigin: true,
+          },
+        ],
+      ]);
+
+      expect(
+        getChangedAuthorizations(newAuthorizations, previousAuthorizations),
+      ).toStrictEqual(
+        new Map([
+          [
+            'foo.bar',
+            {
+              requiredScopes: {
+                'eip155:1': {
+                  accounts: ['eip155:1:0xbeef'],
+                },
+              },
+              optionalScopes: {
+                'eip155:5': {
+                  accounts: ['eip155:5:0x123'],
+                },
+              },
+            },
+          ],
+        ]),
+      );
+    });
+
+    it('returns a new map with empty requiredScopes and optionalScopes for revoked authorizations', () => {
+      const previousAuthorizations = new Map([
+        [
+          'foo.bar',
+          {
+            requiredScopes: {
+              'eip155:1': {
+                accounts: ['eip155:1:0xdead' as const],
+              },
+            },
+            optionalScopes: {
+              'eip155:5': {
+                accounts: [],
+              },
+              'eip155:10': {
+                accounts: [],
+              },
+            },
+            isMultichainOrigin: true,
+          },
+        ],
+      ]);
+
+      const newAuthorizations = new Map();
+
+      expect(
+        getChangedAuthorizations(newAuthorizations, previousAuthorizations),
+      ).toStrictEqual(
+        new Map([
+          [
+            'foo.bar',
+            {
+              requiredScopes: {},
+              optionalScopes: {},
+            },
+          ],
+        ]),
+      );
+    });
+  });
+
+  describe('getRemovedAuthorizations', () => {
+    it('returns an empty map if the previous value is undefined', () => {
+      expect(getRemovedAuthorizations(new Map(), undefined)).toStrictEqual(
+        new Map(),
+      );
+    });
+
+    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 scopes in authorizations', () => {
+      const previousAuthorizations = new Map([
+        [
+          'foo.bar',
+          {
+            requiredScopes: {
+              'eip155:1': {
+                accounts: [],
+              },
+            },
+            optionalScopes: {
+              'eip155:5': {
+                accounts: [],
+              },
+              'eip155:10': {
+                accounts: [],
+              },
+            },
+            isMultichainOrigin: true,
+          },
+        ],
+      ]);
+
+      const newAuthorizations = new Map([
+        [
+          'foo.bar',
+          {
+            requiredScopes: {
+              'eip155:1': {
+                accounts: [],
+              },
+            },
+            optionalScopes: {
+              'eip155:10': {
+                accounts: [],
+              },
+            },
+            isMultichainOrigin: true,
+          },
+        ],
+      ]);
+
+      expect(
+        getRemovedAuthorizations(newAuthorizations, previousAuthorizations),
+      ).toStrictEqual(
+        new Map([
+          [
+            'foo.bar',
+            {
+              requiredScopes: {},
+              optionalScopes: {
+                'eip155:5': {
+                  accounts: [],
+                },
+              },
+            },
+          ],
+        ]),
+      );
+    });
+
+    it('returns a new map of the revoked authorizations', () => {
+      const mockAuthorization = {
+        requiredScopes: {
+          'eip155:1': {
+            accounts: [],
+          },
+        },
+        optionalScopes: {},
+        isMultichainOrigin: true,
+      };
+      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]]));
+    });
+  });
+});