Rename migration 83 to 84 and rename migration 84 to 83 (#18655)

Co-authored-by: legobeat <109787230+legobeat@users.noreply.github.com>

app/scripts/migrations/083.test.js

@@ -1,103 +1,254 @@
-import { migrate } from './083';
+import { v4 } from 'uuid';
+import { migrate, version } from './083';
+
+jest.mock('uuid', () => {
+  const actual = jest.requireActual('uuid');
+
+  return {
+    ...actual,
+    v4: jest.fn(),
+  };
+});
 
 describe('migration #83', () => {
-  it('updates the version metadata', async () => {
-    const originalVersionedData = buildOriginalVersionedData({
+  beforeEach(() => {
+    v4.mockImplementationOnce(() => 'network-configuration-id-1')
+      .mockImplementationOnce(() => 'network-configuration-id-2')
+      .mockImplementationOnce(() => 'network-configuration-id-3')
+      .mockImplementationOnce(() => 'network-configuration-id-4');
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+  it('should update the version metadata', async () => {
+    const oldStorage = {
       meta: {
-        version: 9999999,
+        version: 82,
       },
-    });
-
-    const newVersionedData = await migrate(originalVersionedData);
-
-    expect(newVersionedData.meta).toStrictEqual({
-      version: 83,
-    });
-  });
-
-  it('does not change the state if the network controller state does not exist', async () => {
-    const originalVersionedData = buildOriginalVersionedData({
-      data: {
-        test: '123',
-      },
-    });
-
-    const newVersionedData = await migrate(originalVersionedData);
-
-    expect(newVersionedData.data).toStrictEqual(originalVersionedData.data);
-  });
-
-  const nonObjects = [undefined, null, 'test', 1, ['test']];
-  for (const invalidState of nonObjects) {
-    it(`does not change the state if the network controller state is ${invalidState}`, async () => {
-      const originalVersionedData = buildOriginalVersionedData({
-        data: {
-          NetworkController: invalidState,
-        },
-      });
-
-      const newVersionedData = await migrate(originalVersionedData);
-
-      expect(newVersionedData.data).toStrictEqual(originalVersionedData.data);
-    });
-  }
-
-  it('does not change the state if the network controller state does not include "network"', async () => {
-    const originalVersionedData = buildOriginalVersionedData({
-      data: {
-        NetworkController: {
-          test: '123',
-        },
-      },
-    });
-
-    const newVersionedData = await migrate(originalVersionedData);
-
-    expect(newVersionedData.data).toStrictEqual(originalVersionedData.data);
-  });
-
-  it('replaces "network" in the network controller state with "networkId": null, "networkStatus": "unknown" if it is "loading"', async () => {
-    const originalVersionedData = buildOriginalVersionedData({
-      data: {
-        NetworkController: {
-          network: 'loading',
-        },
-      },
-    });
-
-    const newVersionedData = await migrate(originalVersionedData);
-
-    expect(newVersionedData.data).toStrictEqual({
-      NetworkController: {
-        networkId: null,
-        networkStatus: 'unknown',
-      },
-    });
-  });
-
-  it('replaces "network" in the network controller state with "networkId": network, "networkStatus": "available" if it is not "loading"', async () => {
-    const originalVersionedData = buildOriginalVersionedData({
-      data: {
-        NetworkController: {
-          network: '12345',
-        },
-      },
-    });
-
-    const newVersionedData = await migrate(originalVersionedData);
-
-    expect(newVersionedData.data).toStrictEqual({
-      NetworkController: {
-        networkId: '12345',
-        networkStatus: 'available',
-      },
-    });
-  });
-});
-
-function buildOriginalVersionedData({ meta = {}, data = {} } = {}) {
-  return {
-    meta: { version: 999999, ...meta },
-    data: { ...data },
+      data: {},
     };
-}
+
+    const newStorage = await migrate(oldStorage);
+    expect(newStorage.meta).toStrictEqual({
+      version,
+    });
+  });
+
+  it('should use the key of the networkConfigurations object to set the id of each network configuration', async () => {
+    const oldStorage = {
+      meta: {
+        version,
+      },
+      data: {
+        NetworkController: {
+          networkConfigurations: {
+            'network-configuration-id-1': {
+              chainId: '0x539',
+              nickname: 'Localhost 8545',
+              rpcPrefs: {},
+              rpcUrl: 'http://localhost:8545',
+              ticker: 'ETH',
+            },
+            'network-configuration-id-2': {
+              chainId: '0xa4b1',
+              nickname: 'Arbitrum One',
+              rpcPrefs: {
+                blockExplorerUrl: 'https://explorer.arbitrum.io',
+              },
+              rpcUrl:
+                'https://arbitrum-mainnet.infura.io/v3/373266a93aab4acda48f89d4fe77c748',
+              ticker: 'ETH',
+            },
+            'network-configuration-id-3': {
+              chainId: '0x4e454152',
+              nickname: 'Aurora Mainnet',
+              rpcPrefs: {
+                blockExplorerUrl: 'https://aurorascan.dev/',
+              },
+              rpcUrl:
+                'https://aurora-mainnet.infura.io/v3/373266a93aab4acda48f89d4fe77c748',
+              ticker: 'Aurora ETH',
+            },
+            'network-configuration-id-4': {
+              chainId: '0x38',
+              nickname:
+                'BNB Smart Chain (previously Binance Smart Chain Mainnet)',
+              rpcPrefs: {
+                blockExplorerUrl: 'https://bscscan.com/',
+              },
+              rpcUrl: 'https://bsc-dataseed.binance.org/',
+              ticker: 'BNB',
+            },
+          },
+        },
+      },
+    };
+
+    const newStorage = await migrate(oldStorage);
+
+    const expectedNewStorage = {
+      meta: {
+        version,
+      },
+      data: {
+        NetworkController: {
+          networkConfigurations: {
+            'network-configuration-id-1': {
+              chainId: '0x539',
+              nickname: 'Localhost 8545',
+              rpcPrefs: {},
+              rpcUrl: 'http://localhost:8545',
+              ticker: 'ETH',
+              id: 'network-configuration-id-1',
+            },
+            'network-configuration-id-2': {
+              chainId: '0xa4b1',
+              nickname: 'Arbitrum One',
+              rpcPrefs: {
+                blockExplorerUrl: 'https://explorer.arbitrum.io',
+              },
+              rpcUrl:
+                'https://arbitrum-mainnet.infura.io/v3/373266a93aab4acda48f89d4fe77c748',
+              ticker: 'ETH',
+              id: 'network-configuration-id-2',
+            },
+            'network-configuration-id-3': {
+              chainId: '0x4e454152',
+              nickname: 'Aurora Mainnet',
+              rpcPrefs: {
+                blockExplorerUrl: 'https://aurorascan.dev/',
+              },
+              rpcUrl:
+                'https://aurora-mainnet.infura.io/v3/373266a93aab4acda48f89d4fe77c748',
+              ticker: 'Aurora ETH',
+              id: 'network-configuration-id-3',
+            },
+            'network-configuration-id-4': {
+              chainId: '0x38',
+              nickname:
+                'BNB Smart Chain (previously Binance Smart Chain Mainnet)',
+              rpcPrefs: {
+                blockExplorerUrl: 'https://bscscan.com/',
+              },
+              rpcUrl: 'https://bsc-dataseed.binance.org/',
+              ticker: 'BNB',
+              id: 'network-configuration-id-4',
+            },
+          },
+        },
+      },
+    };
+    expect(newStorage).toStrictEqual(expectedNewStorage);
+  });
+
+  it('should not modify state if state.NetworkController is undefined', async () => {
+    const oldStorage = {
+      meta: {
+        version,
+      },
+      data: {
+        testProperty: 'testValue',
+      },
+    };
+
+    const newStorage = await migrate(oldStorage);
+
+    const expectedNewStorage = {
+      meta: {
+        version,
+      },
+      data: {
+        testProperty: 'testValue',
+      },
+    };
+    expect(newStorage).toStrictEqual(expectedNewStorage);
+  });
+
+  it('should not modify state if state.NetworkController is not an object', async () => {
+    const oldStorage = {
+      meta: {
+        version,
+      },
+      data: {
+        NetworkController: false,
+        testProperty: 'testValue',
+      },
+    };
+
+    const newStorage = await migrate(oldStorage);
+
+    const expectedNewStorage = {
+      meta: {
+        version,
+      },
+      data: {
+        NetworkController: false,
+        testProperty: 'testValue',
+      },
+    };
+    expect(newStorage).toStrictEqual(expectedNewStorage);
+  });
+
+  it('should not modify state if state.NetworkController.networkConfigurations is undefined', async () => {
+    const oldStorage = {
+      meta: {
+        version,
+      },
+      data: {
+        NetworkController: {
+          testNetworkControllerProperty: 'testNetworkControllerValue',
+          networkConfigurations: undefined,
+        },
+        testProperty: 'testValue',
+      },
+    };
+
+    const newStorage = await migrate(oldStorage);
+
+    const expectedNewStorage = {
+      meta: {
+        version,
+      },
+      data: {
+        NetworkController: {
+          testNetworkControllerProperty: 'testNetworkControllerValue',
+          networkConfigurations: undefined,
+        },
+        testProperty: 'testValue',
+      },
+    };
+    expect(newStorage).toStrictEqual(expectedNewStorage);
+  });
+
+  it('should not modify state if state.NetworkController.networkConfigurations is an empty object', async () => {
+    const oldStorage = {
+      meta: {
+        version,
+      },
+      data: {
+        NetworkController: {
+          testNetworkControllerProperty: 'testNetworkControllerValue',
+          networkConfigurations: {},
+        },
+        testProperty: 'testValue',
+      },
+    };
+
+    const newStorage = await migrate(oldStorage);
+
+    const expectedNewStorage = {
+      meta: {
+        version,
+      },
+      data: {
+        NetworkController: {
+          testNetworkControllerProperty: 'testNetworkControllerValue',
+          networkConfigurations: {},
+        },
+        testProperty: 'testValue',
+      },
+    };
+    expect(newStorage).toStrictEqual(expectedNewStorage);
+  });
+});

app/scripts/migrations/083.ts

@@ -1,10 +1,11 @@
 import { cloneDeep } from 'lodash';
-import { hasProperty, isObject } from '@metamask/utils';
+import { isObject } from '@metamask/utils';
 
 export const version = 83;
 
 /**
- * The `network` property in state was replaced with `networkId` and `networkStatus`.
+ * Ensure that each networkConfigurations object in state.NetworkController.networkConfigurations has an
+ * `id` property which matches the key pointing that object
  *
  * @param originalVersionedData - Versioned MetaMask extension state, exactly what we persist to dist.
  * @param originalVersionedData.meta - State metadata.
@@ -23,25 +24,35 @@ export async function migrate(originalVersionedData: {
 }
 
 function transformState(state: Record<string, unknown>) {
-  if (
-    !hasProperty(state, 'NetworkController') ||
-    !isObject(state.NetworkController) ||
-    !hasProperty(state.NetworkController, 'network')
-  ) {
+  if (!isObject(state.NetworkController)) {
+    return state;
+  }
+  const { NetworkController } = state;
+
+  if (!isObject(NetworkController.networkConfigurations)) {
     return state;
   }
 
-  const NetworkController = { ...state.NetworkController };
+  const { networkConfigurations } = NetworkController;
 
-  if (NetworkController.network === 'loading') {
-    NetworkController.networkId = null;
-    NetworkController.networkStatus = 'unknown';
-  } else {
-    NetworkController.networkId = NetworkController.network;
-    NetworkController.networkStatus = 'available';
+  const newNetworkConfigurations: Record<string, Record<string, unknown>> = {};
+
+  for (const networkConfigurationId of Object.keys(networkConfigurations)) {
+    const networkConfiguration = networkConfigurations[networkConfigurationId];
+    if (!isObject(networkConfiguration)) {
+      return state;
+    }
+    newNetworkConfigurations[networkConfigurationId] = {
+      ...networkConfiguration,
+      id: networkConfigurationId,
+    };
   }
 
-  delete NetworkController.network;
-
-  return { ...state, NetworkController };
+  return {
+    ...state,
+    NetworkController: {
+      ...NetworkController,
+      networkConfigurations: newNetworkConfigurations,
+    },
+  };
 }

app/scripts/migrations/084.test.js

@@ -0,0 +1,103 @@
+import { migrate } from './084';
+
+describe('migration #84', () => {
+  it('updates the version metadata', async () => {
+    const originalVersionedData = buildOriginalVersionedData({
+      meta: {
+        version: 9999999,
+      },
+    });
+
+    const newVersionedData = await migrate(originalVersionedData);
+
+    expect(newVersionedData.meta).toStrictEqual({
+      version: 84,
+    });
+  });
+
+  it('does not change the state if the network controller state does not exist', async () => {
+    const originalVersionedData = buildOriginalVersionedData({
+      data: {
+        test: '123',
+      },
+    });
+
+    const newVersionedData = await migrate(originalVersionedData);
+
+    expect(newVersionedData.data).toStrictEqual(originalVersionedData.data);
+  });
+
+  const nonObjects = [undefined, null, 'test', 1, ['test']];
+  for (const invalidState of nonObjects) {
+    it(`does not change the state if the network controller state is ${invalidState}`, async () => {
+      const originalVersionedData = buildOriginalVersionedData({
+        data: {
+          NetworkController: invalidState,
+        },
+      });
+
+      const newVersionedData = await migrate(originalVersionedData);
+
+      expect(newVersionedData.data).toStrictEqual(originalVersionedData.data);
+    });
+  }
+
+  it('does not change the state if the network controller state does not include "network"', async () => {
+    const originalVersionedData = buildOriginalVersionedData({
+      data: {
+        NetworkController: {
+          test: '123',
+        },
+      },
+    });
+
+    const newVersionedData = await migrate(originalVersionedData);
+
+    expect(newVersionedData.data).toStrictEqual(originalVersionedData.data);
+  });
+
+  it('replaces "network" in the network controller state with "networkId": null, "networkStatus": "unknown" if it is "loading"', async () => {
+    const originalVersionedData = buildOriginalVersionedData({
+      data: {
+        NetworkController: {
+          network: 'loading',
+        },
+      },
+    });
+
+    const newVersionedData = await migrate(originalVersionedData);
+
+    expect(newVersionedData.data).toStrictEqual({
+      NetworkController: {
+        networkId: null,
+        networkStatus: 'unknown',
+      },
+    });
+  });
+
+  it('replaces "network" in the network controller state with "networkId": network, "networkStatus": "available" if it is not "loading"', async () => {
+    const originalVersionedData = buildOriginalVersionedData({
+      data: {
+        NetworkController: {
+          network: '12345',
+        },
+      },
+    });
+
+    const newVersionedData = await migrate(originalVersionedData);
+
+    expect(newVersionedData.data).toStrictEqual({
+      NetworkController: {
+        networkId: '12345',
+        networkStatus: 'available',
+      },
+    });
+  });
+});
+
+function buildOriginalVersionedData({ meta = {}, data = {} } = {}) {
+  return {
+    meta: { version: 999999, ...meta },
+    data: { ...data },
+  };
+}

app/scripts/migrations/084.ts

@@ -0,0 +1,47 @@
+import { cloneDeep } from 'lodash';
+import { hasProperty, isObject } from '@metamask/utils';
+
+export const version = 84;
+
+/**
+ * The `network` property in state was replaced with `networkId` and `networkStatus`.
+ *
+ * @param originalVersionedData - Versioned MetaMask extension state, exactly what we persist to dist.
+ * @param originalVersionedData.meta - State metadata.
+ * @param originalVersionedData.meta.version - The current state version.
+ * @param originalVersionedData.data - The persisted MetaMask state, keyed by controller.
+ * @returns Updated versioned MetaMask extension state.
+ */
+export async function migrate(originalVersionedData: {
+  meta: { version: number };
+  data: Record<string, unknown>;
+}) {
+  const versionedData = cloneDeep(originalVersionedData);
+  versionedData.meta.version = version;
+  versionedData.data = transformState(versionedData.data);
+  return versionedData;
+}
+
+function transformState(state: Record<string, unknown>) {
+  if (
+    !hasProperty(state, 'NetworkController') ||
+    !isObject(state.NetworkController) ||
+    !hasProperty(state.NetworkController, 'network')
+  ) {
+    return state;
+  }
+
+  const NetworkController = { ...state.NetworkController };
+
+  if (NetworkController.network === 'loading') {
+    NetworkController.networkId = null;
+    NetworkController.networkStatus = 'unknown';
+  } else {
+    NetworkController.networkId = NetworkController.network;
+    NetworkController.networkStatus = 'available';
+  }
+
+  delete NetworkController.network;
+
+  return { ...state, NetworkController };
+}

app/scripts/migrations/index.js

@@ -87,6 +87,7 @@ import m080 from './080';
 import * as m081 from './081';
 import * as m082 from './082';
 import * as m083 from './083';
+import * as m084 from './084';
 
 const migrations = [
   m002,
@@ -171,6 +172,7 @@ const migrations = [
   m081,
   m082,
   m083,
+  m084,
 ];
 
 export default migrations;