@metamask-previews/network-controller 36.0.0-preview-c61613ed2 → 36.0.0-preview-3866c0ff1

package/dist/{NetworkController.mjs → NetworkController.js}

@@ -1,43 +1,22 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _NetworkController_instances, _NetworkController_ethQuery, _NetworkController_infuraProjectId, _NetworkController_failoverUrls, _NetworkController_previouslySelectedNetworkClientId, _NetworkController_providerProxy, _NetworkController_blockTrackerProxy, _NetworkController_autoManagedNetworkClientRegistry, _NetworkController_autoManagedNetworkClient, _NetworkController_log, _NetworkController_getRpcServiceOptions, _NetworkController_getBlockTrackerOptions, _NetworkController_analyticsOptions, _NetworkController_networkConfigurationsByNetworkClientId, _NetworkController_rpcFailoverMode, _NetworkController_updateRpcFailover, _NetworkController_refreshNetwork, _NetworkController_determineNetworkMetadata, _NetworkController_lookupGivenNetwork, _NetworkController_lookupSelectedNetwork, _NetworkController_updateMetadataForNetwork, _NetworkController_getLatestBlock, _NetworkController_determineEIP1559Compatibility, _NetworkController_validateNetworkFields, _NetworkController_determineNetworkConfigurationToPersist, _NetworkController_registerNetworkClientsAsNeeded, _NetworkController_unregisterNetworkClientsAsNeeded, _NetworkController_updateNetworkConfigurations, _NetworkController_ensureAutoManagedNetworkClientRegistryPopulated, _NetworkController_createAutoManagedNetworkClientRegistry, _NetworkController_applyNetworkSelection, _NetworkController_autoAddNetworksFromConfigRegistry;
-function $importDefault(module) {
-    if (module?.__esModule) {
-        return module.default;
-    }
-    return module;
-}
-import { BaseController } from "@metamask/base-controller";
-import { selectEvmAutoEnabledNetworksChainIds } from "@metamask/config-registry-controller";
-import { InfuraNetworkType, CustomNetworkType, NetworkType, isSafeChainId, isInfuraNetworkType, ChainId, NetworksTicker, NetworkNickname, BUILT_IN_CUSTOM_NETWORKS_RPC, BUILT_IN_NETWORKS, DEFAULT_INFURA_NETWORKS } from "@metamask/controller-utils";
-import $EthQuery from "@metamask/eth-query";
-const EthQuery = $importDefault($EthQuery);
-import { errorCodes } from "@metamask/rpc-errors";
-import { createEventEmitterProxy, createSwappableProxy } from "@metamask/swappable-obj-proxy";
-import { hasProperty, isPlainObject, isStrictHexString, numberToHex, parseCaipChainId } from "@metamask/utils";
-import $deepEqual from "fast-deep-equal";
-const deepEqual = $importDefault($deepEqual);
-import { produce } from "immer";
-import $lodash from "lodash";
-const { cloneDeep } = $lodash;
-import { createSelector } from "reselect";
-import * as URI from "uri-js";
-import { v4 as uuidV4 } from "uuid";
-import { DEPRECATED_NETWORKS, INFURA_BLOCKED_KEY, NetworkStatus } from "./constants.mjs";
-import { createAutoManagedNetworkClient } from "./create-auto-managed-network-client.mjs";
-import { projectLogger, createModuleLogger } from "./logger.mjs";
-import { trackRpcServiceDegraded, trackRpcServiceUnavailable } from "./rpc-service-analytics.mjs";
-import { getRpcFailoverMode } from "./selectors.mjs";
-import { NetworkClientType } from "./types.mjs";
+import { BaseController } from '@metamask/base-controller';
+import { selectEvmAutoEnabledNetworksChainIds } from '@metamask/config-registry-controller';
+import { InfuraNetworkType, CustomNetworkType, NetworkType, isSafeChainId, isInfuraNetworkType, ChainId, NetworksTicker, NetworkNickname, BUILT_IN_CUSTOM_NETWORKS_RPC, BUILT_IN_NETWORKS, DEFAULT_INFURA_NETWORKS, } from '@metamask/controller-utils';
+import EthQuery from '@metamask/eth-query';
+import { errorCodes } from '@metamask/rpc-errors';
+import { createEventEmitterProxy, createSwappableProxy, } from '@metamask/swappable-obj-proxy';
+import { hasProperty, isPlainObject, isStrictHexString, numberToHex, parseCaipChainId, } from '@metamask/utils';
+import deepEqual from 'fast-deep-equal';
+import { produce } from 'immer';
+import { cloneDeep } from 'lodash-es';
+import { createSelector } from 'reselect';
+import * as URI from 'uri-js';
+import { v4 as uuidV4 } from 'uuid';
+import { DEPRECATED_NETWORKS, INFURA_BLOCKED_KEY, NetworkStatus, } from './constants.js';
+import { createAutoManagedNetworkClient } from './create-auto-managed-network-client.js';
+import { projectLogger, createModuleLogger } from './logger.js';
+import { trackRpcServiceDegraded, trackRpcServiceUnavailable, } from './rpc-service-analytics.js';
+import { getRpcFailoverMode } from './selectors.js';
+import { NetworkClientType } from './types.js';
 const debugLog = createModuleLogger(projectLogger, 'NetworkController');
 const INFURA_URL_REGEX = /^https:\/\/(?<networkName>[^.]+)\.infura\.io\/v\d+\/(?<apiKey>.+)$/u;
 /**
@@ -359,6 +338,20 @@ function buildNetworkConfigurationsByNetworkClientId(networkConfigurationsByChai
  * Controller that creates and manages an Ethereum network provider.
  */
 export class NetworkController extends BaseController {
+    #ethQuery;
+    #infuraProjectId;
+    #failoverUrls;
+    #previouslySelectedNetworkClientId;
+    #providerProxy;
+    #blockTrackerProxy;
+    #autoManagedNetworkClientRegistry;
+    #autoManagedNetworkClient;
+    #log;
+    #getRpcServiceOptions;
+    #getBlockTrackerOptions;
+    #analyticsOptions;
+    #networkConfigurationsByNetworkClientId;
+    #rpcFailoverMode = 'disabled';
     /**
      * Constructs a NetworkController.
      *
@@ -400,57 +393,44 @@ export class NetworkController extends BaseController {
             messenger,
             state: correctedInitialState,
         });
-        _NetworkController_instances.add(this);
-        _NetworkController_ethQuery.set(this, void 0);
-        _NetworkController_infuraProjectId.set(this, void 0);
-        _NetworkController_failoverUrls.set(this, void 0);
-        _NetworkController_previouslySelectedNetworkClientId.set(this, void 0);
-        _NetworkController_providerProxy.set(this, void 0);
-        _NetworkController_blockTrackerProxy.set(this, void 0);
-        _NetworkController_autoManagedNetworkClientRegistry.set(this, void 0);
-        _NetworkController_autoManagedNetworkClient.set(this, void 0);
-        _NetworkController_log.set(this, void 0);
-        _NetworkController_getRpcServiceOptions.set(this, void 0);
-        _NetworkController_getBlockTrackerOptions.set(this, void 0);
-        _NetworkController_analyticsOptions.set(this, void 0);
-        _NetworkController_networkConfigurationsByNetworkClientId.set(this, void 0);
-        _NetworkController_rpcFailoverMode.set(this, 'disabled');
-        __classPrivateFieldSet(this, _NetworkController_infuraProjectId, infuraProjectId, "f");
-        __classPrivateFieldSet(this, _NetworkController_failoverUrls, failoverUrls, "f");
-        __classPrivateFieldSet(this, _NetworkController_log, log, "f");
-        __classPrivateFieldSet(this, _NetworkController_getRpcServiceOptions, getRpcServiceOptions, "f");
-        __classPrivateFieldSet(this, _NetworkController_getBlockTrackerOptions, getBlockTrackerOptions, "f");
-        __classPrivateFieldSet(this, _NetworkController_analyticsOptions, {
+        this.#infuraProjectId = infuraProjectId;
+        this.#failoverUrls = failoverUrls;
+        this.#log = log;
+        this.#getRpcServiceOptions = getRpcServiceOptions;
+        this.#getBlockTrackerOptions = getBlockTrackerOptions;
+        this.#analyticsOptions = {
             isRpcEndpointUrlPublic: () => false,
             rpcServiceEventsSampleRate: 0,
             ...analyticsOptions,
-        }, "f");
-        __classPrivateFieldSet(this, _NetworkController_previouslySelectedNetworkClientId, this.state.selectedNetworkClientId, "f");
-        __classPrivateFieldSet(this, _NetworkController_networkConfigurationsByNetworkClientId, buildNetworkConfigurationsByNetworkClientId(this.state.networkConfigurationsByChainId), "f");
+        };
+        this.#previouslySelectedNetworkClientId =
+            this.state.selectedNetworkClientId;
+        this.#networkConfigurationsByNetworkClientId =
+            buildNetworkConfigurationsByNetworkClientId(this.state.networkConfigurationsByChainId);
         this.messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
         this.messenger.subscribe(`${this.name}:rpcEndpointChainUnavailable`, ({ networkClientId }) => {
-            __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_updateMetadataForNetwork).call(this, networkClientId, {
+            this.#updateMetadataForNetwork(networkClientId, {
                 networkStatus: NetworkStatus.Unavailable,
             });
         });
         this.messenger.subscribe(`${this.name}:rpcEndpointChainDegraded`, ({ networkClientId }) => {
-            __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_updateMetadataForNetwork).call(this, networkClientId, {
+            this.#updateMetadataForNetwork(networkClientId, {
                 networkStatus: NetworkStatus.Degraded,
             });
         });
         this.messenger.subscribe(`${this.name}:rpcEndpointChainAvailable`, ({ networkClientId }) => {
-            __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_updateMetadataForNetwork).call(this, networkClientId, {
+            this.#updateMetadataForNetwork(networkClientId, {
                 networkStatus: NetworkStatus.Available,
             });
         });
-        this.messenger.subscribe(`${this.name}:rpcEndpointUnavailable`, (payload) => trackRpcServiceUnavailable(this.messenger, __classPrivateFieldGet(this, _NetworkController_analyticsOptions, "f"), payload));
-        this.messenger.subscribe(`${this.name}:rpcEndpointDegraded`, (payload) => trackRpcServiceDegraded(this.messenger, __classPrivateFieldGet(this, _NetworkController_analyticsOptions, "f"), payload));
+        this.messenger.subscribe(`${this.name}:rpcEndpointUnavailable`, (payload) => trackRpcServiceUnavailable(this.messenger, this.#analyticsOptions, payload));
+        this.messenger.subscribe(`${this.name}:rpcEndpointDegraded`, (payload) => trackRpcServiceDegraded(this.messenger, this.#analyticsOptions, payload));
         this.messenger.subscribe(
         // eslint-disable-next-line no-restricted-syntax
         'RemoteFeatureFlagController:stateChange', (rpcFailoverMode) => {
-            __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_updateRpcFailover).call(this, rpcFailoverMode);
+            this.#updateRpcFailover(rpcFailoverMode);
         }, getRpcFailoverMode);
-        this.messenger.subscribe('ConfigRegistryController:stateChanged', (caipChainIds) => __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_autoAddNetworksFromConfigRegistry).call(this, caipChainIds), selectEvmAutoEnabledNetworksChainIds);
+        this.messenger.subscribe('ConfigRegistryController:stateChanged', (caipChainIds) => this.#autoAddNetworksFromConfigRegistry(caipChainIds), selectEvmAutoEnabledNetworksChainIds);
     }
     /**
      * Returns the EthQuery instance for the currently selected network.
@@ -459,7 +439,31 @@ export class NetworkController extends BaseController {
      * initialized.
      */
     getEthQuery() {
-        return __classPrivateFieldGet(this, _NetworkController_ethQuery, "f");
+        return this.#ethQuery;
+    }
+    /**
+     * Applies the given RPC failover mode by reconstructing all network clients
+     * that were configured with failover URLs so that the new mode takes effect.
+     * Network client IDs are preserved so as not to invalidate state in other
+     * controllers.
+     *
+     * @param newMode - The RPC failover mode to apply.
+     */
+    #updateRpcFailover(newMode) {
+        if (this.#rpcFailoverMode === newMode) {
+            return;
+        }
+        const autoManagedNetworkClientRegistry = this.#ensureAutoManagedNetworkClientRegistryPopulated();
+        for (const networkClientsById of Object.values(autoManagedNetworkClientRegistry)) {
+            for (const networkClientId of Object.keys(networkClientsById)) {
+                const networkClient = networkClientsById[networkClientId];
+                if (networkClient.configuration.failoverRpcUrls &&
+                    networkClient.configuration.failoverRpcUrls.length > 0) {
+                    networkClient.setRpcFailoverMode(newMode);
+                }
+            }
+        }
+        this.#rpcFailoverMode = newMode;
     }
     /**
      * Accesses the provider and block tracker for the currently selected network.
@@ -469,8 +473,8 @@ export class NetworkController extends BaseController {
      */
     getProviderAndBlockTracker() {
         return {
-            provider: __classPrivateFieldGet(this, _NetworkController_providerProxy, "f"),
-            blockTracker: __classPrivateFieldGet(this, _NetworkController_blockTrackerProxy, "f"),
+            provider: this.#providerProxy,
+            blockTracker: this.#blockTrackerProxy,
         };
     }
     /**
@@ -479,10 +483,10 @@ export class NetworkController extends BaseController {
      * @returns an object with the provider and block tracker proxies for the currently selected network.
      */
     getSelectedNetworkClient() {
-        if (__classPrivateFieldGet(this, _NetworkController_providerProxy, "f") && __classPrivateFieldGet(this, _NetworkController_blockTrackerProxy, "f")) {
+        if (this.#providerProxy && this.#blockTrackerProxy) {
             return {
-                provider: __classPrivateFieldGet(this, _NetworkController_providerProxy, "f"),
-                blockTracker: __classPrivateFieldGet(this, _NetworkController_blockTrackerProxy, "f"),
+                provider: this.#providerProxy,
+                blockTracker: this.#blockTrackerProxy,
             };
         }
         return undefined;
@@ -506,14 +510,14 @@ export class NetworkController extends BaseController {
      * @returns The network clients registered so far, keyed by ID.
      */
     getNetworkClientRegistry() {
-        const autoManagedNetworkClientRegistry = __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_ensureAutoManagedNetworkClientRegistryPopulated).call(this);
+        const autoManagedNetworkClientRegistry = this.#ensureAutoManagedNetworkClientRegistryPopulated();
         return Object.assign({}, autoManagedNetworkClientRegistry[NetworkClientType.Infura], autoManagedNetworkClientRegistry[NetworkClientType.Custom]);
     }
     getNetworkClientById(networkClientId) {
         if (!networkClientId) {
             throw new Error('No network client ID was provided.');
         }
-        const autoManagedNetworkClientRegistry = __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_ensureAutoManagedNetworkClientRegistryPopulated).call(this);
+        const autoManagedNetworkClientRegistry = this.#ensureAutoManagedNetworkClientRegistryPopulated();
         const infuraNetworkClient = autoManagedNetworkClientRegistry[NetworkClientType.Infura][networkClientId];
         if (infuraNetworkClient) {
             return infuraNetworkClient;
@@ -524,6 +528,30 @@ export class NetworkController extends BaseController {
         }
         return customNetworkClient;
     }
+    /**
+     * Executes a series of steps to switch the network:
+     *
+     * 1. Notifies subscribers via the messenger that the network is about to be
+     * switched (and, really, that the global provider and block tracker proxies
+     * will be re-pointed to a new network).
+     * 2. Looks up a known and preinitialized network client matching the given
+     * ID and uses it to re-point the aforementioned provider and block tracker
+     * proxies.
+     * 3. Notifies subscribers via the messenger that the network has switched.
+     * 4. Captures metadata for the newly switched network in state.
+     *
+     * @param networkClientId - The ID of a network client that requests will be
+     * routed through (either the name of an Infura network or the ID of a custom
+     * network configuration).
+     * @param options - Options for this method.
+     * @param options.updateState - Allows for updating state.
+     */
+    async #refreshNetwork(networkClientId, options = {}) {
+        this.messenger.publish('NetworkController:networkWillChange', this.state);
+        this.#applyNetworkSelection(networkClientId, options);
+        this.messenger.publish('NetworkController:networkDidChange', this.state);
+        await this.lookupNetwork();
+    }
     /**
      * Initialize the NetworkController:
      *   - Apply the RPC failover mode from the `corePlatformRpcFailoverMode` remote feature flag;
@@ -532,9 +560,68 @@ export class NetworkController extends BaseController {
      */
     init() {
         const state = this.messenger.call('RemoteFeatureFlagController:getState');
-        __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_updateRpcFailover).call(this, getRpcFailoverMode(state));
-        __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_applyNetworkSelection).call(this, this.state.selectedNetworkClientId);
-        __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_autoAddNetworksFromConfigRegistry).call(this, selectEvmAutoEnabledNetworksChainIds(this.messenger.call('ConfigRegistryController:getState')));
+        this.#updateRpcFailover(getRpcFailoverMode(state));
+        this.#applyNetworkSelection(this.state.selectedNetworkClientId);
+        this.#autoAddNetworksFromConfigRegistry(selectEvmAutoEnabledNetworksChainIds(this.messenger.call('ConfigRegistryController:getState')));
+    }
+    /**
+     * Uses a request for the latest block to gather the following information on
+     * the given network:
+     *
+     * - The connectivity status: whether it is available, geo-blocked (Infura
+     * only), unavailable, or unknown
+     * - The capabilities status: whether it supports EIP-1559, whether it does
+     * not, or whether it is unknown
+     *
+     * @param networkClientId - The ID of the network client to inspect.
+     * If no ID is provided, uses the currently selected network.
+     * @returns The resulting metadata for the network.
+     */
+    async #determineNetworkMetadata(networkClientId) {
+        const networkClient = this.getNetworkClientById(networkClientId);
+        const isInfura = networkClient.configuration.type === NetworkClientType.Infura;
+        let networkStatus;
+        let isEIP1559Compatible;
+        try {
+            isEIP1559Compatible =
+                await this.#determineEIP1559Compatibility(networkClientId);
+            networkStatus = NetworkStatus.Available;
+        }
+        catch (error) {
+            debugLog('NetworkController: lookupNetwork: ', error);
+            if (isErrorWithCode(error)) {
+                let responseBody;
+                if (isInfura &&
+                    hasProperty(error, 'message') &&
+                    typeof error.message === 'string') {
+                    try {
+                        responseBody = JSON.parse(error.message);
+                    }
+                    catch {
+                        // error.message must not be JSON
+                        this.#log?.warn('NetworkController: lookupNetwork: json parse error: ', error);
+                    }
+                }
+                if (isPlainObject(responseBody) &&
+                    responseBody.error === INFURA_BLOCKED_KEY) {
+                    networkStatus = NetworkStatus.Blocked;
+                }
+                else if (error.code === errorCodes.rpc.internal) {
+                    networkStatus = NetworkStatus.Unknown;
+                    this.#log?.warn('NetworkController: lookupNetwork: rpc internal error: ', error);
+                }
+                else {
+                    networkStatus = NetworkStatus.Unavailable;
+                    this.#log?.warn('NetworkController: lookupNetwork: ', error);
+                }
+            }
+            else {
+                debugLog('NetworkController - could not determine network status', error);
+                networkStatus = NetworkStatus.Unknown;
+                this.#log?.warn('NetworkController: lookupNetwork: ', error);
+            }
+        }
+        return { isInfura, networkStatus, isEIP1559Compatible };
     }
     /**
      * Uses a request for the latest block to gather the following information on
@@ -550,10 +637,10 @@ export class NetworkController extends BaseController {
      */
     async lookupNetwork(networkClientId) {
         if (networkClientId) {
-            await __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_lookupGivenNetwork).call(this, networkClientId);
+            await this.#lookupGivenNetwork(networkClientId);
         }
         else {
-            await __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_lookupSelectedNetwork).call(this);
+            await this.#lookupSelectedNetwork();
         }
     }
     /**
@@ -573,7 +660,129 @@ export class NetworkController extends BaseController {
     // right now.
     /* istanbul ignore next */
     async lookupNetworkByClientId(networkClientId) {
-        await __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_lookupGivenNetwork).call(this, networkClientId);
+        await this.#lookupGivenNetwork(networkClientId);
+    }
+    /**
+     * Uses a request for the latest block to gather the following information on
+     * the given network, persisting it to state:
+     *
+     * - The connectivity status: whether the network is available, geo-blocked
+     * (Infura only), unavailable, or unknown
+     * - The feature compatibility status: whether the network supports EIP-1559,
+     * whether it does not, or whether it is unknown
+     *
+     * @param networkClientId - The ID of the network client to inspect.
+     */
+    async #lookupGivenNetwork(networkClientId) {
+        const { networkStatus, isEIP1559Compatible } = await this.#determineNetworkMetadata(networkClientId);
+        this.#updateMetadataForNetwork(networkClientId, {
+            networkStatus,
+            isEIP1559Compatible,
+        });
+    }
+    /**
+     * Uses a request for the latest block to gather the following information on
+     * the currently selected network, persisting it to state:
+     *
+     * - The connectivity status: whether the network is available, geo-blocked
+     * (Infura only), unavailable, or unknown
+     * - The feature compatibility status: whether the network supports EIP-1559,
+     * whether it does not, or whether it is unknown
+     *
+     * Note that it is possible for the current network to be switched while this
+     * method is running. If that is the case, it will exit early (as this method
+     * will also run for the new network).
+     */
+    async #lookupSelectedNetwork() {
+        if (!this.#ethQuery) {
+            return;
+        }
+        let networkChanged = false;
+        const listener = () => {
+            networkChanged = true;
+            try {
+                this.messenger.unsubscribe('NetworkController:networkDidChange', listener);
+            }
+            catch (error) {
+                // In theory, this `catch` should not be necessary given that this error
+                // would occur "inside" of the call to `#determineEIP1559Compatibility`
+                // below and so it should be caught by the `try`/`catch` below (it is
+                // impossible to reproduce in tests for that reason). However, somehow
+                // it occurs within Mobile and so we have to add our own `try`/`catch`
+                // here.
+                /* istanbul ignore next */
+                if (!(error instanceof Error) ||
+                    error.message !==
+                        'Subscription not found for event: NetworkController:networkDidChange') {
+                    // Again, this error should not happen and is impossible to reproduce
+                    // in tests.
+                    /* istanbul ignore next */
+                    throw error;
+                }
+            }
+        };
+        this.messenger.subscribe('NetworkController:networkDidChange', listener);
+        const { isInfura, networkStatus, isEIP1559Compatible } = await this.#determineNetworkMetadata(this.state.selectedNetworkClientId);
+        if (networkChanged) {
+            // If the network has changed, then `lookupNetwork` either has been or is
+            // in the process of being called, so we don't need to go further.
+            return;
+        }
+        try {
+            this.messenger.unsubscribe('NetworkController:networkDidChange', listener);
+        }
+        catch (error) {
+            if (!(error instanceof Error) ||
+                error.message !==
+                    'Subscription not found for event: NetworkController:networkDidChange') {
+                throw error;
+            }
+        }
+        this.#updateMetadataForNetwork(this.state.selectedNetworkClientId, {
+            networkStatus,
+            isEIP1559Compatible,
+        });
+        if (isInfura) {
+            if (networkStatus === NetworkStatus.Available) {
+                this.messenger.publish('NetworkController:infuraIsUnblocked');
+            }
+            else if (networkStatus === NetworkStatus.Blocked) {
+                this.messenger.publish('NetworkController:infuraIsBlocked');
+            }
+        }
+        else {
+            // Always publish infuraIsUnblocked regardless of network status to
+            // prevent consumers from being stuck in a blocked state if they were
+            // previously connected to an Infura network that was blocked
+            this.messenger.publish('NetworkController:infuraIsUnblocked');
+        }
+    }
+    /**
+     * Updates the metadata for the given network in state.
+     *
+     * @param networkClientId - The associated network client ID.
+     * @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, metadata) {
+        this.update((state) => {
+            state.networksMetadata[networkClientId] ??= {
+                status: NetworkStatus.Unknown,
+                EIPS: {},
+            };
+            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;
+                }
+            }
+        });
     }
     /**
      * Convenience method to update provider network type settings.
@@ -602,8 +811,33 @@ export class NetworkController extends BaseController {
      * network client ID.
      */
     async setActiveNetwork(networkClientId, options = {}) {
-        __classPrivateFieldSet(this, _NetworkController_previouslySelectedNetworkClientId, this.state.selectedNetworkClientId, "f");
-        await __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_refreshNetwork).call(this, networkClientId, options);
+        this.#previouslySelectedNetworkClientId =
+            this.state.selectedNetworkClientId;
+        await this.#refreshNetwork(networkClientId, options);
+    }
+    /**
+     * Fetches the latest block for the network.
+     *
+     * @param networkClientId - The networkClientId to fetch the correct provider against which to check the latest block. Defaults to the selectedNetworkClientId.
+     * @returns A promise that either resolves to the block header or null if
+     * there is no latest block, or rejects with an error.
+     */
+    #getLatestBlock(networkClientId = this.state.selectedNetworkClientId) {
+        const networkClient = this.getNetworkClientById(networkClientId);
+        const ethQuery = new EthQuery(networkClient.provider);
+        return new Promise((resolve, reject) => {
+            ethQuery.sendAsync({ method: 'eth_getBlockByNumber', params: ['latest', false] }, (error, block) => {
+                if (error) {
+                    // This error comes from JsonRpcEngine, we don't control it.
+                    // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+                    reject(error);
+                }
+                else {
+                    // TODO: Validate this type
+                    resolve(block);
+                }
+            });
+        });
     }
     /**
      * Determines whether the network supports EIP-1559 by checking whether the
@@ -618,14 +852,14 @@ export class NetworkController extends BaseController {
         if (networkClientId) {
             return this.get1559CompatibilityWithNetworkClientId(networkClientId);
         }
-        if (!__classPrivateFieldGet(this, _NetworkController_ethQuery, "f")) {
+        if (!this.#ethQuery) {
             return false;
         }
         const { EIPS } = this.state.networksMetadata[this.state.selectedNetworkClientId];
         if (EIPS[1559] !== undefined) {
             return EIPS[1559];
         }
-        const isEIP1559Compatible = await __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_determineEIP1559Compatibility).call(this, this.state.selectedNetworkClientId);
+        const isEIP1559Compatible = await this.#determineEIP1559Compatibility(this.state.selectedNetworkClientId);
         this.update((state) => {
             if (isEIP1559Compatible !== undefined) {
                 state.networksMetadata[state.selectedNetworkClientId].EIPS[1559] =
@@ -644,12 +878,28 @@ export class NetworkController extends BaseController {
         // may want to include some 'freshness' value - something to make sure we refetch this from time to time
         return EIPS[1559];
     }
+    /**
+     * Retrieves and checks the latest block from the currently selected
+     * network; if the block has a `baseFeePerGas` property, then we know
+     * that the network supports EIP-1559; otherwise it doesn't.
+     *
+     * @param networkClientId - The networkClientId to fetch the correct provider against which to check 1559 compatibility
+     * @returns A promise that resolves to `true` if the network supports EIP-1559,
+     * `false` otherwise, or `undefined` if unable to retrieve the last block.
+     */
+    async #determineEIP1559Compatibility(networkClientId) {
+        const latestBlock = await this.#getLatestBlock(networkClientId);
+        if (!latestBlock) {
+            return undefined;
+        }
+        return latestBlock.baseFeePerGas !== undefined;
+    }
     /**
      * Ensures that the provider and block tracker proxies are pointed to the
      * currently selected network and refreshes the metadata for the
      */
     async resetConnection() {
-        await __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_refreshNetwork).call(this, this.state.selectedNetworkClientId);
+        await this.#refreshNetwork(this.state.selectedNetworkClientId);
     }
     /**
      * Returns the network configuration that has been filed under the given chain
@@ -669,7 +919,7 @@ export class NetworkController extends BaseController {
      * @returns The network configuration if one exists, or undefined.
      */
     getNetworkConfigurationByNetworkClientId(networkClientId) {
-        return __classPrivateFieldGet(this, _NetworkController_networkConfigurationsByNetworkClientId, "f").get(networkClientId);
+        return this.#networkConfigurationsByNetworkClientId.get(networkClientId);
     }
     /**
      * Creates and registers network clients for the collection of Infura and
@@ -684,8 +934,8 @@ export class NetworkController extends BaseController {
      */
     addNetwork(fields) {
         const { rpcEndpoints: setOfRpcEndpointFields } = fields;
-        const autoManagedNetworkClientRegistry = __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_ensureAutoManagedNetworkClientRegistryPopulated).call(this);
-        __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_validateNetworkFields).call(this, {
+        const autoManagedNetworkClientRegistry = this.#ensureAutoManagedNetworkClientRegistryPopulated();
+        this.#validateNetworkFields({
             mode: 'add',
             networkFields: fields,
             autoManagedNetworkClientRegistry,
@@ -702,17 +952,17 @@ export class NetworkController extends BaseController {
                 rpcEndpoint,
             };
         });
-        const newNetworkConfiguration = __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_determineNetworkConfigurationToPersist).call(this, {
+        const newNetworkConfiguration = this.#determineNetworkConfigurationToPersist({
             networkFields: fields,
             networkClientOperations,
         });
-        __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_registerNetworkClientsAsNeeded).call(this, {
+        this.#registerNetworkClientsAsNeeded({
             networkFields: fields,
             networkClientOperations,
             autoManagedNetworkClientRegistry,
         });
         this.update((state) => {
-            __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_updateNetworkConfigurations).call(this, {
+            this.#updateNetworkConfigurations({
                 state,
                 mode: 'add',
                 networkFields: fields,
@@ -753,8 +1003,8 @@ export class NetworkController extends BaseController {
         }
         const existingChainId = chainId;
         const { chainId: newChainId, rpcEndpoints: setOfNewRpcEndpointFields } = fields;
-        const autoManagedNetworkClientRegistry = __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_ensureAutoManagedNetworkClientRegistryPopulated).call(this);
-        __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_validateNetworkFields).call(this, {
+        const autoManagedNetworkClientRegistry = this.#ensureAutoManagedNetworkClientRegistryPopulated();
+        this.#validateNetworkFields({
             mode: 'update',
             networkFields: fields,
             existingNetworkConfiguration,
@@ -862,7 +1112,7 @@ export class NetworkController extends BaseController {
                 networkClientOperations.push(networkClientOperation);
             }
         }
-        const updatedNetworkConfiguration = __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_determineNetworkConfigurationToPersist).call(this, {
+        const updatedNetworkConfiguration = this.#determineNetworkConfigurationToPersist({
             networkFields: fields,
             networkClientOperations,
         });
@@ -879,7 +1129,7 @@ export class NetworkController extends BaseController {
             })) {
             throw new Error(`Could not update network: Cannot update RPC endpoints in such a way that the selected network '${this.state.selectedNetworkClientId}' would be removed without a replacement. Choose a different RPC endpoint as the selected network via the \`replacementSelectedRpcEndpointIndex\` option.`);
         }
-        __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_registerNetworkClientsAsNeeded).call(this, {
+        this.#registerNetworkClientsAsNeeded({
             networkFields: fields,
             networkClientOperations,
             autoManagedNetworkClientRegistry,
@@ -905,7 +1155,7 @@ export class NetworkController extends BaseController {
             rpcEndpointToSelect.networkClientId !== this.state.selectedNetworkClientId) {
             await this.setActiveNetwork(rpcEndpointToSelect.networkClientId, {
                 updateState: (state) => {
-                    __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_updateNetworkConfigurations).call(this, {
+                    this.#updateNetworkConfigurations({
                         state,
                         mode: 'update',
                         networkFields: fields,
@@ -917,7 +1167,7 @@ export class NetworkController extends BaseController {
         }
         else {
             this.update((state) => {
-                __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_updateNetworkConfigurations).call(this, {
+                this.#updateNetworkConfigurations({
                     state,
                     mode: 'update',
                     networkFields: fields,
@@ -926,7 +1176,7 @@ export class NetworkController extends BaseController {
                 });
             });
         }
-        __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_unregisterNetworkClientsAsNeeded).call(this, {
+        this.#unregisterNetworkClientsAsNeeded({
             networkClientOperations,
             autoManagedNetworkClientRegistry,
         });
@@ -949,19 +1199,19 @@ export class NetworkController extends BaseController {
         if (existingNetworkConfiguration.rpcEndpoints.some((rpcEndpoint) => rpcEndpoint.networkClientId === this.state.selectedNetworkClientId)) {
             throw new Error(`Cannot remove the currently selected network`);
         }
-        const autoManagedNetworkClientRegistry = __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_ensureAutoManagedNetworkClientRegistryPopulated).call(this);
+        const autoManagedNetworkClientRegistry = this.#ensureAutoManagedNetworkClientRegistryPopulated();
         const networkClientOperations = existingNetworkConfiguration.rpcEndpoints.map((rpcEndpoint) => {
             return {
                 type: 'remove',
                 rpcEndpoint,
             };
         });
-        __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_unregisterNetworkClientsAsNeeded).call(this, {
+        this.#unregisterNetworkClientsAsNeeded({
             networkClientOperations,
             autoManagedNetworkClientRegistry,
         });
         this.update((state) => {
-            __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_updateNetworkConfigurations).call(this, {
+            this.#updateNetworkConfigurations({
                 state,
                 mode: 'remove',
                 existingNetworkConfiguration,
@@ -980,7 +1230,7 @@ export class NetworkController extends BaseController {
      * to {@link resetConnection}.
      */
     async rollbackToPreviousProvider() {
-        await __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_refreshNetwork).call(this, __classPrivateFieldGet(this, _NetworkController_previouslySelectedNetworkClientId, "f"));
+        await this.#refreshNetwork(this.#previouslySelectedNetworkClientId);
     }
     /**
      * Deactivates the controller, stopping any ongoing polling.
@@ -990,7 +1240,7 @@ export class NetworkController extends BaseController {
     // We're intentionally changing the signature of an extended method.
     // eslint-disable-next-line @typescript-eslint/no-misused-promises
     async destroy() {
-        await __classPrivateFieldGet(this, _NetworkController_blockTrackerProxy, "f")?.destroy();
+        await this.#blockTrackerProxy?.destroy();
     }
     /**
      * Merges the given backup data into controller state.
@@ -1024,551 +1274,405 @@ export class NetworkController extends BaseController {
         const { networkClientId } = networkConfiguration.rpcEndpoints[networkConfiguration.defaultRpcEndpointIndex];
         return networkClientId;
     }
-}
-_NetworkController_ethQuery = new WeakMap(), _NetworkController_infuraProjectId = new WeakMap(), _NetworkController_failoverUrls = new WeakMap(), _NetworkController_previouslySelectedNetworkClientId = new WeakMap(), _NetworkController_providerProxy = new WeakMap(), _NetworkController_blockTrackerProxy = new WeakMap(), _NetworkController_autoManagedNetworkClientRegistry = new WeakMap(), _NetworkController_autoManagedNetworkClient = new WeakMap(), _NetworkController_log = new WeakMap(), _NetworkController_getRpcServiceOptions = new WeakMap(), _NetworkController_getBlockTrackerOptions = new WeakMap(), _NetworkController_analyticsOptions = new WeakMap(), _NetworkController_networkConfigurationsByNetworkClientId = new WeakMap(), _NetworkController_rpcFailoverMode = new WeakMap(), _NetworkController_instances = new WeakSet(), _NetworkController_updateRpcFailover = function _NetworkController_updateRpcFailover(newMode) {
-    if (__classPrivateFieldGet(this, _NetworkController_rpcFailoverMode, "f") === newMode) {
-        return;
-    }
-    const autoManagedNetworkClientRegistry = __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_ensureAutoManagedNetworkClientRegistryPopulated).call(this);
-    for (const networkClientsById of Object.values(autoManagedNetworkClientRegistry)) {
-        for (const networkClientId of Object.keys(networkClientsById)) {
-            const networkClient = networkClientsById[networkClientId];
-            if (networkClient.configuration.failoverRpcUrls &&
-                networkClient.configuration.failoverRpcUrls.length > 0) {
-                networkClient.setRpcFailoverMode(newMode);
-            }
+    /**
+     * Ensure that the given fields which will be used to either add or update a
+     * network are valid.
+     *
+     * @param args - The arguments.
+     */
+    #validateNetworkFields(args) {
+        const { mode, networkFields, autoManagedNetworkClientRegistry } = args;
+        const existingNetworkConfiguration = 'existingNetworkConfiguration' in args
+            ? args.existingNetworkConfiguration
+            : null;
+        const errorMessagePrefix = mode === 'update' ? 'Could not update network' : 'Could not add network';
+        if (!isStrictHexString(networkFields.chainId) ||
+            !isSafeChainId(networkFields.chainId)) {
+            throw new Error(`${errorMessagePrefix}: Invalid \`chainId\` '${networkFields.chainId}' (must start with "0x" and not exceed the maximum)`);
         }
-    }
-    __classPrivateFieldSet(this, _NetworkController_rpcFailoverMode, newMode, "f");
-}, _NetworkController_refreshNetwork = 
-/**
- * Executes a series of steps to switch the network:
- *
- * 1. Notifies subscribers via the messenger that the network is about to be
- * switched (and, really, that the global provider and block tracker proxies
- * will be re-pointed to a new network).
- * 2. Looks up a known and preinitialized network client matching the given
- * ID and uses it to re-point the aforementioned provider and block tracker
- * proxies.
- * 3. Notifies subscribers via the messenger that the network has switched.
- * 4. Captures metadata for the newly switched network in state.
- *
- * @param networkClientId - The ID of a network client that requests will be
- * routed through (either the name of an Infura network or the ID of a custom
- * network configuration).
- * @param options - Options for this method.
- * @param options.updateState - Allows for updating state.
- */
-async function _NetworkController_refreshNetwork(networkClientId, options = {}) {
-    this.messenger.publish('NetworkController:networkWillChange', this.state);
-    __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_applyNetworkSelection).call(this, networkClientId, options);
-    this.messenger.publish('NetworkController:networkDidChange', this.state);
-    await this.lookupNetwork();
-}, _NetworkController_determineNetworkMetadata = 
-/**
- * Uses a request for the latest block to gather the following information on
- * the given network:
- *
- * - The connectivity status: whether it is available, geo-blocked (Infura
- * only), unavailable, or unknown
- * - The capabilities status: whether it supports EIP-1559, whether it does
- * not, or whether it is unknown
- *
- * @param networkClientId - The ID of the network client to inspect.
- * If no ID is provided, uses the currently selected network.
- * @returns The resulting metadata for the network.
- */
-async function _NetworkController_determineNetworkMetadata(networkClientId) {
-    const networkClient = this.getNetworkClientById(networkClientId);
-    const isInfura = networkClient.configuration.type === NetworkClientType.Infura;
-    let networkStatus;
-    let isEIP1559Compatible;
-    try {
-        isEIP1559Compatible =
-            await __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_determineEIP1559Compatibility).call(this, networkClientId);
-        networkStatus = NetworkStatus.Available;
-    }
-    catch (error) {
-        debugLog('NetworkController: lookupNetwork: ', error);
-        if (isErrorWithCode(error)) {
-            let responseBody;
-            if (isInfura &&
-                hasProperty(error, 'message') &&
-                typeof error.message === 'string') {
-                try {
-                    responseBody = JSON.parse(error.message);
+        if (networkFields.chainId !== existingNetworkConfiguration?.chainId) {
+            const existingNetworkConfigurationViaChainId = this.state.networkConfigurationsByChainId[networkFields.chainId];
+            if (existingNetworkConfigurationViaChainId !== undefined) {
+                if (existingNetworkConfiguration === null) {
+                    throw new Error(`Could not add network for chain ${args.networkFields.chainId} as another network for that chain already exists ('${existingNetworkConfigurationViaChainId.name}')`);
                 }
-                catch {
-                    // error.message must not be JSON
-                    __classPrivateFieldGet(this, _NetworkController_log, "f")?.warn('NetworkController: lookupNetwork: json parse error: ', error);
+                else {
+                    throw new Error(`Cannot move network from chain ${existingNetworkConfiguration.chainId} to ${networkFields.chainId} as another network for that chain already exists ('${existingNetworkConfigurationViaChainId.name}')`);
                 }
             }
-            if (isPlainObject(responseBody) &&
-                responseBody.error === INFURA_BLOCKED_KEY) {
-                networkStatus = NetworkStatus.Blocked;
-            }
-            else if (error.code === errorCodes.rpc.internal) {
-                networkStatus = NetworkStatus.Unknown;
-                __classPrivateFieldGet(this, _NetworkController_log, "f")?.warn('NetworkController: lookupNetwork: rpc internal error: ', error);
-            }
-            else {
-                networkStatus = NetworkStatus.Unavailable;
-                __classPrivateFieldGet(this, _NetworkController_log, "f")?.warn('NetworkController: lookupNetwork: ', error);
-            }
         }
-        else {
-            debugLog('NetworkController - could not determine network status', error);
-            networkStatus = NetworkStatus.Unknown;
-            __classPrivateFieldGet(this, _NetworkController_log, "f")?.warn('NetworkController: lookupNetwork: ', error);
+        const isInvalidDefaultBlockExplorerUrlIndex = networkFields.blockExplorerUrls.length > 0
+            ? networkFields.defaultBlockExplorerUrlIndex === undefined ||
+                networkFields.blockExplorerUrls[networkFields.defaultBlockExplorerUrlIndex] === undefined
+            : networkFields.defaultBlockExplorerUrlIndex !== undefined;
+        if (isInvalidDefaultBlockExplorerUrlIndex) {
+            throw new Error(`${errorMessagePrefix}: \`defaultBlockExplorerUrlIndex\` must refer to an entry in \`blockExplorerUrls\``);
         }
-    }
-    return { isInfura, networkStatus, isEIP1559Compatible };
-}, _NetworkController_lookupGivenNetwork = 
-/**
- * Uses a request for the latest block to gather the following information on
- * the given network, persisting it to state:
- *
- * - The connectivity status: whether the network is available, geo-blocked
- * (Infura only), unavailable, or unknown
- * - The feature compatibility status: whether the network supports EIP-1559,
- * whether it does not, or whether it is unknown
- *
- * @param networkClientId - The ID of the network client to inspect.
- */
-async function _NetworkController_lookupGivenNetwork(networkClientId) {
-    const { networkStatus, isEIP1559Compatible } = await __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_determineNetworkMetadata).call(this, networkClientId);
-    __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_updateMetadataForNetwork).call(this, networkClientId, {
-        networkStatus,
-        isEIP1559Compatible,
-    });
-}, _NetworkController_lookupSelectedNetwork = 
-/**
- * Uses a request for the latest block to gather the following information on
- * the currently selected network, persisting it to state:
- *
- * - The connectivity status: whether the network is available, geo-blocked
- * (Infura only), unavailable, or unknown
- * - The feature compatibility status: whether the network supports EIP-1559,
- * whether it does not, or whether it is unknown
- *
- * Note that it is possible for the current network to be switched while this
- * method is running. If that is the case, it will exit early (as this method
- * will also run for the new network).
- */
-async function _NetworkController_lookupSelectedNetwork() {
-    if (!__classPrivateFieldGet(this, _NetworkController_ethQuery, "f")) {
-        return;
-    }
-    let networkChanged = false;
-    const listener = () => {
-        networkChanged = true;
-        try {
-            this.messenger.unsubscribe('NetworkController:networkDidChange', listener);
+        if (networkFields.rpcEndpoints.length === 0) {
+            throw new Error(`${errorMessagePrefix}: \`rpcEndpoints\` must be a non-empty array`);
         }
-        catch (error) {
-            // In theory, this `catch` should not be necessary given that this error
-            // would occur "inside" of the call to `#determineEIP1559Compatibility`
-            // below and so it should be caught by the `try`/`catch` below (it is
-            // impossible to reproduce in tests for that reason). However, somehow
-            // it occurs within Mobile and so we have to add our own `try`/`catch`
-            // here.
-            /* istanbul ignore next */
-            if (!(error instanceof Error) ||
-                error.message !==
-                    'Subscription not found for event: NetworkController:networkDidChange') {
-                // Again, this error should not happen and is impossible to reproduce
-                // in tests.
-                /* istanbul ignore next */
-                throw error;
+        for (const rpcEndpointFields of networkFields.rpcEndpoints) {
+            if (!isValidUrl(rpcEndpointFields.url)) {
+                throw new Error(`${errorMessagePrefix}: An entry in \`rpcEndpoints\` has invalid URL '${rpcEndpointFields.url}'`);
+            }
+            const networkClientId = 'networkClientId' in rpcEndpointFields
+                ? rpcEndpointFields.networkClientId
+                : undefined;
+            if (mode === 'update' &&
+                networkClientId !== undefined &&
+                rpcEndpointFields.type === RpcEndpointType.Custom &&
+                !Object.values(autoManagedNetworkClientRegistry).some((networkClientsById) => networkClientId in networkClientsById)) {
+                throw new Error(`${errorMessagePrefix}: RPC endpoint '${rpcEndpointFields.url}' refers to network client '${networkClientId}' that does not exist`);
+            }
+            if (networkFields.rpcEndpoints.some((otherRpcEndpointFields) => otherRpcEndpointFields !== rpcEndpointFields &&
+                URI.equal(otherRpcEndpointFields.url, rpcEndpointFields.url))) {
+                throw new Error(`${errorMessagePrefix}: Each entry in rpcEndpoints must have a unique URL`);
+            }
+            const networkConfigurationsForOtherChains = Object.values(this.state.networkConfigurationsByChainId).filter((networkConfiguration) => existingNetworkConfiguration
+                ? networkConfiguration.chainId !==
+                    existingNetworkConfiguration.chainId
+                : true);
+            for (const networkConfiguration of networkConfigurationsForOtherChains) {
+                const rpcEndpoint = networkConfiguration.rpcEndpoints.find((existingRpcEndpoint) => URI.equal(rpcEndpointFields.url, existingRpcEndpoint.url));
+                if (rpcEndpoint) {
+                    if (mode === 'update') {
+                        throw new Error(`Could not update network to point to same RPC endpoint as existing network for chain ${networkConfiguration.chainId} ('${networkConfiguration.name}')`);
+                    }
+                    else {
+                        throw new Error(`Could not add network that points to same RPC endpoint as existing network for chain ${networkConfiguration.chainId} ('${networkConfiguration.name}')`);
+                    }
+                }
             }
         }
-    };
-    this.messenger.subscribe('NetworkController:networkDidChange', listener);
-    const { isInfura, networkStatus, isEIP1559Compatible } = await __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_determineNetworkMetadata).call(this, this.state.selectedNetworkClientId);
-    if (networkChanged) {
-        // If the network has changed, then `lookupNetwork` either has been or is
-        // in the process of being called, so we don't need to go further.
-        return;
-    }
-    try {
-        this.messenger.unsubscribe('NetworkController:networkDidChange', listener);
-    }
-    catch (error) {
-        if (!(error instanceof Error) ||
-            error.message !==
-                'Subscription not found for event: NetworkController:networkDidChange') {
-            throw error;
+        if ([...new Set(networkFields.rpcEndpoints)].length <
+            networkFields.rpcEndpoints.length) {
+            throw new Error(`${errorMessagePrefix}: Each entry in rpcEndpoints must be unique`);
         }
-    }
-    __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_updateMetadataForNetwork).call(this, this.state.selectedNetworkClientId, {
-        networkStatus,
-        isEIP1559Compatible,
-    });
-    if (isInfura) {
-        if (networkStatus === NetworkStatus.Available) {
-            this.messenger.publish('NetworkController:infuraIsUnblocked');
+        const networkClientIds = networkFields.rpcEndpoints
+            .map((rpcEndpoint) => 'networkClientId' in rpcEndpoint
+            ? rpcEndpoint.networkClientId
+            : undefined)
+            .filter((networkClientId) => networkClientId !== undefined);
+        if ([...new Set(networkClientIds)].length < networkClientIds.length) {
+            throw new Error(`${errorMessagePrefix}: Each entry in rpcEndpoints must have a unique networkClientId`);
         }
-        else if (networkStatus === NetworkStatus.Blocked) {
-            this.messenger.publish('NetworkController:infuraIsBlocked');
+        const infuraRpcEndpoints = networkFields.rpcEndpoints.filter((rpcEndpointFields) => rpcEndpointFields.type === RpcEndpointType.Infura);
+        if (infuraRpcEndpoints.length > 1) {
+            throw new Error(`${errorMessagePrefix}: There cannot be more than one Infura RPC endpoint`);
         }
-    }
-    else {
-        // Always publish infuraIsUnblocked regardless of network status to
-        // prevent consumers from being stuck in a blocked state if they were
-        // previously connected to an Infura network that was blocked
-        this.messenger.publish('NetworkController:infuraIsUnblocked');
-    }
-}, _NetworkController_updateMetadataForNetwork = function _NetworkController_updateMetadataForNetwork(networkClientId, metadata) {
-    this.update((state) => {
-        var _a;
-        (_a = state.networksMetadata)[networkClientId] ?? (_a[networkClientId] = {
-            status: NetworkStatus.Unknown,
-            EIPS: {},
-        });
-        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;
-            }
+        if (networkFields.rpcEndpoints[networkFields.defaultRpcEndpointIndex] ===
+            undefined) {
+            throw new Error(`${errorMessagePrefix}: \`defaultRpcEndpointIndex\` must refer to an entry in \`rpcEndpoints\``);
         }
-    });
-}, _NetworkController_getLatestBlock = function _NetworkController_getLatestBlock(networkClientId = this.state.selectedNetworkClientId) {
-    const networkClient = this.getNetworkClientById(networkClientId);
-    const ethQuery = new EthQuery(networkClient.provider);
-    return new Promise((resolve, reject) => {
-        ethQuery.sendAsync({ method: 'eth_getBlockByNumber', params: ['latest', false] }, (error, block) => {
-            if (error) {
-                // This error comes from JsonRpcEngine, we don't control it.
-                // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
-                reject(error);
-            }
-            else {
-                // TODO: Validate this type
-                resolve(block);
-            }
-        });
-    });
-}, _NetworkController_determineEIP1559Compatibility = 
-/**
- * Retrieves and checks the latest block from the currently selected
- * network; if the block has a `baseFeePerGas` property, then we know
- * that the network supports EIP-1559; otherwise it doesn't.
- *
- * @param networkClientId - The networkClientId to fetch the correct provider against which to check 1559 compatibility
- * @returns A promise that resolves to `true` if the network supports EIP-1559,
- * `false` otherwise, or `undefined` if unable to retrieve the last block.
- */
-async function _NetworkController_determineEIP1559Compatibility(networkClientId) {
-    const latestBlock = await __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_getLatestBlock).call(this, networkClientId);
-    if (!latestBlock) {
-        return undefined;
     }
-    return latestBlock.baseFeePerGas !== undefined;
-}, _NetworkController_validateNetworkFields = function _NetworkController_validateNetworkFields(args) {
-    const { mode, networkFields, autoManagedNetworkClientRegistry } = args;
-    const existingNetworkConfiguration = 'existingNetworkConfiguration' in args
-        ? args.existingNetworkConfiguration
-        : null;
-    const errorMessagePrefix = mode === 'update' ? 'Could not update network' : 'Could not add network';
-    if (!isStrictHexString(networkFields.chainId) ||
-        !isSafeChainId(networkFields.chainId)) {
-        throw new Error(`${errorMessagePrefix}: Invalid \`chainId\` '${networkFields.chainId}' (must start with "0x" and not exceed the maximum)`);
+    /**
+     * Constructs a network configuration that will be persisted to state when
+     * adding or updating a network.
+     *
+     * @param args - The arguments to this function.
+     * @param args.networkFields - The fields used to add or update a network.
+     * @param args.networkClientOperations - Operations which were calculated for
+     * updating the network client registry but which also map back to RPC
+     * endpoints (and so can be used to save those RPC endpoints).
+     * @returns The network configuration to persist.
+     */
+    #determineNetworkConfigurationToPersist({ networkFields, networkClientOperations, }) {
+        const rpcEndpointsToPersist = networkClientOperations
+            .filter((networkClientOperation) => {
+            return (networkClientOperation.type === 'add' ||
+                networkClientOperation.type === 'noop');
+        })
+            .map((networkClientOperation) => networkClientOperation.rpcEndpoint)
+            .concat(networkClientOperations
+            .filter((networkClientOperation) => {
+            return networkClientOperation.type === 'replace';
+        })
+            .map((networkClientOperation) => networkClientOperation.newRpcEndpoint));
+        return { ...networkFields, rpcEndpoints: rpcEndpointsToPersist };
     }
-    if (networkFields.chainId !== existingNetworkConfiguration?.chainId) {
-        const existingNetworkConfigurationViaChainId = this.state.networkConfigurationsByChainId[networkFields.chainId];
-        if (existingNetworkConfigurationViaChainId !== undefined) {
-            if (existingNetworkConfiguration === null) {
-                throw new Error(`Could not add network for chain ${args.networkFields.chainId} as another network for that chain already exists ('${existingNetworkConfigurationViaChainId.name}')`);
+    /**
+     * Creates and registers network clients using the given operations calculated
+     * as a part of adding or updating a network.
+     *
+     * @param args - The arguments to this function.
+     * @param args.networkFields - The fields used to add or update a network.
+     * @param args.networkClientOperations - Dictate which network clients need to
+     * be created.
+     * @param args.autoManagedNetworkClientRegistry - The network client registry
+     * to update.
+     */
+    #registerNetworkClientsAsNeeded({ networkFields, networkClientOperations, autoManagedNetworkClientRegistry, }) {
+        const addedRpcEndpoints = networkClientOperations
+            .filter((networkClientOperation) => {
+            return networkClientOperation.type === 'add';
+        })
+            .map((networkClientOperation) => networkClientOperation.rpcEndpoint)
+            .concat(networkClientOperations
+            .filter((networkClientOperation) => {
+            return networkClientOperation.type === 'replace';
+        })
+            .map((networkClientOperation) => networkClientOperation.newRpcEndpoint));
+        const defaultFailoverUrls = this.#failoverUrls?.[networkFields.chainId];
+        for (const addedRpcEndpoint of addedRpcEndpoints) {
+            if (addedRpcEndpoint.type === RpcEndpointType.Infura) {
+                autoManagedNetworkClientRegistry[NetworkClientType.Infura][addedRpcEndpoint.networkClientId] = createAutoManagedNetworkClient({
+                    networkClientId: addedRpcEndpoint.networkClientId,
+                    networkClientConfiguration: {
+                        type: NetworkClientType.Infura,
+                        chainId: networkFields.chainId,
+                        network: addedRpcEndpoint.networkClientId,
+                        failoverRpcUrls: defaultFailoverUrls ?? addedRpcEndpoint.failoverUrls,
+                        infuraProjectId: this.#infuraProjectId,
+                        ticker: networkFields.nativeCurrency,
+                    },
+                    getRpcServiceOptions: this.#getRpcServiceOptions,
+                    getBlockTrackerOptions: this.#getBlockTrackerOptions,
+                    messenger: this.messenger,
+                    rpcFailoverMode: this.#rpcFailoverMode,
+                    logger: this.#log,
+                });
             }
             else {
-                throw new Error(`Cannot move network from chain ${existingNetworkConfiguration.chainId} to ${networkFields.chainId} as another network for that chain already exists ('${existingNetworkConfigurationViaChainId.name}')`);
+                autoManagedNetworkClientRegistry[NetworkClientType.Custom][addedRpcEndpoint.networkClientId] = createAutoManagedNetworkClient({
+                    networkClientId: addedRpcEndpoint.networkClientId,
+                    networkClientConfiguration: {
+                        type: NetworkClientType.Custom,
+                        chainId: networkFields.chainId,
+                        failoverRpcUrls: defaultFailoverUrls ?? addedRpcEndpoint.failoverUrls,
+                        rpcUrl: addedRpcEndpoint.url,
+                        ticker: networkFields.nativeCurrency,
+                    },
+                    getRpcServiceOptions: this.#getRpcServiceOptions,
+                    getBlockTrackerOptions: this.#getBlockTrackerOptions,
+                    messenger: this.messenger,
+                    rpcFailoverMode: this.#rpcFailoverMode,
+                    logger: this.#log,
+                });
             }
         }
     }
-    const isInvalidDefaultBlockExplorerUrlIndex = networkFields.blockExplorerUrls.length > 0
-        ? networkFields.defaultBlockExplorerUrlIndex === undefined ||
-            networkFields.blockExplorerUrls[networkFields.defaultBlockExplorerUrlIndex] === undefined
-        : networkFields.defaultBlockExplorerUrlIndex !== undefined;
-    if (isInvalidDefaultBlockExplorerUrlIndex) {
-        throw new Error(`${errorMessagePrefix}: \`defaultBlockExplorerUrlIndex\` must refer to an entry in \`blockExplorerUrls\``);
-    }
-    if (networkFields.rpcEndpoints.length === 0) {
-        throw new Error(`${errorMessagePrefix}: \`rpcEndpoints\` must be a non-empty array`);
-    }
-    for (const rpcEndpointFields of networkFields.rpcEndpoints) {
-        if (!isValidUrl(rpcEndpointFields.url)) {
-            throw new Error(`${errorMessagePrefix}: An entry in \`rpcEndpoints\` has invalid URL '${rpcEndpointFields.url}'`);
-        }
-        const networkClientId = 'networkClientId' in rpcEndpointFields
-            ? rpcEndpointFields.networkClientId
-            : undefined;
-        if (mode === 'update' &&
-            networkClientId !== undefined &&
-            rpcEndpointFields.type === RpcEndpointType.Custom &&
-            !Object.values(autoManagedNetworkClientRegistry).some((networkClientsById) => networkClientId in networkClientsById)) {
-            throw new Error(`${errorMessagePrefix}: RPC endpoint '${rpcEndpointFields.url}' refers to network client '${networkClientId}' that does not exist`);
-        }
-        if (networkFields.rpcEndpoints.some((otherRpcEndpointFields) => otherRpcEndpointFields !== rpcEndpointFields &&
-            URI.equal(otherRpcEndpointFields.url, rpcEndpointFields.url))) {
-            throw new Error(`${errorMessagePrefix}: Each entry in rpcEndpoints must have a unique URL`);
-        }
-        const networkConfigurationsForOtherChains = Object.values(this.state.networkConfigurationsByChainId).filter((networkConfiguration) => existingNetworkConfiguration
-            ? networkConfiguration.chainId !==
-                existingNetworkConfiguration.chainId
-            : true);
-        for (const networkConfiguration of networkConfigurationsForOtherChains) {
-            const rpcEndpoint = networkConfiguration.rpcEndpoints.find((existingRpcEndpoint) => URI.equal(rpcEndpointFields.url, existingRpcEndpoint.url));
-            if (rpcEndpoint) {
-                if (mode === 'update') {
-                    throw new Error(`Could not update network to point to same RPC endpoint as existing network for chain ${networkConfiguration.chainId} ('${networkConfiguration.name}')`);
-                }
-                else {
-                    throw new Error(`Could not add network that points to same RPC endpoint as existing network for chain ${networkConfiguration.chainId} ('${networkConfiguration.name}')`);
-                }
-            }
+    /**
+     * Destroys and removes network clients using the given operations calculated
+     * as a part of updating or removing a network.
+     *
+     * @param args - The arguments to this function.
+     * @param args.networkClientOperations - Dictate which network clients to
+     * remove.
+     * @param args.autoManagedNetworkClientRegistry - The network client registry
+     * to update.
+     */
+    #unregisterNetworkClientsAsNeeded({ networkClientOperations, autoManagedNetworkClientRegistry, }) {
+        const removedRpcEndpoints = networkClientOperations
+            .filter((networkClientOperation) => {
+            return networkClientOperation.type === 'remove';
+        })
+            .map((networkClientOperation) => networkClientOperation.rpcEndpoint)
+            .concat(networkClientOperations
+            .filter((networkClientOperation) => {
+            return networkClientOperation.type === 'replace';
+        })
+            .map((networkClientOperation) => networkClientOperation.oldRpcEndpoint));
+        for (const rpcEndpoint of removedRpcEndpoints) {
+            const networkClient = this.getNetworkClientById(rpcEndpoint.networkClientId);
+            networkClient.destroy();
+            delete autoManagedNetworkClientRegistry[networkClient.configuration.type][rpcEndpoint.networkClientId];
         }
     }
-    if ([...new Set(networkFields.rpcEndpoints)].length <
-        networkFields.rpcEndpoints.length) {
-        throw new Error(`${errorMessagePrefix}: Each entry in rpcEndpoints must be unique`);
-    }
-    const networkClientIds = networkFields.rpcEndpoints
-        .map((rpcEndpoint) => 'networkClientId' in rpcEndpoint
-        ? rpcEndpoint.networkClientId
-        : undefined)
-        .filter((networkClientId) => networkClientId !== undefined);
-    if ([...new Set(networkClientIds)].length < networkClientIds.length) {
-        throw new Error(`${errorMessagePrefix}: Each entry in rpcEndpoints must have a unique networkClientId`);
-    }
-    const infuraRpcEndpoints = networkFields.rpcEndpoints.filter((rpcEndpointFields) => rpcEndpointFields.type === RpcEndpointType.Infura);
-    if (infuraRpcEndpoints.length > 1) {
-        throw new Error(`${errorMessagePrefix}: There cannot be more than one Infura RPC endpoint`);
-    }
-    if (networkFields.rpcEndpoints[networkFields.defaultRpcEndpointIndex] ===
-        undefined) {
-        throw new Error(`${errorMessagePrefix}: \`defaultRpcEndpointIndex\` must refer to an entry in \`rpcEndpoints\``);
-    }
-}, _NetworkController_determineNetworkConfigurationToPersist = function _NetworkController_determineNetworkConfigurationToPersist({ networkFields, networkClientOperations, }) {
-    const rpcEndpointsToPersist = networkClientOperations
-        .filter((networkClientOperation) => {
-        return (networkClientOperation.type === 'add' ||
-            networkClientOperation.type === 'noop');
-    })
-        .map((networkClientOperation) => networkClientOperation.rpcEndpoint)
-        .concat(networkClientOperations
-        .filter((networkClientOperation) => {
-        return networkClientOperation.type === 'replace';
-    })
-        .map((networkClientOperation) => networkClientOperation.newRpcEndpoint));
-    return { ...networkFields, rpcEndpoints: rpcEndpointsToPersist };
-}, _NetworkController_registerNetworkClientsAsNeeded = function _NetworkController_registerNetworkClientsAsNeeded({ networkFields, networkClientOperations, autoManagedNetworkClientRegistry, }) {
-    const addedRpcEndpoints = networkClientOperations
-        .filter((networkClientOperation) => {
-        return networkClientOperation.type === 'add';
-    })
-        .map((networkClientOperation) => networkClientOperation.rpcEndpoint)
-        .concat(networkClientOperations
-        .filter((networkClientOperation) => {
-        return networkClientOperation.type === 'replace';
-    })
-        .map((networkClientOperation) => networkClientOperation.newRpcEndpoint));
-    const defaultFailoverUrls = __classPrivateFieldGet(this, _NetworkController_failoverUrls, "f")?.[networkFields.chainId];
-    for (const addedRpcEndpoint of addedRpcEndpoints) {
-        if (addedRpcEndpoint.type === RpcEndpointType.Infura) {
-            autoManagedNetworkClientRegistry[NetworkClientType.Infura][addedRpcEndpoint.networkClientId] = createAutoManagedNetworkClient({
-                networkClientId: addedRpcEndpoint.networkClientId,
-                networkClientConfiguration: {
-                    type: NetworkClientType.Infura,
-                    chainId: networkFields.chainId,
-                    network: addedRpcEndpoint.networkClientId,
-                    failoverRpcUrls: defaultFailoverUrls ?? addedRpcEndpoint.failoverUrls,
-                    infuraProjectId: __classPrivateFieldGet(this, _NetworkController_infuraProjectId, "f"),
-                    ticker: networkFields.nativeCurrency,
-                },
-                getRpcServiceOptions: __classPrivateFieldGet(this, _NetworkController_getRpcServiceOptions, "f"),
-                getBlockTrackerOptions: __classPrivateFieldGet(this, _NetworkController_getBlockTrackerOptions, "f"),
-                messenger: this.messenger,
-                rpcFailoverMode: __classPrivateFieldGet(this, _NetworkController_rpcFailoverMode, "f"),
-                logger: __classPrivateFieldGet(this, _NetworkController_log, "f"),
-            });
+    /**
+     * Updates `networkConfigurationsByChainId` in state depending on whether a
+     * network is being added, updated, or removed.
+     *
+     * - The existing network configuration will be removed when a network is
+     * being filed under a different chain or removed.
+     * - A network configuration will be stored when a network is being added or
+     * when a network is being updated.
+     *
+     * @param args - The arguments to this function.
+     */
+    #updateNetworkConfigurations(args) {
+        const { state, mode } = args;
+        if (mode === 'remove' ||
+            (mode === 'update' &&
+                args.networkFields.chainId !==
+                    args.existingNetworkConfiguration.chainId)) {
+            delete state.networkConfigurationsByChainId[args.existingNetworkConfiguration.chainId];
         }
-        else {
-            autoManagedNetworkClientRegistry[NetworkClientType.Custom][addedRpcEndpoint.networkClientId] = createAutoManagedNetworkClient({
-                networkClientId: addedRpcEndpoint.networkClientId,
-                networkClientConfiguration: {
-                    type: NetworkClientType.Custom,
-                    chainId: networkFields.chainId,
-                    failoverRpcUrls: defaultFailoverUrls ?? addedRpcEndpoint.failoverUrls,
-                    rpcUrl: addedRpcEndpoint.url,
-                    ticker: networkFields.nativeCurrency,
-                },
-                getRpcServiceOptions: __classPrivateFieldGet(this, _NetworkController_getRpcServiceOptions, "f"),
-                getBlockTrackerOptions: __classPrivateFieldGet(this, _NetworkController_getBlockTrackerOptions, "f"),
-                messenger: this.messenger,
-                rpcFailoverMode: __classPrivateFieldGet(this, _NetworkController_rpcFailoverMode, "f"),
-                logger: __classPrivateFieldGet(this, _NetworkController_log, "f"),
-            });
+        if (mode === 'add' || mode === 'update') {
+            if (!deepEqual(state.networkConfigurationsByChainId[args.networkFields.chainId], args.networkConfigurationToPersist)) {
+                args.networkConfigurationToPersist.lastUpdatedAt = Date.now();
+            }
+            state.networkConfigurationsByChainId[args.networkFields.chainId] =
+                args.networkConfigurationToPersist;
         }
+        this.#networkConfigurationsByNetworkClientId =
+            buildNetworkConfigurationsByNetworkClientId(cloneDeep(state.networkConfigurationsByChainId));
     }
-}, _NetworkController_unregisterNetworkClientsAsNeeded = function _NetworkController_unregisterNetworkClientsAsNeeded({ networkClientOperations, autoManagedNetworkClientRegistry, }) {
-    const removedRpcEndpoints = networkClientOperations
-        .filter((networkClientOperation) => {
-        return networkClientOperation.type === 'remove';
-    })
-        .map((networkClientOperation) => networkClientOperation.rpcEndpoint)
-        .concat(networkClientOperations
-        .filter((networkClientOperation) => {
-        return networkClientOperation.type === 'replace';
-    })
-        .map((networkClientOperation) => networkClientOperation.oldRpcEndpoint));
-    for (const rpcEndpoint of removedRpcEndpoints) {
-        const networkClient = this.getNetworkClientById(rpcEndpoint.networkClientId);
-        networkClient.destroy();
-        delete autoManagedNetworkClientRegistry[networkClient.configuration.type][rpcEndpoint.networkClientId];
-    }
-}, _NetworkController_updateNetworkConfigurations = function _NetworkController_updateNetworkConfigurations(args) {
-    const { state, mode } = args;
-    if (mode === 'remove' ||
-        (mode === 'update' &&
-            args.networkFields.chainId !==
-                args.existingNetworkConfiguration.chainId)) {
-        delete state.networkConfigurationsByChainId[args.existingNetworkConfiguration.chainId];
-    }
-    if (mode === 'add' || mode === 'update') {
-        if (!deepEqual(state.networkConfigurationsByChainId[args.networkFields.chainId], args.networkConfigurationToPersist)) {
-            args.networkConfigurationToPersist.lastUpdatedAt = Date.now();
-        }
-        state.networkConfigurationsByChainId[args.networkFields.chainId] =
-            args.networkConfigurationToPersist;
+    /**
+     * Before accessing or switching the network, the registry of network clients
+     * needs to be populated. Otherwise, `#applyNetworkSelection` and
+     * `getNetworkClientRegistry` will throw an error. This method checks to see if the
+     * population step has happened yet, and if not, makes it happen.
+     *
+     * @returns The populated network client registry.
+     */
+    #ensureAutoManagedNetworkClientRegistryPopulated() {
+        return (this.#autoManagedNetworkClientRegistry ??=
+            this.#createAutoManagedNetworkClientRegistry());
     }
-    __classPrivateFieldSet(this, _NetworkController_networkConfigurationsByNetworkClientId, buildNetworkConfigurationsByNetworkClientId(cloneDeep(state.networkConfigurationsByChainId)), "f");
-}, _NetworkController_ensureAutoManagedNetworkClientRegistryPopulated = function _NetworkController_ensureAutoManagedNetworkClientRegistryPopulated() {
-    return (__classPrivateFieldSet(this, _NetworkController_autoManagedNetworkClientRegistry, __classPrivateFieldGet(this, _NetworkController_autoManagedNetworkClientRegistry, "f") ?? __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_createAutoManagedNetworkClientRegistry).call(this), "f"));
-}, _NetworkController_createAutoManagedNetworkClientRegistry = function _NetworkController_createAutoManagedNetworkClientRegistry() {
-    const chainIds = knownKeysOf(this.state.networkConfigurationsByChainId);
-    const networkClientsWithIds = chainIds.flatMap((chainId) => {
-        const networkConfiguration = this.state.networkConfigurationsByChainId[chainId];
-        const defaultFailoverUrls = __classPrivateFieldGet(this, _NetworkController_failoverUrls, "f")?.[chainId];
-        return networkConfiguration.rpcEndpoints.map((rpcEndpoint) => {
-            if (rpcEndpoint.type === RpcEndpointType.Infura) {
-                const infuraNetworkName = deriveInfuraNetworkNameFromRpcEndpointUrl(rpcEndpoint.url);
+    /**
+     * Constructs the registry of network clients based on the set of default
+     * and custom networks in state.
+     *
+     * @returns The network clients keyed by ID.
+     */
+    #createAutoManagedNetworkClientRegistry() {
+        const chainIds = knownKeysOf(this.state.networkConfigurationsByChainId);
+        const networkClientsWithIds = chainIds.flatMap((chainId) => {
+            const networkConfiguration = this.state.networkConfigurationsByChainId[chainId];
+            const defaultFailoverUrls = this.#failoverUrls?.[chainId];
+            return networkConfiguration.rpcEndpoints.map((rpcEndpoint) => {
+                if (rpcEndpoint.type === RpcEndpointType.Infura) {
+                    const infuraNetworkName = deriveInfuraNetworkNameFromRpcEndpointUrl(rpcEndpoint.url);
+                    return [
+                        rpcEndpoint.networkClientId,
+                        createAutoManagedNetworkClient({
+                            networkClientId: rpcEndpoint.networkClientId,
+                            networkClientConfiguration: {
+                                type: NetworkClientType.Infura,
+                                network: infuraNetworkName,
+                                failoverRpcUrls: defaultFailoverUrls ?? rpcEndpoint.failoverUrls,
+                                infuraProjectId: this.#infuraProjectId,
+                                chainId: networkConfiguration.chainId,
+                                ticker: networkConfiguration.nativeCurrency,
+                            },
+                            getRpcServiceOptions: this.#getRpcServiceOptions,
+                            getBlockTrackerOptions: this.#getBlockTrackerOptions,
+                            messenger: this.messenger,
+                            rpcFailoverMode: this.#rpcFailoverMode,
+                            logger: this.#log,
+                        }),
+                    ];
+                }
                 return [
                     rpcEndpoint.networkClientId,
                     createAutoManagedNetworkClient({
                         networkClientId: rpcEndpoint.networkClientId,
                         networkClientConfiguration: {
-                            type: NetworkClientType.Infura,
-                            network: infuraNetworkName,
-                            failoverRpcUrls: defaultFailoverUrls ?? rpcEndpoint.failoverUrls,
-                            infuraProjectId: __classPrivateFieldGet(this, _NetworkController_infuraProjectId, "f"),
+                            type: NetworkClientType.Custom,
                             chainId: networkConfiguration.chainId,
+                            failoverRpcUrls: defaultFailoverUrls ?? rpcEndpoint.failoverUrls,
+                            rpcUrl: rpcEndpoint.url,
                             ticker: networkConfiguration.nativeCurrency,
                         },
-                        getRpcServiceOptions: __classPrivateFieldGet(this, _NetworkController_getRpcServiceOptions, "f"),
-                        getBlockTrackerOptions: __classPrivateFieldGet(this, _NetworkController_getBlockTrackerOptions, "f"),
+                        getRpcServiceOptions: this.#getRpcServiceOptions,
+                        getBlockTrackerOptions: this.#getBlockTrackerOptions,
                         messenger: this.messenger,
-                        rpcFailoverMode: __classPrivateFieldGet(this, _NetworkController_rpcFailoverMode, "f"),
-                        logger: __classPrivateFieldGet(this, _NetworkController_log, "f"),
+                        rpcFailoverMode: this.#rpcFailoverMode,
+                        logger: this.#log,
                     }),
                 ];
-            }
-            return [
-                rpcEndpoint.networkClientId,
-                createAutoManagedNetworkClient({
-                    networkClientId: rpcEndpoint.networkClientId,
-                    networkClientConfiguration: {
-                        type: NetworkClientType.Custom,
-                        chainId: networkConfiguration.chainId,
-                        failoverRpcUrls: defaultFailoverUrls ?? rpcEndpoint.failoverUrls,
-                        rpcUrl: rpcEndpoint.url,
-                        ticker: networkConfiguration.nativeCurrency,
-                    },
-                    getRpcServiceOptions: __classPrivateFieldGet(this, _NetworkController_getRpcServiceOptions, "f"),
-                    getBlockTrackerOptions: __classPrivateFieldGet(this, _NetworkController_getBlockTrackerOptions, "f"),
-                    messenger: this.messenger,
-                    rpcFailoverMode: __classPrivateFieldGet(this, _NetworkController_rpcFailoverMode, "f"),
-                    logger: __classPrivateFieldGet(this, _NetworkController_log, "f"),
-                }),
-            ];
+            });
         });
-    });
-    return networkClientsWithIds.reduce((obj, [networkClientId, networkClient]) => {
-        return {
-            ...obj,
-            [networkClient.configuration.type]: {
-                ...obj[networkClient.configuration.type],
-                [networkClientId]: networkClient,
-            },
-        };
-    }, {
-        [NetworkClientType.Custom]: {},
-        [NetworkClientType.Infura]: {},
-    });
-}, _NetworkController_applyNetworkSelection = function _NetworkController_applyNetworkSelection(networkClientId, { updateState, } = {}) {
-    __classPrivateFieldSet(this, _NetworkController_autoManagedNetworkClient, this.getNetworkClientById(networkClientId), "f");
-    this.update((state) => {
-        var _a;
-        state.selectedNetworkClientId = networkClientId;
-        (_a = state.networksMetadata)[networkClientId] ?? (_a[networkClientId] = {
-            status: NetworkStatus.Unknown,
-            EIPS: {},
+        return networkClientsWithIds.reduce((obj, [networkClientId, networkClient]) => {
+            return {
+                ...obj,
+                [networkClient.configuration.type]: {
+                    ...obj[networkClient.configuration.type],
+                    [networkClientId]: networkClient,
+                },
+            };
+        }, {
+            [NetworkClientType.Custom]: {},
+            [NetworkClientType.Infura]: {},
         });
-        updateState?.(state);
-    });
-    if (__classPrivateFieldGet(this, _NetworkController_providerProxy, "f")) {
-        __classPrivateFieldGet(this, _NetworkController_providerProxy, "f").setTarget(__classPrivateFieldGet(this, _NetworkController_autoManagedNetworkClient, "f").provider);
-    }
-    else {
-        __classPrivateFieldSet(this, _NetworkController_providerProxy, createSwappableProxy(__classPrivateFieldGet(this, _NetworkController_autoManagedNetworkClient, "f").provider), "f");
-    }
-    if (__classPrivateFieldGet(this, _NetworkController_blockTrackerProxy, "f")) {
-        __classPrivateFieldGet(this, _NetworkController_blockTrackerProxy, "f").setTarget(__classPrivateFieldGet(this, _NetworkController_autoManagedNetworkClient, "f").blockTracker);
-    }
-    else {
-        __classPrivateFieldSet(this, _NetworkController_blockTrackerProxy, createEventEmitterProxy(__classPrivateFieldGet(this, _NetworkController_autoManagedNetworkClient, "f").blockTracker, {
-            eventFilter: 'skipInternal',
-        }), "f");
     }
-    __classPrivateFieldSet(this, _NetworkController_ethQuery, new EthQuery(__classPrivateFieldGet(this, _NetworkController_providerProxy, "f")), "f");
-}, _NetworkController_autoAddNetworksFromConfigRegistry = function _NetworkController_autoAddNetworksFromConfigRegistry(caipChainIds) {
-    for (const caipChainId of caipChainIds) {
-        try {
-            const registryNetworkConfig = this.messenger.call('ConfigRegistryController:getNetworkConfigByCaip2ChainId', caipChainId);
-            const hexChainId = numberToHex(Number(parseCaipChainId(caipChainId).reference));
-            if (!registryNetworkConfig ||
-                this.state.networkConfigurationsByChainId[hexChainId]) {
-                continue;
-            }
-            const rpcEndpoint = registryNetworkConfig.rpcProviders.default.type === 'infura'
-                ? {
-                    type: RpcEndpointType.Infura,
-                    networkClientId: registryNetworkConfig.rpcProviders.default.networkClientId,
-                    url: registryNetworkConfig.rpcProviders.default
-                        .url,
-                }
-                : {
-                    type: RpcEndpointType.Custom,
-                    url: registryNetworkConfig.rpcProviders.default.url,
-                };
-            this.addNetwork({
-                chainId: hexChainId,
-                name: registryNetworkConfig.name,
-                nativeCurrency: registryNetworkConfig.assets.native.symbol,
-                rpcEndpoints: [rpcEndpoint],
-                defaultRpcEndpointIndex: 0,
-                blockExplorerUrls: [registryNetworkConfig.blockExplorerUrls.default],
-                defaultBlockExplorerUrlIndex: 0,
+    /**
+     * Updates the global provider and block tracker proxies (accessible via
+     * {@link getSelectedNetworkClient}) to point to the same ones within the
+     * given network client, thereby magically switching any consumers using these
+     * proxies to use the new network.
+     *
+     * Also refreshes the EthQuery instance accessible via the `getEthQuery`
+     * action to wrap the provider from the new network client. Note that this is
+     * not a proxy, so consumers will need to call `getEthQuery` again after the
+     * network switch.
+     *
+     * @param networkClientId - The ID of a network client that requests will be
+     * routed through (either the name of an Infura network or the ID of a custom
+     * network configuration).
+     * @param options - Options for this method.
+     * @param options.updateState - Allows for updating state.
+     * @throws if no network client could be found matching the given ID.
+     */
+    #applyNetworkSelection(networkClientId, { updateState, } = {}) {
+        this.#autoManagedNetworkClient = this.getNetworkClientById(networkClientId);
+        this.update((state) => {
+            state.selectedNetworkClientId = networkClientId;
+            state.networksMetadata[networkClientId] ??= {
+                status: NetworkStatus.Unknown,
+                EIPS: {},
+            };
+            updateState?.(state);
+        });
+        if (this.#providerProxy) {
+            this.#providerProxy.setTarget(this.#autoManagedNetworkClient.provider);
+        }
+        else {
+            this.#providerProxy = createSwappableProxy(this.#autoManagedNetworkClient.provider);
+        }
+        if (this.#blockTrackerProxy) {
+            this.#blockTrackerProxy.setTarget(this.#autoManagedNetworkClient.blockTracker);
+        }
+        else {
+            this.#blockTrackerProxy = createEventEmitterProxy(this.#autoManagedNetworkClient.blockTracker, {
+                eventFilter: 'skipInternal',
             });
         }
-        catch (error) {
-            const capturedError = error instanceof Error ? error : new Error(String(error));
-            __classPrivateFieldGet(this, _NetworkController_log, "f")?.error(`Failed to auto-enable network for chain ID ${caipChainId}: ${capturedError}`);
-            this.messenger.captureException?.(capturedError);
+        this.#ethQuery = new EthQuery(this.#providerProxy);
+    }
+    /**
+     * Adds networks to state and registers network clients for the given CAIP-2
+     * chain IDs if they are not already present. Configurations for these
+     * networks are retrieved from ConfigRegistryController.
+     *
+     * @param caipChainIds - The CAIP-2 chain IDs of the networks to enable.
+     */
+    #autoAddNetworksFromConfigRegistry(caipChainIds) {
+        for (const caipChainId of caipChainIds) {
+            try {
+                const registryNetworkConfig = this.messenger.call('ConfigRegistryController:getNetworkConfigByCaip2ChainId', caipChainId);
+                const hexChainId = numberToHex(Number(parseCaipChainId(caipChainId).reference));
+                if (!registryNetworkConfig ||
+                    this.state.networkConfigurationsByChainId[hexChainId]) {
+                    continue;
+                }
+                const rpcEndpoint = registryNetworkConfig.rpcProviders.default.type === 'infura'
+                    ? {
+                        type: RpcEndpointType.Infura,
+                        networkClientId: registryNetworkConfig.rpcProviders.default.networkClientId,
+                        url: registryNetworkConfig.rpcProviders.default
+                            .url,
+                    }
+                    : {
+                        type: RpcEndpointType.Custom,
+                        url: registryNetworkConfig.rpcProviders.default.url,
+                    };
+                this.addNetwork({
+                    chainId: hexChainId,
+                    name: registryNetworkConfig.name,
+                    nativeCurrency: registryNetworkConfig.assets.native.symbol,
+                    rpcEndpoints: [rpcEndpoint],
+                    defaultRpcEndpointIndex: 0,
+                    blockExplorerUrls: [registryNetworkConfig.blockExplorerUrls.default],
+                    defaultBlockExplorerUrlIndex: 0,
+                });
+            }
+            catch (error) {
+                const capturedError = error instanceof Error ? error : new Error(String(error));
+                this.#log?.error(`Failed to auto-enable network for chain ID ${caipChainId}: ${capturedError}`);
+                this.messenger.captureException?.(capturedError);
+            }
         }
     }
-};
-//# sourceMappingURL=NetworkController.mjs.map
+}
+//# sourceMappingURL=NetworkController.js.map