Temp/network syncing all changes

packages/network-controller/src/NetworkController.ts

@@ -34,6 +34,7 @@
   ProxyWithAccessibleTarget,
 } from './create-auto-managed-network-client';
 import { createAutoManagedNetworkClient } from './create-auto-managed-network-client';
+import { lastUpdatedNetworkConfiguration } from './last-updated-at-network-configuration';
 import { projectLogger, createModuleLogger } from './logger';
 import { NetworkClientType } from './types';
 import type {
@@ -203,6 +204,11 @@
    * 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 +218,11 @@
  * 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,
+ * can use the same `networkClientId` set on both devices.
  */
-export type AddNetworkCustomRpcEndpointFields = Omit<
+export type AddNetworkCustomRpcEndpointFields = Partialize<
   CustomRpcEndpoint,
   'networkClientId'
 >;
@@ -409,13 +418,33 @@
   payload: [networkConfiguration: NetworkConfiguration];
 };
 
+/**
+ * `networkUpdated` is published after a network configuration is updated in the
+ * network configuration registry and network clients are created as needed.
+ */
+export type NetworkControllerNetworkUpdatedEvent = {
+  type: 'NetworkController:networkUpdated';
+  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
+  | NetworkControllerNetworkUpdatedEvent
+  | NetworkControllerNetworkRemovedEvent;
 
 export type NetworkControllerGetStateAction = ControllerGetStateAction<
   typeof controllerName,
@@ -473,6 +502,26 @@
   handler: NetworkController['getNetworkConfigurationByNetworkClientId'];
 };
 
+export type NetworkControllerAddNetworkAction = {
+  type: 'NetworkController:addNetwork';
+  handler: NetworkController['addNetwork'];
+};
+
+export type NetworkControllerUpdateNetworkAction = {
+  type: 'NetworkController:updateNetwork';
+  handler: NetworkController['updateNetwork'];
+};
+
+export type NetworkControllerRemoveNetworkAction = {
+  type: 'NetworkController:removeNetwork';
+  handler: NetworkController['removeNetwork'];
+};
+
+export type NetworkControllerDangerouslySetNetworkConfigurationAction = {
+  type: 'NetworkController:dangerouslySetNetworkConfiguration';
+  handler: NetworkController['dangerouslySetNetworkConfiguration'];
+};
+
 export type NetworkControllerActions =
   | NetworkControllerGetStateAction
   | NetworkControllerGetEthQueryAction
@@ -483,7 +532,11 @@
   | NetworkControllerSetActiveNetworkAction
   | NetworkControllerSetProviderTypeAction
   | NetworkControllerGetNetworkConfigurationByChainId
-  | NetworkControllerGetNetworkConfigurationByNetworkClientId;
+  | NetworkControllerGetNetworkConfigurationByNetworkClientId
+  | NetworkControllerAddNetworkAction
+  | NetworkControllerUpdateNetworkAction
+  | NetworkControllerRemoveNetworkAction
+  | NetworkControllerDangerouslySetNetworkConfigurationAction;
 
 export type NetworkControllerMessenger = RestrictedControllerMessenger<
   typeof controllerName,
@@ -954,6 +1007,32 @@
       `${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}:updateNetwork`,
+      this.updateNetwork.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(
+      `${this.name}:dangerouslySetNetworkConfiguration`,
+      this.dangerouslySetNetworkConfiguration.bind(this),
+    );
   }
 
   /**
@@ -1557,7 +1636,8 @@
           defaultOrCustomRpcEndpointFields.type === RpcEndpointType.Custom
             ? {
                 ...defaultOrCustomRpcEndpointFields,
-                networkClientId: uuidV4(),
+                networkClientId:
+                  defaultOrCustomRpcEndpointFields.networkClientId ?? uuidV4(),
               }
             : defaultOrCustomRpcEndpointFields;
         return {
@@ -1881,6 +1961,11 @@
       autoManagedNetworkClientRegistry,
     });
 
+    this.messagingSystem.publish(
+      'NetworkController:networkUpdated',
+      updatedNetworkConfiguration,
+    );
+
     return updatedNetworkConfiguration;
   }
 
@@ -1939,6 +2024,110 @@
       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;
+
+    // Update Registry (remove old and add new)
+    const autoManagedNetworkClientRegistry =
+      this.#ensureAutoManagedNetworkClientRegistryPopulated();
+    if (prevNetworkConfig) {
+      const networkClientOperations = prevNetworkConfig.rpcEndpoints.map(
+        (rpcEndpoint) => {
+          return {
+            type: 'remove' as const,
+            rpcEndpoint,
+          };
+        },
+      );
+      this.#unregisterNetworkClientsAsNeeded({
+        networkClientOperations,
+        autoManagedNetworkClientRegistry,
+      });
+    }
+    const networkClientOperations = networkConfiguration.rpcEndpoints.map(
+      (rpcEndpoint) => {
+        return {
+          type: 'add' as const,
+          rpcEndpoint,
+        };
+      },
+    );
+    this.#registerNetworkClientsAsNeeded({
+      networkFields: networkConfiguration,
+      networkClientOperations,
+      autoManagedNetworkClientRegistry,
+    });
+
+    // update new `networkConfigurationsByChainId` (full replace)
+    this.update((state) => {
+      state.networkConfigurationsByChainId[networkConfiguration.chainId] =
+        networkConfiguration;
+    });
+    this.#networkConfigurationsByNetworkClientId =
+      buildNetworkConfigurationsByNetworkClientId(
+        this.state.networkConfigurationsByChainId,
+      );
+
+    // update `networksMetadata` remove old
+    if (prevNetworkConfig) {
+      this.update((state) => {
+        const newNetworksMetadata: NetworksMetadata = {
+          ...state.networksMetadata,
+        };
+        prevNetworkConfig.rpcEndpoints.forEach((rpcEndpoint) => {
+          delete newNetworksMetadata[rpcEndpoint.networkClientId];
+        });
+      });
+    }
+
+    // update `networksMetadata` update new
+    for (const rpcEndpoint of networkConfiguration.rpcEndpoints) {
+      await this.lookupNetwork(rpcEndpoint.networkClientId);
+    }
+
+    // update selectedNetworkId
+    const selectedClientId = this.state.selectedNetworkClientId;
+    const wasReplacedClientId = prevNetworkConfig?.rpcEndpoints.some(
+      (r) => r.networkClientId === selectedClientId,
+    );
+    const isValidClientIdInNewNetworks = networkConfiguration.rpcEndpoints.some(
+      (r) => r.networkClientId === selectedClientId,
+    );
+    if (wasReplacedClientId) {
+      if (!isValidClientIdInNewNetworks) {
+        // Update clientId to something that exists
+        const newSelectedNetworkMetadata =
+          networkConfiguration.rpcEndpoints.find(
+            (r) => r.networkClientId in this.state.networksMetadata,
+          )?.networkClientId;
+        const anyClientId = Object.keys(this.state.networksMetadata)[0];
+        const newlySelectedNetwork =
+          newSelectedNetworkMetadata ?? anyClientId ?? selectedClientId;
+        await this.#refreshNetwork(newlySelectedNetwork);
+      }
+    }
   }
 
   /**
@@ -2438,6 +2627,7 @@
     }
 
     if (mode === 'add' || mode === 'update') {
+      lastUpdatedNetworkConfiguration(args.networkConfigurationToPersist);
       state.networkConfigurationsByChainId[args.networkFields.chainId] =
         args.networkConfigurationToPersist;
     }

packages/network-controller/src/index.ts

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

packages/network-controller/src/last-updated-at-network-configuration.ts

@@ -0,0 +1,16 @@
+import type { NetworkConfiguration } from './NetworkController';
+
+/**
+ * Adds or updates the NetworkConfiguration `lastUpdatedAt` property.
+ * Keeping this property updated on network changes allows us to compare remote vs local NetworkConfiguration
+ * for network syncing.
+ *
+ * @param configuration - NetworkConfiguration that is being updated
+ * @returns the NetworkConfiguration with the lastUpdatedAt property updated.
+ */
+export function lastUpdatedNetworkConfiguration(
+  configuration: NetworkConfiguration,
+) {
+  configuration.lastUpdatedAt = Date.now();
+  return configuration;
+}

packages/network-controller/tests/NetworkController.test.ts

@@ -25,6 +25,7 @@ import { NetworkStatus } from '../src/constants';
 import * as createAutoManagedNetworkClientModule from '../src/create-auto-managed-network-client';
 import type { NetworkClient } from '../src/create-network-client';
 import { createNetworkClient } from '../src/create-network-client';
+import * as LastUpdatedAtNetworkConfigurationModule from '../src/last-updated-at-network-configuration';
 import type {
   AutoManagedBuiltInNetworkClientRegistry,
   AutoManagedCustomNetworkClientRegistry,
@@ -139,6 +140,13 @@ describe('NetworkController', () => {
       uuidCounter += 1;
       return uuid;
     });
+
+    jest
+      .spyOn(
+        LastUpdatedAtNetworkConfigurationModule,
+        'lastUpdatedNetworkConfiguration',
+      )
+      .mockImplementation((n) => n);
   });
 
   afterEach(() => {

packages/network-controller/tests/last-updated-at-network-configuration.test.ts

@@ -0,0 +1,12 @@
+import { lastUpdatedNetworkConfiguration } from '../src/last-updated-at-network-configuration';
+import { buildCustomNetworkConfiguration } from './helpers';
+
+describe('lastUpdatedNetworkConfiguration() tests', () => {
+  it('adds a timestamp (ms) to the network configuration', () => {
+    const configuration = buildCustomNetworkConfiguration();
+
+    expect(configuration.lastUpdatedAt).toBeUndefined();
+    lastUpdatedNetworkConfiguration(configuration);
+    expect(configuration.lastUpdatedAt).toBeDefined();
+  });
+});

packages/profile-sync-controller/src/controllers/user-storage/UserStorageController.test.ts

@@ -39,6 +39,14 @@ import type {
 } from './UserStorageController';
 import UserStorageController from './UserStorageController';
 
+// Creates the correct typed call params for mocks
+type CallParams = {
+  [K in AllowedActions['type']]: [
+    K,
+    ...Parameters<Extract<AllowedActions, { type: K }>['handler']>,
+  ];
+}[AllowedActions['type']];
+
 const typedMockFn = <Func extends (...args: unknown[]) => unknown>() =>
   jest.fn<ReturnType<Func>, Parameters<Func>>();
 
@@ -1730,14 +1738,6 @@ function mockUserStorageMessenger(options?: {
   const mockAccountsUpdateAccountMetadata = jest.fn().mockResolvedValue(true);
 
   jest.spyOn(messenger, 'call').mockImplementation((...args) => {
-    // Creates the correct typed call params for mocks
-    type CallParams = {
-      [K in AllowedActions['type']]: [
-        K,
-        ...Parameters<Extract<AllowedActions, { type: K }>['handler']>,
-      ];
-    }[AllowedActions['type']];
-
     const [actionType, params] = args as unknown as CallParams;
 
     if (actionType === 'SnapController:handleRequest') {