NetworkController: Split network into networkId and `networkStatu…

…s` (#17556)

The `network` store of the network controller crams two types of data
into one place. It roughly tracks whether we have enough information to
make requests to the network and whether the network is capable of
receiving requests, but it also stores the ID of the network (as
obtained via `net_version`).

Generally we shouldn't be using the network ID for anything, as it has
been completely replaced by chain ID, which all custom RPC endpoints
have been required to support for over a year now. However, as the
network ID is used in various places within the extension codebase,
removing it entirely would be a non-trivial effort. So, minimally, this
commit splits `network` into two stores: `networkId` and
`networkStatus`. But it also expands the concept of network status.

Previously, the network was in one of two states: "loading" and
"not-loading". But now it can be in one of four states:

- `available`: The network is able to receive and respond to requests.
- `unavailable`: The network is not able to receive and respond to
  requests for unknown reasons.
- `blocked`: The network is actively blocking requests based on the
  user's geolocation. (This is specific to Infura.)
- `unknown`: We don't know whether the network can receive and respond
  to requests, either because we haven't checked or we tried to check
  and were unsuccessful.

This commit also changes how the network status is determined —
specifically, how many requests are used to determine that status, when
they occur, and whether they are awaited. Previously, the network
controller would make 2 to 3 requests during the course of running
`lookupNetwork`.

* First, if it was an Infura network, it would make a request for
  `eth_blockNumber` to determine whether Infura was blocking requests or
  not, then emit an appropriate event. This operation was not awaited.
* Then, regardless of the network, it would fetch the network ID via
  `net_version`. This operation was awaited.
* Finally, regardless of the network, it would fetch the latest block
  via `eth_getBlockByNumber`, then use the result to determine whether
  the network supported EIP-1559. This operation was awaited.

Now:

* One fewer request is made, specifically `eth_blockNumber`, as we don't
  need to make an extra request to determine whether Infura is blocking
  requests; we can reuse `eth_getBlockByNumber`;
* All requests are awaited, which makes `lookupNetwork` run fully
  in-band instead of partially out-of-band; and
* Both requests for `net_version` and `eth_getBlockByNumber` are
  performed in parallel to make `lookupNetwork` run slightly faster.

app/scripts/background.js

@@ -223,7 +223,8 @@ browser.runtime.onConnectExternal.addListener(async (...args) => {
  * @property {object} provider - The current selected network provider.
  * @property {string} provider.rpcUrl - The address for the RPC API, if using an RPC API.
  * @property {string} provider.type - An identifier for the type of network selected, allows MetaMask to use custom provider strategies for known networks.
- * @property {string} network - A stringified number of the current network ID.
+ * @property {string} networkId - The stringified number of the current network ID.
+ * @property {string} networkStatus - Either "unknown", "available", "unavailable", or "blocked", depending on the status of the currently selected network.
  * @property {object} accounts - An object mapping lower-case hex addresses to objects with "balance" and "address" keys, both storing hex string values.
  * @property {hex} currentBlockGasLimit - The most recently seen block gas limit, in a lower case hex prefixed string.
  * @property {TransactionMeta[]} currentNetworkTxList - An array of transactions associated with the currently selected network.

app/scripts/controllers/detect-tokens.test.js

@@ -17,8 +17,8 @@ import NetworkController, { NetworkControllerEventTypes } from './network';
 import PreferencesController from './preferences';
 
 describe('DetectTokensController', function () {
-  const sandbox = sinon.createSandbox();
-  let assetsContractController,
+  let sandbox,
+    assetsContractController,
     keyringMemStore,
     network,
     preferences,
@@ -32,87 +32,94 @@ describe('DetectTokensController', function () {
     getAccounts: noop,
   };
 
+  const infuraProjectId = 'infura-project-id';
+
   beforeEach(async function () {
-    keyringMemStore = new ObservableStore({ isUnlocked: false });
-    const networkControllerMessenger = new ControllerMessenger();
-    network = new NetworkController({
-      messenger: networkControllerMessenger,
-      infuraProjectId: 'foo',
-    });
-    network.initializeProvider(networkControllerProviderConfig);
-    provider = network.getProviderAndBlockTracker().provider;
+    sandbox = sinon.createSandbox();
+    // Disable all requests, even those to localhost
+    nock.disableNetConnect();
+    nock('https://mainnet.infura.io')
+      .post(`/v3/${infuraProjectId}`)
+      .reply(200, (_uri, requestBody) => {
+        if (requestBody.method === 'eth_getBlockByNumber') {
+          return {
+            id: requestBody.id,
+            jsonrpc: '2.0',
+            result: {
+              number: '0x42',
+            },
+          };
+        }
 
-    const tokenListMessenger = new ControllerMessenger().getRestricted({
-      name: 'TokenListController',
-    });
-    tokenListController = new TokenListController({
-      chainId: '1',
-      preventPollingOnNetworkRestart: false,
-      onNetworkStateChange: sinon.spy(),
-      onPreferencesStateChange: sinon.spy(),
-      messenger: tokenListMessenger,
-    });
-    await tokenListController.start();
+        if (requestBody.method === 'eth_blockNumber') {
+          return {
+            id: requestBody.id,
+            jsonrpc: '2.0',
+            result: '0x42',
+          };
+        }
 
-    preferences = new PreferencesController({
-      network,
-      provider,
-      tokenListController,
-      onInfuraIsBlocked: sinon.stub(),
-      onInfuraIsUnblocked: sinon.stub(),
-    });
-    preferences.setAddresses([
-      '0x7e57e2',
-      '0xbc86727e770de68b1060c91f6bb6945c73e10388',
-    ]);
-    preferences.setUseTokenDetection(true);
+        throw new Error(`(Infura) Mock not defined for ${requestBody.method}`);
+      })
+      .persist();
+    nock('https://sepolia.infura.io')
+      .post(`/v3/${infuraProjectId}`)
+      .reply(200, (_uri, requestBody) => {
+        if (requestBody.method === 'eth_getBlockByNumber') {
+          return {
+            id: requestBody.id,
+            jsonrpc: '2.0',
+            result: {
+              number: '0x42',
+            },
+          };
+        }
 
-    tokensController = new TokensController({
-      onPreferencesStateChange: preferences.store.subscribe.bind(
-        preferences.store,
-      ),
-      onNetworkStateChange: (cb) =>
-        network.store.subscribe((networkState) => {
-          const modifiedNetworkState = {
-            ...networkState,
-            providerConfig: {
-              ...networkState.provider,
+        if (requestBody.method === 'eth_blockNumber') {
+          return {
+            id: requestBody.id,
+            jsonrpc: '2.0',
+            result: '0x42',
+          };
+        }
+
+        throw new Error(`(Infura) Mock not defined for ${requestBody.method}`);
+      })
+      .persist();
+    nock('http://localhost:8545')
+      .post('/')
+      .reply(200, (_uri, requestBody) => {
+        if (requestBody.method === 'eth_getBlockByNumber') {
+          return {
+            id: requestBody.id,
+            jsonrpc: '2.0',
+            result: {
+              number: '0x42',
             },
           };
-          return cb(modifiedNetworkState);
-        }),
-    });
+        }
 
-    assetsContractController = new AssetsContractController({
-      onPreferencesStateChange: preferences.store.subscribe.bind(
-        preferences.store,
-      ),
-      onNetworkStateChange: (cb) =>
-        networkControllerMessenger.subscribe(
-          NetworkControllerEventTypes.NetworkDidChange,
-          () => {
-            const networkState = network.store.getState();
-            const modifiedNetworkState = {
-              ...networkState,
-              providerConfig: {
-                ...networkState.provider,
-                chainId: convertHexToDecimal(networkState.provider.chainId),
-              },
-            };
-            return cb(modifiedNetworkState);
-          },
-        ),
-    });
+        if (requestBody.method === 'eth_blockNumber') {
+          return {
+            id: requestBody.id,
+            jsonrpc: '2.0',
+            result: '0x42',
+          };
+        }
 
-    sandbox
-      .stub(network, '_getLatestBlock')
-      .callsFake(() => Promise.resolve({}));
-    sandbox
-      .stub(tokensController, '_instantiateNewEthersProvider')
-      .returns(null);
-    sandbox
-      .stub(tokensController, '_detectIsERC721')
-      .returns(Promise.resolve(false));
+        if (requestBody.method === 'net_version') {
+          return {
+            id: requestBody.id,
+            jsonrpc: '2.0',
+            result: '1337',
+          };
+        }
+
+        throw new Error(
+          `(localhost) Mock not defined for ${requestBody.method}`,
+        );
+      })
+      .persist();
     nock('https://token-api.metaswap.codefi.network')
       .get(`/tokens/1`)
       .reply(200, [
@@ -183,9 +190,82 @@ describe('DetectTokensController', function () {
       .get(`/tokens/3`)
       .reply(200, { error: 'ChainId 3 is not supported' })
       .persist();
+
+    keyringMemStore = new ObservableStore({ isUnlocked: false });
+    const networkControllerMessenger = new ControllerMessenger();
+    network = new NetworkController({
+      messenger: networkControllerMessenger,
+      infuraProjectId,
+    });
+    await network.initializeProvider(networkControllerProviderConfig);
+    provider = network.getProviderAndBlockTracker().provider;
+
+    const tokenListMessenger = new ControllerMessenger().getRestricted({
+      name: 'TokenListController',
+    });
+    tokenListController = new TokenListController({
+      chainId: '1',
+      preventPollingOnNetworkRestart: false,
+      onNetworkStateChange: sinon.spy(),
+      onPreferencesStateChange: sinon.spy(),
+      messenger: tokenListMessenger,
+    });
+    await tokenListController.start();
+
+    preferences = new PreferencesController({
+      network,
+      provider,
+      tokenListController,
+      onInfuraIsBlocked: sinon.stub(),
+      onInfuraIsUnblocked: sinon.stub(),
+    });
+    preferences.setAddresses([
+      '0x7e57e2',
+      '0xbc86727e770de68b1060c91f6bb6945c73e10388',
+    ]);
+    preferences.setUseTokenDetection(true);
+
+    tokensController = new TokensController({
+      config: { provider },
+      onPreferencesStateChange: preferences.store.subscribe.bind(
+        preferences.store,
+      ),
+      onNetworkStateChange: (cb) =>
+        network.store.subscribe((networkState) => {
+          const modifiedNetworkState = {
+            ...networkState,
+            providerConfig: {
+              ...networkState.provider,
+            },
+          };
+          return cb(modifiedNetworkState);
+        }),
+    });
+
+    assetsContractController = new AssetsContractController({
+      onPreferencesStateChange: preferences.store.subscribe.bind(
+        preferences.store,
+      ),
+      onNetworkStateChange: (cb) =>
+        networkControllerMessenger.subscribe(
+          NetworkControllerEventTypes.NetworkDidChange,
+          () => {
+            const networkState = network.store.getState();
+            const modifiedNetworkState = {
+              ...networkState,
+              providerConfig: {
+                ...networkState.provider,
+                chainId: convertHexToDecimal(networkState.provider.chainId),
+              },
+            };
+            return cb(modifiedNetworkState);
+          },
+        ),
+    });
   });
 
-  after(function () {
+  afterEach(function () {
+    nock.enableNetConnect('localhost');
     sandbox.restore();
   });