Keep network statuses up to date as requests are made

packages/network-controller/CHANGELOG.md

@@ -31,6 +31,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - In clients, it is now possible for multiple versions of these packages to exist in the dependency tree.
     - For example, this scenario would be valid: a client relies on `@metamask/controller-a` 1.0.0 and `@metamask/controller-b` 1.0.0, and `@metamask/controller-b` depends on `@metamask/controller-a` 1.1.0.
   - Note, however, that the versions specified in the client's `package.json` always "win", and you are expected to keep them up to date so as not to break controller and service intercommunication.
+- Automatically update network status metadata when chain-level RPC events are published ([#7186](https://github.com/MetaMask/core/pull/7186))
+  - `NetworkController` now automatically subscribes to `NetworkController:rpcEndpointChainUnavailable`, `NetworkController:rpcEndpointChainDegraded`, and `NetworkController:rpcEndpointChainAvailable` events and updates the corresponding network's status metadata in state when these events are published.
+  - This enables real-time network status updates without requiring explicit `lookupNetwork` calls, providing more accurate and timely network availability information.
 
 ## [26.0.0]
 

packages/network-controller/src/NetworkController.ts

@@ -1439,6 +1439,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,
+        });
+      },
+    );
   }
 
   /**
@@ -1846,11 +1871,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,
-    );
+    });
   }
 
   /**
@@ -1925,11 +1950,10 @@ export class NetworkController extends BaseController<
       }
     }
 
-    this.#updateMetadataForNetwork(
-      this.state.selectedNetworkClientId,
+    this.#updateMetadataForNetwork(this.state.selectedNetworkClientId, {
       networkStatus,
       isEIP1559Compatible,
-    );
+    });
 
     if (isInfura) {
       if (networkStatus === NetworkStatus.Available) {
@@ -1949,14 +1973,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) {
@@ -1965,12 +1992,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,34 @@
 /**
- * Represents the availability state of the currently selected network.
+ * Represents the availability status of an RPC endpoint. (Regrettably, the
+ * name of this type is a misnomer.)
+ *
+ * The availability status is set both automatically (as requests are made) and
+ * manually (when `lookupNetwork` is called).
  */
 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.
+   * Either the availability status of the RPC endpoint has not been determined,
+   * or request that `lookupNetwork` performed returned an unknown error.
    */
   Unknown = 'unknown',
   /**
-   * The network is able to receive and respond to requests.
+   * The RPC endpoint is consistently returning successful (2xx) responses.
    */
   Available = 'available',
   /**
-   * The network was unable to receive and respond to requests for unknown
-   * reasons.
+   * Either the last request to the RPC endpoint was either too slow, or the
+   * endpoint is consistently returning errors and the number of retries has
+   * been reached.
+   */
+  Degraded = 'degraded',
+  /**
+   * The RPC endpoint is consistently returning enough 5xx errors that requests
+   * have been paused.
    */
   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',
 }