feat: NetworkController changes to support Network Syncing

packages/network-controller/src/NetworkController.ts

@@ -212,8 +212,11 @@ export type NetworkConfiguration = {
  * Custom RPC endpoints do not need a `networkClientId` property because it is
  * assumed that they have not already been added and therefore network clients
  * do not exist for them yet (and hence IDs need to be generated).
+ *
+ * However Custom RPC endpoints, that are synchronized between devices,
+ * can contain a `networkClientId` set on both devices.
  */
-export type AddNetworkCustomRpcEndpointFields = Omit<
+export type AddNetworkCustomRpcEndpointFields = Partialize<
   CustomRpcEndpoint,
   'networkClientId'
 >;
@@ -473,6 +476,11 @@ export type NetworkControllerGetNetworkConfigurationByNetworkClientId = {
   handler: NetworkController['getNetworkConfigurationByNetworkClientId'];
 };
 
+export type NetworkControllerDangerouslySetNetworkConfigurationAction = {
+  type: 'NetworkController:dangerouslySetNetworkConfiguration';
+  handler: NetworkController['dangerouslySetNetworkConfiguration'];
+};
+
 export type NetworkControllerActions =
   | NetworkControllerGetStateAction
   | NetworkControllerGetEthQueryAction
@@ -483,7 +491,8 @@ export type NetworkControllerActions =
   | NetworkControllerSetActiveNetworkAction
   | NetworkControllerSetProviderTypeAction
   | NetworkControllerGetNetworkConfigurationByChainId
-  | NetworkControllerGetNetworkConfigurationByNetworkClientId;
+  | NetworkControllerGetNetworkConfigurationByNetworkClientId
+  | NetworkControllerDangerouslySetNetworkConfigurationAction;
 
 export type NetworkControllerMessenger = RestrictedControllerMessenger<
   typeof controllerName,
@@ -954,6 +963,13 @@ export class NetworkController extends BaseController<
       `${this.name}:getSelectedNetworkClient`,
       this.getSelectedNetworkClient.bind(this),
     );
+
+    this.messagingSystem.registerActionHandler(
+      // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `${this.name}:dangerouslySetNetworkConfiguration`,
+      this.dangerouslySetNetworkConfiguration.bind(this),
+    );
   }
 
   /**
@@ -1557,7 +1573,8 @@ export class NetworkController extends BaseController<
           defaultOrCustomRpcEndpointFields.type === RpcEndpointType.Custom
             ? {
                 ...defaultOrCustomRpcEndpointFields,
-                networkClientId: uuidV4(),
+                networkClientId:
+                  defaultOrCustomRpcEndpointFields.networkClientId ?? uuidV4(),
               }
             : defaultOrCustomRpcEndpointFields;
         return {
@@ -1941,6 +1958,129 @@ export class NetworkController extends BaseController<
       );
   }
 
+  /**
+   * This is used to override an existing network configuration.
+   * This is only meant for internal use only and not to be exposed via the UI.
+   * It is used as part of "Network Syncing", to sync networks, RPCs and block explorers cross devices.
+   *
+   * This will subsequently update the network client registry; state.networksMetadata, and state.selectedNetworkClientId
+   * @param networkConfiguration - the network configuration to override
+   */
+  async dangerouslySetNetworkConfiguration(
+    networkConfiguration: NetworkConfiguration,
+  ) {
+    const prevNetworkConfig: NetworkConfiguration | undefined =
+      networkConfiguration.chainId in this.state.networkConfigurationsByChainId
+        ? this.state.networkConfigurationsByChainId[
+            networkConfiguration.chainId
+          ]
+        : undefined;
+
+    if (!prevNetworkConfig) {
+      // We only want to perform overrides, not add new network configurations
+      return;
+    }
+
+    // Update Registry (remove old and add new)
+    const updateRegistry = () => {
+      // Unregister old networks we want to override
+      const autoManagedNetworkClientRegistry =
+        this.#ensureAutoManagedNetworkClientRegistryPopulated();
+      const networkClientRemoveOperations = prevNetworkConfig.rpcEndpoints.map(
+        (rpcEndpoint) => {
+          return {
+            type: 'remove' as const,
+            rpcEndpoint,
+          };
+        },
+      );
+      this.#unregisterNetworkClientsAsNeeded({
+        networkClientOperations: networkClientRemoveOperations,
+        autoManagedNetworkClientRegistry,
+      });
+
+      // Register new networks we want to override
+      const networkClientAddOperations = networkConfiguration.rpcEndpoints.map(
+        (rpcEndpoint) => {
+          return {
+            type: 'add' as const,
+            rpcEndpoint,
+          };
+        },
+      );
+      this.#registerNetworkClientsAsNeeded({
+        networkFields: networkConfiguration,
+        networkClientOperations: networkClientAddOperations,
+        autoManagedNetworkClientRegistry,
+      });
+    };
+
+    // Replace the networkConfiguration with our new networkConfiguration
+    // This is a full replace (no merging)
+    const replaceNetworkConfiguration = () => {
+      // Update State
+      this.update((state) => {
+        state.networkConfigurationsByChainId[networkConfiguration.chainId] =
+          networkConfiguration;
+      });
+
+      // Update Cache
+      this.#networkConfigurationsByNetworkClientId =
+        buildNetworkConfigurationsByNetworkClientId(
+          this.state.networkConfigurationsByChainId,
+        );
+    };
+
+    // Updates the NetworksMetadata State
+    const updateNetworksMetadata = async () => {
+      // Remove old metadata state
+      this.update((state) => {
+        prevNetworkConfig.rpcEndpoints.forEach((r) => {
+          if (state.networksMetadata?.[r.networkClientId]) {
+            delete state.networksMetadata[r.networkClientId];
+          }
+        });
+      });
+
+      // Add new metadata state
+      for (const r of networkConfiguration.rpcEndpoints) {
+        await this.lookupNetwork(r.networkClientId);
+      }
+    };
+
+    // Update selectedNetworkId State
+    // Will try to keep the same OR will select a new RPC from new network OR any network (edge case)
+    const updateSelectedNetworkId = async () => {
+      const selectedClientId = this.state.selectedNetworkClientId;
+      const wasClientIdReplaced = prevNetworkConfig.rpcEndpoints.some(
+        (r) => r.networkClientId === selectedClientId,
+      );
+      const doesExistInNewNetwork = networkConfiguration.rpcEndpoints.some(
+        (r) => r.networkClientId === selectedClientId,
+      );
+
+      const shouldUpdateSelectedNetworkId =
+        wasClientIdReplaced && !doesExistInNewNetwork;
+      if (shouldUpdateSelectedNetworkId) {
+        // Update the clientId to "something" that exists
+        const newRPCClientId = networkConfiguration.rpcEndpoints.find(
+          (r) => r.networkClientId in this.state.networksMetadata,
+        )?.networkClientId;
+        const anyRPCClientId = Object.keys(this.state.networksMetadata)[0];
+        /* istanbul ignore next: anyRPCClientId and selectedClientId are fallbacks and should be impossible to reach  */
+        const newlySelectedNetwork =
+          newRPCClientId ?? anyRPCClientId ?? selectedClientId;
+        await this.#refreshNetwork(newlySelectedNetwork);
+      }
+    };
+
+    // Execute Set Network Config
+    updateRegistry();
+    replaceNetworkConfiguration();
+    await updateNetworksMetadata();
+    await updateSelectedNetworkId();
+  }
+
   /**
    * Assuming that the network has been previously switched, switches to this
    * new network.

packages/network-controller/src/index.ts

@@ -26,6 +26,7 @@ export type {
   NetworkControllerFindNetworkClientIdByChainIdAction,
   NetworkControllerSetProviderTypeAction,
   NetworkControllerSetActiveNetworkAction,
+  NetworkControllerDangerouslySetNetworkConfigurationAction,
   NetworkControllerGetNetworkConfigurationByNetworkClientId,
   NetworkControllerActions,
   NetworkControllerMessenger,