Temp/network syncing all changes

packages/network-controller/src/NetworkController.ts

@@ -203,6 +203,11 @@ export type NetworkConfiguration = {
    * interact with the chain.
    */
   rpcEndpoints: RpcEndpoint[];
+  /**
+   * Profile Sync - Network Sync field.
+   * Allows comparison of local network state with state to sync.
+   */
+  lastUpdatedAt?: number;
 };
 
 /**
@@ -212,8 +217,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'
 >;
@@ -409,13 +417,23 @@ export type NetworkControllerNetworkAddedEvent = {
   payload: [networkConfiguration: NetworkConfiguration];
 };
 
+/**
+ * `networkRemoved` is published after a network configuration is removed from the
+ * network configuration registry and once the network clients have been removed.
+ */
+export type NetworkControllerNetworkRemovedEvent = {
+  type: 'NetworkController:networkRemoved';
+  payload: [networkConfiguration: NetworkConfiguration];
+};
+
 export type NetworkControllerEvents =
   | NetworkControllerStateChangeEvent
   | NetworkControllerNetworkWillChangeEvent
   | NetworkControllerNetworkDidChangeEvent
   | NetworkControllerInfuraIsBlockedEvent
   | NetworkControllerInfuraIsUnblockedEvent
-  | NetworkControllerNetworkAddedEvent;
+  | NetworkControllerNetworkAddedEvent
+  | NetworkControllerNetworkRemovedEvent;
 
 export type NetworkControllerGetStateAction = ControllerGetStateAction<
   typeof controllerName,
@@ -473,6 +491,26 @@ export type NetworkControllerGetNetworkConfigurationByNetworkClientId = {
   handler: NetworkController['getNetworkConfigurationByNetworkClientId'];
 };
 
+export type NetworkControllerAddNetworkAction = {
+  type: 'NetworkController:addNetwork';
+  handler: NetworkController['addNetwork'];
+};
+
+export type NetworkControllerRemoveNetworkAction = {
+  type: 'NetworkController:removeNetwork';
+  handler: NetworkController['removeNetwork'];
+};
+
+export type NetworkControllerUpdateNetworkAction = {
+  type: 'NetworkController:updateNetwork';
+  handler: NetworkController['updateNetwork'];
+};
+
+export type NetworkControllerDangerouslySetNetworkConfigurationAction = {
+  type: 'NetworkController:dangerouslySetNetworkConfiguration';
+  handler: (networkConfiguration: NetworkConfiguration) => Promise<void>;
+};
+
 export type NetworkControllerActions =
   | NetworkControllerGetStateAction
   | NetworkControllerGetEthQueryAction
@@ -483,7 +521,11 @@ export type NetworkControllerActions =
   | NetworkControllerSetActiveNetworkAction
   | NetworkControllerSetProviderTypeAction
   | NetworkControllerGetNetworkConfigurationByChainId
-  | NetworkControllerGetNetworkConfigurationByNetworkClientId;
+  | NetworkControllerGetNetworkConfigurationByNetworkClientId
+  | NetworkControllerAddNetworkAction
+  | NetworkControllerRemoveNetworkAction
+  | NetworkControllerUpdateNetworkAction
+  | NetworkControllerDangerouslySetNetworkConfigurationAction;
 
 export type NetworkControllerMessenger = RestrictedControllerMessenger<
   typeof controllerName,
@@ -954,6 +996,34 @@ export class NetworkController extends BaseController<
       `${this.name}:getSelectedNetworkClient`,
       this.getSelectedNetworkClient.bind(this),
     );
+
+    this.messagingSystem.registerActionHandler(
+      // ESLint is mistaken here; `name` is a string.
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `${this.name}:addNetwork`,
+      this.addNetwork.bind(this),
+    );
+
+    this.messagingSystem.registerActionHandler(
+      // ESLint is mistaken here; `name` is a string.
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `${this.name}:removeNetwork`,
+      this.removeNetwork.bind(this),
+    );
+
+    this.messagingSystem.registerActionHandler(
+      // ESLint is mistaken here; `name` is a string.
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `${this.name}:updateNetwork`,
+      this.updateNetwork.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 +1627,8 @@ export class NetworkController extends BaseController<
           defaultOrCustomRpcEndpointFields.type === RpcEndpointType.Custom
             ? {
                 ...defaultOrCustomRpcEndpointFields,
-                networkClientId: uuidV4(),
+                networkClientId:
+                  defaultOrCustomRpcEndpointFields.networkClientId ?? uuidV4(),
               }
             : defaultOrCustomRpcEndpointFields;
         return {
@@ -1939,6 +2010,134 @@ export class NetworkController extends BaseController<
       buildNetworkConfigurationsByNetworkClientId(
         this.state.networkConfigurationsByChainId,
       );
+
+    this.messagingSystem.publish(
+      'NetworkController:networkRemoved',
+      existingNetworkConfiguration,
+    );
+  }
+
+  /**
+   * 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();
   }
 
   /**
@@ -2438,6 +2637,13 @@ export class NetworkController extends BaseController<
     }
 
     if (mode === 'add' || mode === 'update') {
+      if (
+        JSON.stringify(
+          state.networkConfigurationsByChainId[args.networkFields.chainId],
+        ) !== JSON.stringify(args.networkConfigurationToPersist)
+      ) {
+        args.networkConfigurationToPersist.lastUpdatedAt = Date.now();
+      }
       state.networkConfigurationsByChainId[args.networkFields.chainId] =
         args.networkConfigurationToPersist;
     }

packages/network-controller/src/index.ts

@@ -17,6 +17,8 @@ export type {
   NetworkControllerNetworkDidChangeEvent,
   NetworkControllerInfuraIsBlockedEvent,
   NetworkControllerInfuraIsUnblockedEvent,
+  NetworkControllerNetworkAddedEvent,
+  NetworkControllerNetworkRemovedEvent,
   NetworkControllerEvents,
   NetworkControllerGetStateAction,
   NetworkControllerGetEthQueryAction,
@@ -26,6 +28,10 @@ export type {
   NetworkControllerFindNetworkClientIdByChainIdAction,
   NetworkControllerSetProviderTypeAction,
   NetworkControllerSetActiveNetworkAction,
+  NetworkControllerAddNetworkAction,
+  NetworkControllerRemoveNetworkAction,
+  NetworkControllerUpdateNetworkAction,
+  NetworkControllerDangerouslySetNetworkConfigurationAction,
   NetworkControllerGetNetworkConfigurationByNetworkClientId,
   NetworkControllerActions,
   NetworkControllerMessenger,