@metamask/network-controller 7.0.0 → 9.0.0

package/dist/NetworkController.js

@@ -22,29 +22,76 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _NetworkController_instances, _NetworkController_previousNetworkSpecifier, _NetworkController_provider, _NetworkController_providerProxy, _NetworkController_blockTrackerProxy, _NetworkController_getNetworkId, _NetworkController_setCurrentAsPreviousProvider, _NetworkController_getLatestBlock, _NetworkController_setProviderAndBlockTracker;
+var _NetworkController_instances, _NetworkController_ethQuery, _NetworkController_infuraProjectId, _NetworkController_trackMetaMetricsEvent, _NetworkController_previousProviderConfig, _NetworkController_providerProxy, _NetworkController_blockTrackerProxy, _NetworkController_configureProvider, _NetworkController_refreshNetwork, _NetworkController_registerProvider, _NetworkController_setupInfuraProvider, _NetworkController_setupStandardProvider, _NetworkController_updateProvider, _NetworkController_getNetworkId, _NetworkController_getLatestBlock, _NetworkController_determineEIP1559Compatibility, _NetworkController_setProviderAndBlockTracker;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NetworkController = exports.defaultState = void 0;
-const eth_query_1 = __importDefault(require("eth-query"));
-const provider_1 = __importDefault(require("web3-provider-engine/subproviders/provider"));
-const createProvider_1 = __importDefault(require("eth-json-rpc-infura/src/createProvider"));
-const zero_1 = __importDefault(require("web3-provider-engine/zero"));
 const swappable_obj_proxy_1 = require("@metamask/swappable-obj-proxy");
-const async_mutex_1 = require("async-mutex");
-const uuid_1 = require("uuid");
+const eth_query_1 = __importDefault(require("eth-query"));
 const base_controller_1 = require("@metamask/base-controller");
+const uuid_1 = require("uuid");
+const eth_rpc_errors_1 = require("eth-rpc-errors");
 const controller_utils_1 = require("@metamask/controller-utils");
 const utils_1 = require("@metamask/utils");
-const LOCALHOST_RPC_URL = 'http://localhost:8545';
+const constants_1 = require("./constants");
+const logger_1 = require("./logger");
+const create_network_client_1 = require("./create-network-client");
+const log = (0, logger_1.createModuleLogger)(logger_1.projectLogger, 'NetworkController');
+/**
+ * Convert the given value into a valid network ID. The ID is accepted
+ * as either a number, a decimal string, or a 0x-prefixed hex string.
+ *
+ * @param value - The network ID to convert, in an unknown format.
+ * @returns A valid network ID (as a decimal string)
+ * @throws If the given value cannot be safely parsed.
+ */
+function convertNetworkId(value) {
+    if (typeof value === 'number' && !Number.isNaN(value)) {
+        return `${value}`;
+    }
+    else if ((0, utils_1.isStrictHexString)(value)) {
+        return `${(0, controller_utils_1.convertHexToDecimal)(value)}`;
+    }
+    else if (typeof value === 'string' && /^\d+$/u.test(value)) {
+        return value;
+    }
+    throw new Error(`Cannot parse as a valid network ID: '${value}'`);
+}
+/**
+ * Type guard for determining whether the given value is an error object with a
+ * `code` property, such as an instance of Error.
+ *
+ * TODO: Move this to @metamask/utils.
+ *
+ * @param error - The object to check.
+ * @returns True if `error` has a `code`, false otherwise.
+ */
+function isErrorWithCode(error) {
+    return typeof error === 'object' && error !== null && 'code' in error;
+}
+/**
+ * Returns whether the given argument is a type that our Infura middleware
+ * recognizes.
+ *
+ * @param type - A type to compare.
+ * @returns True or false, depending on whether the given type is one that our
+ * Infura middleware recognizes.
+ */
+function isInfuraProviderType(type) {
+    return Object.keys(controller_utils_1.InfuraNetworkType).includes(type);
+}
 const name = 'NetworkController';
 exports.defaultState = {
-    network: 'loading',
-    isCustomNetwork: false,
+    networkId: null,
+    networkStatus: constants_1.NetworkStatus.Unknown,
     providerConfig: {
         type: controller_utils_1.NetworkType.mainnet,
-        chainId: controller_utils_1.NetworksChainId.mainnet,
+        chainId: controller_utils_1.ChainId.mainnet,
+    },
+    networkDetails: {
+        EIPS: {
+            1559: false,
+        },
     },
-    networkDetails: { isEIP1559Compatible: false },
     networkConfigurations: {},
 };
 /**
@@ -55,11 +102,11 @@ class NetworkController extends base_controller_1.BaseControllerV2 {
         super({
             name,
             metadata: {
-                network: {
+                networkId: {
                     persist: true,
                     anonymous: false,
                 },
-                isCustomNetwork: {
+                networkStatus: {
                     persist: true,
                     anonymous: false,
                 },
@@ -80,42 +127,24 @@ class NetworkController extends base_controller_1.BaseControllerV2 {
             state: Object.assign(Object.assign({}, exports.defaultState), state),
         });
         _NetworkController_instances.add(this);
-        this.mutex = new async_mutex_1.Mutex();
-        _NetworkController_previousNetworkSpecifier.set(this, void 0);
-        _NetworkController_provider.set(this, void 0);
+        _NetworkController_ethQuery.set(this, void 0);
+        _NetworkController_infuraProjectId.set(this, void 0);
+        _NetworkController_trackMetaMetricsEvent.set(this, void 0);
+        _NetworkController_previousProviderConfig.set(this, void 0);
         _NetworkController_providerProxy.set(this, void 0);
         _NetworkController_blockTrackerProxy.set(this, void 0);
-        this.infuraProjectId = infuraProjectId;
-        this.trackMetaMetricsEvent = trackMetaMetricsEvent;
+        if (!infuraProjectId || typeof infuraProjectId !== 'string') {
+            throw new Error('Invalid Infura project ID');
+        }
+        __classPrivateFieldSet(this, _NetworkController_infuraProjectId, infuraProjectId, "f");
+        __classPrivateFieldSet(this, _NetworkController_trackMetaMetricsEvent, trackMetaMetricsEvent, "f");
         this.messagingSystem.registerActionHandler(`${this.name}:getProviderConfig`, () => {
             return this.state.providerConfig;
         });
         this.messagingSystem.registerActionHandler(`${this.name}:getEthQuery`, () => {
-            return this.ethQuery;
-        });
-        __classPrivateFieldSet(this, _NetworkController_previousNetworkSpecifier, this.state.providerConfig.type, "f");
-    }
-    configureProvider(type, rpcTarget, chainId, ticker, nickname) {
-        this.update((state) => {
-            state.isCustomNetwork = this.getIsCustomNetwork(chainId);
+            return __classPrivateFieldGet(this, _NetworkController_ethQuery, "f");
         });
-        switch (type) {
-            case controller_utils_1.NetworkType.mainnet:
-            case controller_utils_1.NetworkType.goerli:
-            case controller_utils_1.NetworkType.sepolia:
-                this.setupInfuraProvider(type);
-                break;
-            case controller_utils_1.NetworkType.localhost:
-                this.setupStandardProvider(LOCALHOST_RPC_URL);
-                break;
-            case controller_utils_1.NetworkType.rpc:
-                rpcTarget &&
-                    this.setupStandardProvider(rpcTarget, chainId, ticker, nickname);
-                break;
-            default:
-                throw new Error(`Unrecognized network type: '${type}'`);
-        }
-        this.getEIP1559Compatibility();
+        __classPrivateFieldSet(this, _NetworkController_previousProviderConfig, this.state.providerConfig, "f");
     }
     getProviderAndBlockTracker() {
         return {
@@ -123,69 +152,6 @@ class NetworkController extends base_controller_1.BaseControllerV2 {
             blockTracker: __classPrivateFieldGet(this, _NetworkController_blockTrackerProxy, "f"),
         };
     }
-    refreshNetwork() {
-        this.update((state) => {
-            state.network = 'loading';
-            state.networkDetails = {};
-        });
-        const { rpcTarget, type, chainId, ticker } = this.state.providerConfig;
-        this.configureProvider(type, rpcTarget, chainId, ticker);
-        this.lookupNetwork();
-    }
-    registerProvider() {
-        const { provider } = this.getProviderAndBlockTracker();
-        if (provider) {
-            provider.on('error', this.verifyNetwork.bind(this));
-            this.ethQuery = new eth_query_1.default(provider);
-        }
-    }
-    setupInfuraProvider(type) {
-        const infuraProvider = (0, createProvider_1.default)({
-            network: type,
-            projectId: this.infuraProjectId,
-        });
-        const infuraSubprovider = new provider_1.default(infuraProvider);
-        const config = {
-            dataSubprovider: infuraSubprovider,
-            engineParams: {
-                blockTrackerProvider: infuraProvider,
-                pollingInterval: 12000,
-            },
-        };
-        this.updateProvider((0, zero_1.default)(config));
-    }
-    getIsCustomNetwork(chainId) {
-        return (chainId !== controller_utils_1.NetworksChainId.mainnet &&
-            chainId !== controller_utils_1.NetworksChainId.goerli &&
-            chainId !== controller_utils_1.NetworksChainId.sepolia &&
-            chainId !== controller_utils_1.NetworksChainId.localhost);
-    }
-    setupStandardProvider(rpcTarget, chainId, ticker, nickname) {
-        const config = {
-            chainId,
-            engineParams: { pollingInterval: 12000 },
-            nickname,
-            rpcUrl: rpcTarget,
-            ticker,
-        };
-        this.updateProvider((0, zero_1.default)(config));
-    }
-    updateProvider(provider) {
-        this.safelyStopProvider(__classPrivateFieldGet(this, _NetworkController_provider, "f"));
-        __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_setProviderAndBlockTracker).call(this, {
-            provider,
-            blockTracker: provider._blockTracker,
-        });
-        this.registerProvider();
-    }
-    safelyStopProvider(provider) {
-        setTimeout(() => {
-            provider === null || provider === void 0 ? void 0 : provider.stop();
-        }, 500);
-    }
-    verifyNetwork() {
-        this.state.network === 'loading' && this.lookupNetwork();
-    }
     /**
      * Method to inilialize the provider,
      * Creates the provider and block tracker for the configured network,
@@ -193,39 +159,101 @@ class NetworkController extends base_controller_1.BaseControllerV2 {
      *
      */
     initializeProvider() {
-        const { type, rpcTarget, chainId, ticker, nickname } = this.state.providerConfig;
-        this.configureProvider(type, rpcTarget, chainId, ticker, nickname);
-        this.registerProvider();
-        this.lookupNetwork();
+        return __awaiter(this, void 0, void 0, function* () {
+            const { type, rpcUrl, chainId } = this.state.providerConfig;
+            __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_configureProvider).call(this, type, rpcUrl, chainId);
+            __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_registerProvider).call(this);
+            yield this.lookupNetwork();
+        });
     }
     /**
-     * Refreshes the current network code.
+     * Performs side effects after switching to a network. If the network is
+     * available, updates the network state with the network ID of the network and
+     * stores whether the network supports EIP-1559; otherwise clears said
+     * information about the network that may have been previously stored.
+     *
+     * @fires infuraIsBlocked if the network is Infura-supported and is blocking
+     * requests.
+     * @fires infuraIsUnblocked if the network is Infura-supported and is not
+     * blocking requests, or if the network is not Infura-supported.
      */
     lookupNetwork() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.ethQuery) {
+            if (!__classPrivateFieldGet(this, _NetworkController_ethQuery, "f")) {
                 return;
             }
-            const releaseLock = yield this.mutex.acquire();
+            const isInfura = isInfuraProviderType(this.state.providerConfig.type);
+            let networkChanged = false;
+            const listener = () => {
+                networkChanged = true;
+                this.messagingSystem.unsubscribe('NetworkController:networkDidChange', listener);
+            };
+            this.messagingSystem.subscribe('NetworkController:networkDidChange', listener);
+            let updatedNetworkStatus;
+            let updatedNetworkId = null;
+            let updatedIsEIP1559Compatible = false;
             try {
-                try {
-                    const networkId = yield __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_getNetworkId).call(this);
-                    if (this.state.network === networkId) {
-                        return;
+                const [networkId, isEIP1559Compatible] = yield Promise.all([
+                    __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_getNetworkId).call(this),
+                    __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_determineEIP1559Compatibility).call(this),
+                ]);
+                updatedNetworkStatus = constants_1.NetworkStatus.Available;
+                updatedNetworkId = networkId;
+                updatedIsEIP1559Compatible = isEIP1559Compatible;
+            }
+            catch (error) {
+                if (isErrorWithCode(error)) {
+                    let responseBody;
+                    if (isInfura &&
+                        (0, utils_1.hasProperty)(error, 'message') &&
+                        typeof error.message === 'string') {
+                        try {
+                            responseBody = JSON.parse(error.message);
+                        }
+                        catch (_a) {
+                            // error.message must not be JSON
+                        }
+                    }
+                    if ((0, utils_1.isPlainObject)(responseBody) &&
+                        responseBody.error === constants_1.INFURA_BLOCKED_KEY) {
+                        updatedNetworkStatus = constants_1.NetworkStatus.Blocked;
+                    }
+                    else if (error.code === eth_rpc_errors_1.errorCodes.rpc.internal) {
+                        updatedNetworkStatus = constants_1.NetworkStatus.Unknown;
+                    }
+                    else {
+                        updatedNetworkStatus = constants_1.NetworkStatus.Unavailable;
                     }
-                    this.update((state) => {
-                        state.network = networkId;
-                    });
                 }
-                catch (_error) {
-                    this.update((state) => {
-                        state.network = 'loading';
-                    });
+                else {
+                    log('NetworkController - could not determine network status', error);
+                    updatedNetworkStatus = constants_1.NetworkStatus.Unknown;
                 }
-                this.messagingSystem.publish(`NetworkController:providerConfigChange`, this.state.providerConfig);
             }
-            finally {
-                releaseLock();
+            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;
+            }
+            this.messagingSystem.unsubscribe('NetworkController:networkDidChange', listener);
+            this.update((state) => {
+                state.networkId = updatedNetworkId;
+                state.networkStatus = updatedNetworkStatus;
+                state.networkDetails.EIPS[1559] = updatedIsEIP1559Compatible;
+            });
+            if (isInfura) {
+                if (updatedNetworkStatus === constants_1.NetworkStatus.Available) {
+                    this.messagingSystem.publish('NetworkController:infuraIsUnblocked');
+                }
+                else if (updatedNetworkStatus === constants_1.NetworkStatus.Blocked) {
+                    this.messagingSystem.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.messagingSystem.publish('NetworkController:infuraIsUnblocked');
             }
         });
     }
@@ -235,21 +263,23 @@ class NetworkController extends base_controller_1.BaseControllerV2 {
      * @param type - Human readable network name.
      */
     setProviderType(type) {
-        __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_setCurrentAsPreviousProvider).call(this);
-        // If testnet the ticker symbol should use a testnet prefix
-        const ticker = type in controller_utils_1.NetworksTicker && controller_utils_1.NetworksTicker[type].length > 0
-            ? controller_utils_1.NetworksTicker[type]
-            : 'ETH';
-        this.update((state) => {
-            state.providerConfig.type = type;
-            state.providerConfig.ticker = ticker;
-            state.providerConfig.chainId = controller_utils_1.NetworksChainId[type];
-            state.providerConfig.rpcPrefs = controller_utils_1.BUILT_IN_NETWORKS[type].rpcPrefs;
-            state.providerConfig.rpcTarget = undefined;
-            state.providerConfig.nickname = undefined;
-            state.providerConfig.id = undefined;
+        return __awaiter(this, void 0, void 0, function* () {
+            __classPrivateFieldSet(this, _NetworkController_previousProviderConfig, this.state.providerConfig, "f");
+            // If testnet the ticker symbol should use a testnet prefix
+            const ticker = type in controller_utils_1.NetworksTicker && controller_utils_1.NetworksTicker[type].length > 0
+                ? controller_utils_1.NetworksTicker[type]
+                : 'ETH';
+            this.update((state) => {
+                state.providerConfig.type = type;
+                state.providerConfig.ticker = ticker;
+                state.providerConfig.chainId = controller_utils_1.ChainId[type];
+                state.providerConfig.rpcPrefs = controller_utils_1.BUILT_IN_NETWORKS[type].rpcPrefs;
+                state.providerConfig.rpcUrl = undefined;
+                state.providerConfig.nickname = undefined;
+                state.providerConfig.id = undefined;
+            });
+            yield __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_refreshNetwork).call(this);
         });
-        this.refreshNetwork();
     }
     /**
      * Convenience method to update provider RPC settings.
@@ -257,38 +287,55 @@ class NetworkController extends base_controller_1.BaseControllerV2 {
      * @param networkConfigurationId - The unique id for the network configuration to set as the active provider.
      */
     setActiveNetwork(networkConfigurationId) {
-        __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_setCurrentAsPreviousProvider).call(this);
-        const targetNetwork = this.state.networkConfigurations[networkConfigurationId];
-        if (!targetNetwork) {
-            throw new Error(`networkConfigurationId ${networkConfigurationId} does not match a configured networkConfiguration`);
-        }
-        this.update((state) => {
-            state.providerConfig.type = controller_utils_1.NetworkType.rpc;
-            state.providerConfig.rpcTarget = targetNetwork.rpcUrl;
-            state.providerConfig.chainId = targetNetwork.chainId;
-            state.providerConfig.ticker = targetNetwork.ticker;
-            state.providerConfig.nickname = targetNetwork.nickname;
-            state.providerConfig.rpcPrefs = targetNetwork.rpcPrefs;
-            state.providerConfig.id = targetNetwork.id;
+        return __awaiter(this, void 0, void 0, function* () {
+            __classPrivateFieldSet(this, _NetworkController_previousProviderConfig, this.state.providerConfig, "f");
+            const targetNetwork = this.state.networkConfigurations[networkConfigurationId];
+            if (!targetNetwork) {
+                throw new Error(`networkConfigurationId ${networkConfigurationId} does not match a configured networkConfiguration`);
+            }
+            this.update((state) => {
+                state.providerConfig.type = controller_utils_1.NetworkType.rpc;
+                state.providerConfig.rpcUrl = targetNetwork.rpcUrl;
+                state.providerConfig.chainId = targetNetwork.chainId;
+                state.providerConfig.ticker = targetNetwork.ticker;
+                state.providerConfig.nickname = targetNetwork.nickname;
+                state.providerConfig.rpcPrefs = targetNetwork.rpcPrefs;
+                state.providerConfig.id = targetNetwork.id;
+            });
+            yield __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_refreshNetwork).call(this);
         });
-        this.refreshNetwork();
     }
+    /**
+     * Determines whether the network supports EIP-1559 by checking whether the
+     * latest block has a `baseFeePerGas` property, then updates state
+     * appropriately.
+     *
+     * @returns A promise that resolves to true if the network supports EIP-1559
+     * and false otherwise.
+     */
     getEIP1559Compatibility() {
         return __awaiter(this, void 0, void 0, function* () {
-            const { networkDetails = {} } = this.state;
-            if (networkDetails.isEIP1559Compatible || !this.ethQuery) {
+            const { networkDetails = { EIPS: {} } } = this.state;
+            if (networkDetails.EIPS[1559] || !__classPrivateFieldGet(this, _NetworkController_ethQuery, "f")) {
                 return true;
             }
-            const latestBlock = yield __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_getLatestBlock).call(this);
-            const isEIP1559Compatible = typeof latestBlock.baseFeePerGas !== 'undefined';
-            if (networkDetails.isEIP1559Compatible !== isEIP1559Compatible) {
+            const isEIP1559Compatible = yield __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_determineEIP1559Compatibility).call(this);
+            if (networkDetails.EIPS[1559] !== isEIP1559Compatible) {
                 this.update((state) => {
-                    state.networkDetails.isEIP1559Compatible = isEIP1559Compatible;
+                    state.networkDetails.EIPS[1559] = isEIP1559Compatible;
                 });
             }
             return isEIP1559Compatible;
         });
     }
+    /**
+     * Re-initializes the provider and block tracker for the current network.
+     */
+    resetConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_refreshNetwork).call(this);
+        });
+    }
     /**
      * Adds a network configuration if the rpcUrl is not already present on an
      * existing network configuration. Otherwise updates the entry with the matching rpcUrl.
@@ -307,59 +354,60 @@ class NetworkController extends base_controller_1.BaseControllerV2 {
      */
     upsertNetworkConfiguration({ rpcUrl, chainId, ticker, nickname, rpcPrefs }, { setActive = false, referrer, source, }) {
         var _a;
-        (0, utils_1.assertIsStrictHexString)(chainId);
-        if (!(0, controller_utils_1.isSafeChainId)(parseInt(chainId, 16))) {
-            throw new Error(`Invalid chain ID "${chainId}": numerical value greater than max safe value.`);
-        }
-        if (!rpcUrl) {
-            throw new Error('An rpcUrl is required to add or update network configuration');
-        }
-        if (!referrer || !source) {
-            throw new Error('referrer and source are required arguments for adding or updating a network configuration');
-        }
-        try {
-            // eslint-disable-next-line no-new
-            new URL(rpcUrl);
-        }
-        catch (e) {
-            if (e.message.includes('Invalid URL')) {
-                throw new Error('rpcUrl must be a valid URL');
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, utils_1.assertIsStrictHexString)(chainId);
+            if (!(0, controller_utils_1.isSafeChainId)(chainId)) {
+                throw new Error(`Invalid chain ID "${chainId}": numerical value greater than max safe value.`);
             }
-        }
-        if (!ticker) {
-            throw new Error('A ticker is required to add or update networkConfiguration');
-        }
-        const newNetworkConfiguration = {
-            rpcUrl,
-            chainId,
-            ticker,
-            nickname,
-            rpcPrefs,
-        };
-        const oldNetworkConfigurations = this.state.networkConfigurations;
-        const oldNetworkConfigurationId = (_a = Object.values(oldNetworkConfigurations).find((networkConfiguration) => { var _a; return ((_a = networkConfiguration.rpcUrl) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === (rpcUrl === null || rpcUrl === void 0 ? void 0 : rpcUrl.toLowerCase()); })) === null || _a === void 0 ? void 0 : _a.id;
-        const newNetworkConfigurationId = oldNetworkConfigurationId || (0, uuid_1.v4)();
-        this.update((state) => {
-            state.networkConfigurations = Object.assign(Object.assign({}, oldNetworkConfigurations), { [newNetworkConfigurationId]: Object.assign(Object.assign({}, newNetworkConfiguration), { id: newNetworkConfigurationId }) });
-        });
-        if (!oldNetworkConfigurationId) {
-            this.trackMetaMetricsEvent({
-                event: 'Custom Network Added',
-                category: 'Network',
-                referrer: {
-                    url: referrer,
-                },
-                properties: {
-                    chain_id: chainId,
-                    symbol: ticker,
-                    source,
-                },
+            if (!rpcUrl) {
+                throw new Error('An rpcUrl is required to add or update network configuration');
+            }
+            if (!referrer || !source) {
+                throw new Error('referrer and source are required arguments for adding or updating a network configuration');
+            }
+            try {
+                new URL(rpcUrl);
+            }
+            catch (e) {
+                if (e.message.includes('Invalid URL')) {
+                    throw new Error('rpcUrl must be a valid URL');
+                }
+            }
+            if (!ticker) {
+                throw new Error('A ticker is required to add or update networkConfiguration');
+            }
+            const newNetworkConfiguration = {
+                rpcUrl,
+                chainId,
+                ticker,
+                nickname,
+                rpcPrefs,
+            };
+            const oldNetworkConfigurations = this.state.networkConfigurations;
+            const oldNetworkConfigurationId = (_a = Object.values(oldNetworkConfigurations).find((networkConfiguration) => { var _a; return ((_a = networkConfiguration.rpcUrl) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === (rpcUrl === null || rpcUrl === void 0 ? void 0 : rpcUrl.toLowerCase()); })) === null || _a === void 0 ? void 0 : _a.id;
+            const newNetworkConfigurationId = oldNetworkConfigurationId || (0, uuid_1.v4)();
+            this.update((state) => {
+                state.networkConfigurations = Object.assign(Object.assign({}, oldNetworkConfigurations), { [newNetworkConfigurationId]: Object.assign(Object.assign({}, newNetworkConfiguration), { id: newNetworkConfigurationId }) });
             });
-        }
-        if (setActive) {
-            this.setActiveNetwork(newNetworkConfigurationId);
-        }
-        return newNetworkConfigurationId;
+            if (!oldNetworkConfigurationId) {
+                __classPrivateFieldGet(this, _NetworkController_trackMetaMetricsEvent, "f").call(this, {
+                    event: 'Custom Network Added',
+                    category: 'Network',
+                    referrer: {
+                        url: referrer,
+                    },
+                    properties: {
+                        chain_id: chainId,
+                        symbol: ticker,
+                        source,
+                    },
+                });
+            }
+            if (setActive) {
+                yield this.setActiveNetwork(newNetworkConfigurationId);
+            }
+            return newNetworkConfigurationId;
+        });
     }
     /**
      * Removes network configuration from state.
@@ -375,51 +423,128 @@ class NetworkController extends base_controller_1.BaseControllerV2 {
         });
     }
     /**
-     * Rolls back provider config to the previous provider in case of errors or inability to connect during network switch.
+     * Switches to the previous network, assuming that the current network is
+     * different than the initial network (if it is, then this is equivalent to
+     * calling `resetConnection`).
      */
     rollbackToPreviousProvider() {
-        const specifier = __classPrivateFieldGet(this, _NetworkController_previousNetworkSpecifier, "f");
-        if ((0, controller_utils_1.isNetworkType)(specifier)) {
-            this.setProviderType(specifier);
-        }
-        else if (typeof specifier === 'string') {
-            this.setActiveNetwork(specifier);
-        }
+        return __awaiter(this, void 0, void 0, function* () {
+            this.update((state) => {
+                state.providerConfig = __classPrivateFieldGet(this, _NetworkController_previousProviderConfig, "f");
+            });
+            yield __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_refreshNetwork).call(this);
+        });
+    }
+    /**
+     * Deactivates the controller, stopping any ongoing polling.
+     *
+     * In-progress requests will not be aborted.
+     */
+    destroy() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            yield ((_a = __classPrivateFieldGet(this, _NetworkController_blockTrackerProxy, "f")) === null || _a === void 0 ? void 0 : _a.destroy());
+        });
     }
 }
 exports.NetworkController = NetworkController;
-_NetworkController_previousNetworkSpecifier = new WeakMap(), _NetworkController_provider = new WeakMap(), _NetworkController_providerProxy = new WeakMap(), _NetworkController_blockTrackerProxy = new WeakMap(), _NetworkController_instances = new WeakSet(), _NetworkController_getNetworkId = function _NetworkController_getNetworkId() {
+_NetworkController_ethQuery = new WeakMap(), _NetworkController_infuraProjectId = new WeakMap(), _NetworkController_trackMetaMetricsEvent = new WeakMap(), _NetworkController_previousProviderConfig = new WeakMap(), _NetworkController_providerProxy = new WeakMap(), _NetworkController_blockTrackerProxy = new WeakMap(), _NetworkController_instances = new WeakSet(), _NetworkController_configureProvider = function _NetworkController_configureProvider(type, rpcUrl, chainId) {
+    switch (type) {
+        case controller_utils_1.NetworkType.mainnet:
+        case controller_utils_1.NetworkType.goerli:
+        case controller_utils_1.NetworkType.sepolia:
+            __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_setupInfuraProvider).call(this, type);
+            break;
+        case controller_utils_1.NetworkType.rpc:
+            if (chainId === undefined) {
+                throw new Error('chainId must be provided for custom RPC endpoints');
+            }
+            if (rpcUrl === undefined) {
+                throw new Error('rpcUrl must be provided for custom RPC endpoints');
+            }
+            __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_setupStandardProvider).call(this, rpcUrl, chainId);
+            break;
+        default:
+            throw new Error(`Unrecognized network type: '${type}'`);
+    }
+}, _NetworkController_refreshNetwork = function _NetworkController_refreshNetwork() {
     return __awaiter(this, void 0, void 0, function* () {
-        return yield new Promise((resolve, reject) => {
-            this.ethQuery.sendAsync({ method: 'net_version' }, (error, result) => {
+        this.messagingSystem.publish('NetworkController:networkWillChange');
+        this.update((state) => {
+            state.networkId = null;
+            state.networkStatus = constants_1.NetworkStatus.Unknown;
+            state.networkDetails = {
+                EIPS: {},
+            };
+        });
+        const { rpcUrl, type, chainId } = this.state.providerConfig;
+        __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_configureProvider).call(this, type, rpcUrl, chainId);
+        this.messagingSystem.publish('NetworkController:networkDidChange');
+        yield this.lookupNetwork();
+    });
+}, _NetworkController_registerProvider = function _NetworkController_registerProvider() {
+    const { provider } = this.getProviderAndBlockTracker();
+    if (provider) {
+        __classPrivateFieldSet(this, _NetworkController_ethQuery, new eth_query_1.default(provider), "f");
+    }
+}, _NetworkController_setupInfuraProvider = function _NetworkController_setupInfuraProvider(type) {
+    const { provider, blockTracker } = (0, create_network_client_1.createNetworkClient)({
+        network: type,
+        infuraProjectId: __classPrivateFieldGet(this, _NetworkController_infuraProjectId, "f"),
+        type: create_network_client_1.NetworkClientType.Infura,
+    });
+    __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_updateProvider).call(this, provider, blockTracker);
+}, _NetworkController_setupStandardProvider = function _NetworkController_setupStandardProvider(rpcUrl, chainId) {
+    const { provider, blockTracker } = (0, create_network_client_1.createNetworkClient)({
+        chainId,
+        rpcUrl,
+        type: create_network_client_1.NetworkClientType.Custom,
+    });
+    __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_updateProvider).call(this, provider, blockTracker);
+}, _NetworkController_updateProvider = function _NetworkController_updateProvider(provider, blockTracker) {
+    __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_setProviderAndBlockTracker).call(this, {
+        provider,
+        blockTracker,
+    });
+    __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_registerProvider).call(this);
+}, _NetworkController_getNetworkId = function _NetworkController_getNetworkId() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const possibleNetworkId = yield new Promise((resolve, reject) => {
+            if (!__classPrivateFieldGet(this, _NetworkController_ethQuery, "f")) {
+                throw new Error('Provider has not been initialized');
+            }
+            __classPrivateFieldGet(this, _NetworkController_ethQuery, "f").sendAsync({ method: 'net_version' }, (error, result) => {
                 if (error) {
                     reject(error);
                 }
                 else {
+                    // TODO: Validate this type
                     resolve(result);
                 }
             });
         });
+        return convertNetworkId(possibleNetworkId);
     });
-}, _NetworkController_setCurrentAsPreviousProvider = function _NetworkController_setCurrentAsPreviousProvider() {
-    const { type, id } = this.state.providerConfig;
-    if (type === controller_utils_1.NetworkType.rpc && id) {
-        __classPrivateFieldSet(this, _NetworkController_previousNetworkSpecifier, id, "f");
-    }
-    else {
-        __classPrivateFieldSet(this, _NetworkController_previousNetworkSpecifier, type, "f");
-    }
 }, _NetworkController_getLatestBlock = function _NetworkController_getLatestBlock() {
     return new Promise((resolve, reject) => {
-        this.ethQuery.sendAsync({ method: 'eth_getBlockByNumber', params: ['latest', false] }, (error, block) => {
+        if (!__classPrivateFieldGet(this, _NetworkController_ethQuery, "f")) {
+            throw new Error('Provider has not been initialized');
+        }
+        __classPrivateFieldGet(this, _NetworkController_ethQuery, "f").sendAsync({ method: 'eth_getBlockByNumber', params: ['latest', false] }, (error, block) => {
             if (error) {
                 reject(error);
             }
             else {
+                // TODO: Validate this type
                 resolve(block);
             }
         });
     });
+}, _NetworkController_determineEIP1559Compatibility = function _NetworkController_determineEIP1559Compatibility() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const latestBlock = yield __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_getLatestBlock).call(this);
+        return (latestBlock === null || latestBlock === void 0 ? void 0 : latestBlock.baseFeePerGas) !== undefined;
+    });
 }, _NetworkController_setProviderAndBlockTracker = function _NetworkController_setProviderAndBlockTracker({ provider, blockTracker, }) {
     if (__classPrivateFieldGet(this, _NetworkController_providerProxy, "f")) {
         __classPrivateFieldGet(this, _NetworkController_providerProxy, "f").setTarget(provider);
@@ -427,7 +552,6 @@ _NetworkController_previousNetworkSpecifier = new WeakMap(), _NetworkController_
     else {
         __classPrivateFieldSet(this, _NetworkController_providerProxy, (0, swappable_obj_proxy_1.createEventEmitterProxy)(provider), "f");
     }
-    __classPrivateFieldSet(this, _NetworkController_provider, provider, "f");
     if (__classPrivateFieldGet(this, _NetworkController_blockTrackerProxy, "f")) {
         __classPrivateFieldGet(this, _NetworkController_blockTrackerProxy, "f").setTarget(blockTracker);
     }