feat: Editing flow

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

@@ -3,7 +3,7 @@ import {
   CaveatTypes,
   RestrictedMethods,
 } from '../../../../shared/constants/permissions';
-import { CaveatFactories } from './specifications';
+import { CaveatFactories, PermissionNames } from './specifications';
 
 export function getPermissionBackgroundApiMethods(permissionController) {
   const addMoreAccounts = (origin, accountOrAccounts) => {
@@ -26,7 +26,6 @@ export function getPermissionBackgroundApiMethods(permissionController) {
     // 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,
@@ -57,6 +56,49 @@ export function getPermissionBackgroundApiMethods(permissionController) {
       }
     },
 
+    removePermittedChain: (origin, chain) => {
+      const { value: existingChains } = permissionController.getCaveat(
+        origin,
+        RestrictedMethods.permittedChains,
+        CaveatTypes.restrictNetworkSwitching,
+      );
+
+      const remainingChains = existingChains.filter(
+        (existingChain) => existingChain !== chain,
+      );
+
+      if (remainingChains.length === existingChains.length) {
+        return;
+      }
+
+      if (remainingChains.length === 0) {
+        permissionController.revokePermission(
+          origin,
+          RestrictedMethods.permittedChains,
+        );
+      } else {
+        permissionController.updateCaveat(
+          origin,
+          RestrictedMethods.permittedChains,
+          CaveatTypes.restrictNetworkSwitching,
+          remainingChains,
+        );
+      }
+    },
+
+    requestAccountsAndChainPermissionsWithId: async (origin) => {
+      const id = nanoid();
+      permissionController.requestPermissions(
+        { origin },
+        {
+          [PermissionNames.eth_accounts]: {},
+          [PermissionNames.permittedChains]: {},
+        },
+        { id },
+      );
+      return id;
+    },
+
     requestAccountsPermissionWithId: async (origin) => {
       const id = nanoid();
       permissionController.requestPermissions(

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

@@ -3,7 +3,7 @@ import {
   RestrictedMethods,
 } from '../../../../shared/constants/permissions';
 import { getPermissionBackgroundApiMethods } from './background-api';
-import { CaveatFactories } from './specifications';
+import { CaveatFactories, PermissionNames } from './specifications';
 
 describe('permission background API methods', () => {
   const getApprovedPermissions = (accounts) => ({
@@ -194,4 +194,126 @@ describe('permission background API methods', () => {
       );
     });
   });
+
+  describe('requestAccountsAndChainPermissionsWithId', () => {
+    it('request eth_accounts and permittedChains permissions and returns the request id', async () => {
+      const permissionController = {
+        requestPermissions: jest
+          .fn()
+          .mockImplementationOnce(async (_, __, { id }) => {
+            return [null, { id }];
+          }),
+      };
+
+      const id = await getPermissionBackgroundApiMethods(
+        permissionController,
+      ).requestAccountsAndChainPermissionsWithId('foo.com');
+
+      expect(permissionController.requestPermissions).toHaveBeenCalledTimes(1);
+      expect(permissionController.requestPermissions).toHaveBeenCalledWith(
+        { origin: 'foo.com' },
+        {
+          [PermissionNames.eth_accounts]: {},
+          [PermissionNames.permittedChains]: {},
+        },
+        { id: expect.any(String) },
+      );
+
+      expect(id.length > 0).toBe(true);
+      expect(id).toStrictEqual(
+        permissionController.requestPermissions.mock.calls[0][2].id,
+      );
+    });
+  });
+
+  describe('removePermittedChain', () => {
+    it('removes a permitted chain', () => {
+      const permissionController = {
+        getCaveat: jest.fn().mockImplementationOnce(() => {
+          return {
+            type: CaveatTypes.restrictNetworkSwitching,
+            value: ['0x1', '0x2'],
+          };
+        }),
+        revokePermission: jest.fn(),
+        updateCaveat: jest.fn(),
+      };
+
+      getPermissionBackgroundApiMethods(
+        permissionController,
+      ).removePermittedChain('foo.com', '0x2');
+
+      expect(permissionController.getCaveat).toHaveBeenCalledTimes(1);
+      expect(permissionController.getCaveat).toHaveBeenCalledWith(
+        'foo.com',
+        RestrictedMethods.permittedChains,
+        CaveatTypes.restrictNetworkSwitching,
+      );
+
+      expect(permissionController.revokePermission).not.toHaveBeenCalled();
+
+      expect(permissionController.updateCaveat).toHaveBeenCalledTimes(1);
+      expect(permissionController.updateCaveat).toHaveBeenCalledWith(
+        'foo.com',
+        RestrictedMethods.permittedChains,
+        CaveatTypes.restrictNetworkSwitching,
+        ['0x1'],
+      );
+    });
+
+    it('revokes the permittedChains permission if the removed chain is the only permitted chain', () => {
+      const permissionController = {
+        getCaveat: jest.fn().mockImplementationOnce(() => {
+          return {
+            type: CaveatTypes.restrictNetworkSwitching,
+            value: ['0x1'],
+          };
+        }),
+        revokePermission: jest.fn(),
+        updateCaveat: jest.fn(),
+      };
+
+      getPermissionBackgroundApiMethods(
+        permissionController,
+      ).removePermittedChain('foo.com', '0x1');
+
+      expect(permissionController.getCaveat).toHaveBeenCalledTimes(1);
+      expect(permissionController.getCaveat).toHaveBeenCalledWith(
+        'foo.com',
+        RestrictedMethods.permittedChains,
+        CaveatTypes.restrictNetworkSwitching,
+      );
+
+      expect(permissionController.revokePermission).toHaveBeenCalledTimes(1);
+      expect(permissionController.revokePermission).toHaveBeenCalledWith(
+        'foo.com',
+        RestrictedMethods.permittedChains,
+      );
+
+      expect(permissionController.updateCaveat).not.toHaveBeenCalled();
+    });
+
+    it('does not call permissionController.updateCaveat if the specified chain is not permitted', () => {
+      const permissionController = {
+        getCaveat: jest.fn().mockImplementationOnce(() => {
+          return { type: CaveatTypes.restrictNetworkSwitching, value: ['0x1'] };
+        }),
+        revokePermission: jest.fn(),
+        updateCaveat: jest.fn(),
+      };
+
+      getPermissionBackgroundApiMethods(
+        permissionController,
+      ).removePermittedChain('foo.com', '0x2');
+      expect(permissionController.getCaveat).toHaveBeenCalledTimes(1);
+      expect(permissionController.getCaveat).toHaveBeenCalledWith(
+        'foo.com',
+        RestrictedMethods.permittedChains,
+        CaveatTypes.restrictNetworkSwitching,
+      );
+
+      expect(permissionController.revokePermission).not.toHaveBeenCalled();
+      expect(permissionController.updateCaveat).not.toHaveBeenCalled();
+    });
+  });
 });