Keep network statuses up to date as requests are made

NetworkController has the ability to analyze an RPC endpoint and capture
its availability status (that is, whether the controller is able to make
successful requests to the endpoint). However, this step occurs
automatically only once, when the RPC endpoint's network is switched to,
and so any changes in status while the network is being used will not
be reflected in state. This problem can be mitigated by periodically
calling `lookupNetwork` manually, but this is awkward, and usage of this
method should be kept in check so as not to create too many requests.

Ideally, the controller should keep track of network status as requests
are made. This commit implements this change by hooking into events
published by the network client and added in a previous commit.

Author: mcmire

packages/network-controller/src/NetworkController.ts

@@ -1491,6 +1491,31 @@ export class NetworkController extends BaseController<
       `${this.name}:updateNetwork`,
       this.updateNetwork.bind(this),
     );
+
+    this.messenger.subscribe(
+      `${this.name}:rpcEndpointChainUnavailable`,
+      ({ networkClientId }) => {
+        this.#updateMetadataForNetwork(networkClientId, {
+          networkStatus: NetworkStatus.Unavailable,
+        });
+      },
+    );
+    this.messenger.subscribe(
+      `${this.name}:rpcEndpointChainDegraded`,
+      ({ networkClientId }) => {
+        this.#updateMetadataForNetwork(networkClientId, {
+          networkStatus: NetworkStatus.Degraded,
+        });
+      },
+    );
+    this.messenger.subscribe(
+      `${this.name}:rpcEndpointChainAvailable`,
+      ({ networkClientId }) => {
+        this.#updateMetadataForNetwork(networkClientId, {
+          networkStatus: NetworkStatus.Available,
+        });
+      },
+    );
   }
 
   /**
@@ -1898,11 +1923,11 @@ export class NetworkController extends BaseController<
   async #lookupGivenNetwork(networkClientId: NetworkClientId) {
     const { networkStatus, isEIP1559Compatible } =
       await this.#determineNetworkMetadata(networkClientId);
-    this.#updateMetadataForNetwork(
-      networkClientId,
+
+    this.#updateMetadataForNetwork(networkClientId, {
       networkStatus,
       isEIP1559Compatible,
-    );
+    });
   }
 
   /**
@@ -1977,11 +2002,10 @@ export class NetworkController extends BaseController<
       }
     }
 
-    this.#updateMetadataForNetwork(
-      this.state.selectedNetworkClientId,
+    this.#updateMetadataForNetwork(this.state.selectedNetworkClientId, {
       networkStatus,
       isEIP1559Compatible,
-    );
+    });
 
     if (isInfura) {
       if (networkStatus === NetworkStatus.Available) {
@@ -2001,14 +2025,17 @@ export class NetworkController extends BaseController<
    * Updates the metadata for the given network in state.
    *
    * @param networkClientId - The associated network client ID.
-   * @param networkStatus - The network status to store in state.
-   * @param isEIP1559Compatible - The EIP-1559 compatibility status to
+   * @param metadata - The metadata to store in state.
+   * @param metadata.networkStatus - The network status to store in state.
+   * @param metadata.isEIP1559Compatible - The EIP-1559 compatibility status to
    * store in state.
    */
   #updateMetadataForNetwork(
     networkClientId: NetworkClientId,
-    networkStatus: NetworkStatus,
-    isEIP1559Compatible: boolean | undefined,
+    metadata: {
+      networkStatus: NetworkStatus;
+      isEIP1559Compatible?: boolean | undefined;
+    },
   ) {
     this.update((state) => {
       if (state.networksMetadata[networkClientId] === undefined) {
@@ -2017,12 +2044,15 @@ export class NetworkController extends BaseController<
           EIPS: {},
         };
       }
-      const meta = state.networksMetadata[networkClientId];
-      meta.status = networkStatus;
-      if (isEIP1559Compatible === undefined) {
-        delete meta.EIPS[1559];
-      } else {
-        meta.EIPS[1559] = isEIP1559Compatible;
+      const newMetadata = state.networksMetadata[networkClientId];
+      newMetadata.status = metadata.networkStatus;
+
+      if ('isEIP1559Compatible' in metadata) {
+        if (metadata.isEIP1559Compatible === undefined) {
+          delete newMetadata.EIPS[1559];
+        } else {
+          newMetadata.EIPS[1559] = metadata.isEIP1559Compatible;
+        }
       }
     });
   }

packages/network-controller/src/constants.ts

@@ -1,26 +1,29 @@
 /**
- * Represents the availability state of the currently selected network.
+ * Represents the availability state of an RPC endpoint. (Yes, this is a
+ * misnomer.)
  */
 export enum NetworkStatus {
   /**
-   * The network may or may not be able to receive requests, but either no
-   * attempt has been made to determine this, or an attempt was made but was
-   * unsuccessful.
+   * It is not determined yet whether the RPC endpoint is available.
    */
   Unknown = 'unknown',
   /**
-   * The network is able to receive and respond to requests.
+   * The RPC endpoint is consistently returning successful responses.
    */
   Available = 'available',
   /**
-   * The network was unable to receive and respond to requests for unknown
-   * reasons.
+   * Requests to the RPC endpoint are either slow or are beginning to
+   * consistently respond with errors.
+   */
+  Degraded = 'degraded',
+  /**
+   * Requests to the RPC endpoint have responded with enough errors that it is
+   * determined to be unavailable.
    */
   Unavailable = 'unavailable',
   /**
-   * The network is not only unavailable, but is also inaccessible for the user
-   * specifically based on their location. This state only applies to Infura
-   * networks.
+   * The RPC endpoint is inaccessible for the user based on their location. This
+   * status only applies to Infura networks.
    */
   Blocked = 'blocked',
 }

packages/network-controller/src/rpc-service/rpc-service-chain.ts

@@ -21,6 +21,7 @@ import type {
 import { projectLogger, createModuleLogger } from '../logger';
 
 const log = createModuleLogger(projectLogger, 'RpcServiceChain');
+// const log = console.log.bind(console);
 
 /**
  * Statuses that the RPC service chain can be in.

packages/network-controller/src/rpc-service/rpc-service.ts

@@ -61,6 +61,7 @@ export type RpcServiceOptions = {
 };
 
 const log = createModuleLogger(projectLogger, 'RpcService');
+// const log = console.log.bind(console);
 
 /**
  * The maximum number of times that a failing service should be re-run before