feat: CAIP Multichain

.gitignore

@@ -75,8 +75,10 @@ lavamoat/**/policy-debug.json
 # Attributions
 licenseInfos.json
 
+# Branding
+/app/images/branding
+
 # API Spec tests
 html-report/
-
-/app/images/branding
+html-report-multichain/
 

.storybook/test-data.js

@@ -1375,17 +1375,29 @@ const state = {
     subjects: {
       'https://app.uniswap.org': {
         permissions: {
-          eth_accounts: {
-            invoker: 'https://app.uniswap.org',
-            parentCapability: 'eth_accounts',
-            id: 'a7342e4b-beae-4525-a36c-c0635fd03359',
-            date: 1620710693178,
+          'endowment:caip25': {
             caveats: [
               {
-                type: 'restrictReturnedAccounts',
-                value: ['0x64a845a5b02460acf8a3d84503b0d68d028b4bb4'],
+                type: 'authorizedScopes',
+                value: {
+                  requiredScopes: {},
+                  optionalScopes: {
+                    'eip155:1': {
+                      methods: [],
+                      notifications: [],
+                      accounts: [
+                        'eip155:1:0x64a845a5b02460acf8a3d84503b0d68d028b4bb4',
+                      ],
+                    },
+                  },
+                  isMultichainOrigin: false,
+                },
               },
             ],
+            invoker: 'https://app.uniswap.org',
+            id: 'a7342e4b-beae-4525-a36c-c0635fd03359',
+            date: 1620710693178,
+            parentCapability: 'endowment:caip25',
           },
         },
       },

.yarn/patches/@json-schema-spec-json-pointer-npm-0.1.2-3d06119887.patch

@@ -0,0 +1,13 @@
+diff --git a/lib/index.js b/lib/index.js
+index f5795884311124b221d91f488ed45750eb6e9c80..e030d6f8d8e85e6d1350c565d36ad48bc49af881 100644
+--- a/lib/index.js
++++ b/lib/index.js
+@@ -25,7 +25,7 @@ class Ptr {
+         });
+         return `/${tokens.join("/")}`;
+     }
+-    eval(instance) {
++    shmeval(instance) {
+         for (const token of this.tokens) {
+             if (instance.hasOwnProperty(token)) {
+                 instance = instance[token];

.yarn/patches/@json-schema-tools-reference-resolver-npm-1.2.6-4e1497c16d.patch

@@ -0,0 +1,13 @@
+diff --git a/build/resolve-pointer.js b/build/resolve-pointer.js
+index d5a8ec7486250cd17572eb0e0449725643fc9842..044e74bb51a46e9bf3547f6d7a84763b93260613 100644
+--- a/build/resolve-pointer.js
++++ b/build/resolve-pointer.js
+@@ -27,7 +27,7 @@ exports.default = (function (ref, root) {
+     try {
+         var withoutHash = ref.replace("#", "");
+         var pointer = json_pointer_1.default.parse(withoutHash);
+-        return pointer.eval(root);
++        return pointer.shmeval(root);
+     }
+     catch (e) {
+         throw new InvalidJsonPointerRefError(ref, e.message);

app/scripts/background.js

@@ -635,13 +635,8 @@ function emitDappViewedMetricEvent(origin) {
     return;
   }
 
-  const permissions = controller.controllerMessenger.call(
-    'PermissionController:getPermissions',
-    origin,
-  );
-  const numberOfConnectedAccounts =
-    permissions?.eth_accounts?.caveats[0]?.value.length;
-  if (!numberOfConnectedAccounts) {
+  const numberOfConnectedAccounts = controller.getPermittedAccounts(origin);
+  if (numberOfConnectedAccounts.length === 0) {
     return;
   }
 

app/scripts/controllers/permissions/background-api.js

@@ -1,38 +1,90 @@
 import nanoid from 'nanoid';
+import { MethodNames } from '@metamask/permission-controller';
+import {
+  Caip25CaveatType,
+  Caip25EndowmentPermissionName,
+} from '../../lib/multichain-api/caip25permissions';
+import {
+  getEthAccounts,
+  setEthAccounts,
+} from '../../lib/multichain-api/adapters/caip-permission-adapter-eth-accounts';
+import { setPermittedEthChainIds } from '../../lib/multichain-api/adapters/caip-permission-adapter-permittedChains';
 import {
   CaveatTypes,
   RestrictedMethods,
 } from '../../../../shared/constants/permissions';
-import { CaveatFactories } from './specifications';
+import { PermissionNames } from './specifications';
 
-export function getPermissionBackgroundApiMethods(permissionController) {
+export function getPermissionBackgroundApiMethods({
+  permissionController,
+  approvalController,
+  networkController,
+}) {
+  // To add more than one account when already connected to the dapp
   const addMoreAccounts = (origin, accountOrAccounts) => {
     const accounts = Array.isArray(accountOrAccounts)
       ? accountOrAccounts
       : [accountOrAccounts];
-    const caveat = CaveatFactories.restrictReturnedAccounts(accounts);
-
-    permissionController.grantPermissionsIncremental({
-      subject: { origin },
-      approvedPermissions: {
-        [RestrictedMethods.eth_accounts]: { caveats: [caveat] },
-      },
-    });
+
+    let caip25Caveat;
+    try {
+      caip25Caveat = permissionController.getCaveat(
+        origin,
+        Caip25EndowmentPermissionName,
+        Caip25CaveatType,
+      );
+    } catch (err) {
+      // noop
+    }
+
+    if (!caip25Caveat) {
+      throw new Error('tried to add accounts when none have been permissioned'); // TODO: better error
+    }
+
+    const ethAccounts = getEthAccounts(caip25Caveat.value);
+
+    const updatedEthAccounts = Array.from(
+      new Set([...ethAccounts, ...accounts]),
+    );
+
+    const updatedCaveatValue = setEthAccounts(
+      caip25Caveat.value,
+      updatedEthAccounts,
+    );
+
+    permissionController.updateCaveat(
+      origin,
+      Caip25EndowmentPermissionName,
+      Caip25CaveatType,
+      updatedCaveatValue,
+    );
   };
 
   return {
     addPermittedAccount: (origin, account) => addMoreAccounts(origin, account),
 
-    // To add more than one account when already connected to the dapp
     addMorePermittedAccounts: (origin, accounts) =>
       addMoreAccounts(origin, accounts),
 
     removePermittedAccount: (origin, account) => {
-      const { value: existingAccounts } = permissionController.getCaveat(
-        origin,
-        RestrictedMethods.eth_accounts,
-        CaveatTypes.restrictReturnedAccounts,
-      );
+      let caip25Caveat;
+      try {
+        caip25Caveat = permissionController.getCaveat(
+          origin,
+          Caip25EndowmentPermissionName,
+          Caip25CaveatType,
+        );
+      } catch (err) {
+        // noop
+      }
+
+      if (!caip25Caveat) {
+        throw new Error(
+          'tried to remove accounts when none have been permissioned',
+        ); // TODO: better error
+      }
+
+      const existingAccounts = getEthAccounts(caip25Caveat.value);
 
       const remainingAccounts = existingAccounts.filter(
         (existingAccount) => existingAccount !== account,
@@ -45,27 +97,86 @@ export function getPermissionBackgroundApiMethods(permissionController) {
       if (remainingAccounts.length === 0) {
         permissionController.revokePermission(
           origin,
-          RestrictedMethods.eth_accounts,
+          Caip25EndowmentPermissionName,
         );
       } else {
+        const updatedCaveatValue = setEthAccounts(
+          caip25Caveat.value,
+          remainingAccounts,
+        );
         permissionController.updateCaveat(
           origin,
-          RestrictedMethods.eth_accounts,
-          CaveatTypes.restrictReturnedAccounts,
-          remainingAccounts,
+          Caip25EndowmentPermissionName,
+          Caip25CaveatType,
+          updatedCaveatValue,
         );
       }
     },
 
-    requestAccountsPermissionWithId: async (origin) => {
+    requestAccountsPermissionWithId: (origin) => {
+      const { chainId } =
+        networkController.getNetworkConfigurationByNetworkClientId(
+          networkController.state.selectedNetworkClientId,
+        );
+
       const id = nanoid();
-      permissionController.requestPermissions(
-        { origin },
-        {
-          eth_accounts: {},
-        },
-        { id },
-      );
+      // NOTE: the eth_accounts/permittedChains approvals will be combined in the future.
+      // Until they are actually combined, when testing, you must request both
+      // eth_accounts and permittedChains together.
+      approvalController
+        .addAndShowApprovalRequest({
+          id,
+          origin,
+          requestData: {
+            metadata: {
+              id,
+              origin,
+            },
+            permissions: {
+              [RestrictedMethods.eth_accounts]: {},
+              [PermissionNames.permittedChains]: {
+                caveats: [
+                  {
+                    type: CaveatTypes.restrictNetworkSwitching,
+                    value: [chainId],
+                  },
+                ],
+              },
+            },
+          },
+          type: MethodNames.requestPermissions,
+        })
+        .then((legacyApproval) => {
+          let caveatValue = {
+            requiredScopes: {},
+            optionalScopes: {},
+            isMultichainOrigin: false,
+          };
+          caveatValue = setPermittedEthChainIds(
+            caveatValue,
+            legacyApproval.approvedChainIds,
+          );
+
+          caveatValue = setEthAccounts(
+            caveatValue,
+            legacyApproval.approvedAccounts,
+          );
+
+          permissionController.grantPermissions({
+            subject: { origin },
+            approvedPermissions: {
+              [Caip25EndowmentPermissionName]: {
+                caveats: [
+                  {
+                    type: Caip25CaveatType,
+                    value: caveatValue,
+                  },
+                ],
+              },
+            },
+          });
+        });
+
       return id;
     },
   };