@metamask-previews/network-controller 12.1.1-preview.d32a7cc

package/dist/NetworkController.js

@@ -0,0 +1,864 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _NetworkController_instances, _NetworkController_ethQuery, _NetworkController_infuraProjectId, _NetworkController_trackMetaMetricsEvent, _NetworkController_previousProviderConfig, _NetworkController_providerProxy, _NetworkController_provider, _NetworkController_blockTrackerProxy, _NetworkController_autoManagedNetworkClientRegistry, _NetworkController_refreshNetwork, _NetworkController_getNetworkId, _NetworkController_getLatestBlock, _NetworkController_determineEIP1559Compatibility, _NetworkController_ensureAutoManagedNetworkClientRegistryPopulated, _NetworkController_createAutoManagedNetworkClientRegistry, _NetworkController_buildIdentifiedInfuraNetworkClientConfigurations, _NetworkController_buildIdentifiedCustomNetworkClientConfigurations, _NetworkController_buildIdentifiedNetworkClientConfigurationsFromProviderConfig, _NetworkController_applyNetworkSelection;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkController = exports.defaultState = exports.knownKeysOf = void 0;
+const base_controller_1 = require("@metamask/base-controller");
+const controller_utils_1 = require("@metamask/controller-utils");
+const eth_query_1 = __importDefault(require("@metamask/eth-query"));
+const swappable_obj_proxy_1 = require("@metamask/swappable-obj-proxy");
+const utils_1 = require("@metamask/utils");
+const assert_1 = require("assert");
+const eth_rpc_errors_1 = require("eth-rpc-errors");
+const uuid_1 = require("uuid");
+const constants_1 = require("./constants");
+const create_auto_managed_network_client_1 = require("./create-auto-managed-network-client");
+const logger_1 = require("./logger");
+const types_1 = require("./types");
+const log = (0, logger_1.createModuleLogger)(logger_1.projectLogger, 'NetworkController');
+/**
+ * `Object.keys()` is intentionally generic: it returns the keys of an object,
+ * but it cannot make guarantees about the contents of that object, so the type
+ * of the keys is merely `string[]`. While this is technically accurate, it is
+ * also unnecessary if we have an object that we own and whose contents are
+ * known exactly.
+ *
+ * TODO: Move to @metamask/utils.
+ *
+ * @param object - The object.
+ * @returns The keys of an object, typed according to the type of the object
+ * itself.
+ */
+function knownKeysOf(object) {
+    return Object.keys(object);
+}
+exports.knownKeysOf = knownKeysOf;
+/**
+ * Asserts that the given value is of the given type if the given validation
+ * function returns a truthy result.
+ *
+ * @param value - The value to validate.
+ * @param validate - A function used to validate that the value is of the given
+ * type. Takes the `value` as an argument and is expected to return true or
+ * false.
+ * @param message - The message to throw if the function does not return a
+ * truthy result.
+ * @throws if the function does not return a truthy result.
+ */
+function assertOfType(value, validate, message) {
+    assert_1.strict.ok(validate(value), message);
+}
+/**
+ * Returns a portion of the given object with only the given keys.
+ *
+ * @param object - An object.
+ * @param keys - The keys to pick from the object.
+ * @returns the portion of the object.
+ */
+function pick(object, keys) {
+    const pickedObject = keys.reduce((finalObject, key) => {
+        return Object.assign(Object.assign({}, finalObject), { [key]: object[key] });
+    }, {});
+    assertOfType(pickedObject, () => keys.every((key) => key in pickedObject), 'The reduce did not produce an object with all of the desired keys.');
+    return pickedObject;
+}
+/**
+ * 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);
+}
+/**
+ * Builds an identifier for an Infura network client for lookup purposes.
+ *
+ * @param infuraNetworkOrProviderConfig - The name of an Infura network or a
+ * provider config.
+ * @returns The built identifier.
+ */
+function buildInfuraNetworkClientId(infuraNetworkOrProviderConfig) {
+    if (typeof infuraNetworkOrProviderConfig === 'string') {
+        return infuraNetworkOrProviderConfig;
+    }
+    return infuraNetworkOrProviderConfig.type;
+}
+/**
+ * Builds an identifier for a custom network client for lookup purposes.
+ *
+ * @param args - This function can be called two ways:
+ * 1. The ID of a network configuration.
+ * 2. A provider config and a set of network configurations.
+ * @returns The built identifier.
+ */
+function buildCustomNetworkClientId(...args) {
+    if (args.length === 1) {
+        return args[0];
+    }
+    const [{ id, rpcUrl }, networkConfigurations] = args;
+    if (id === undefined) {
+        const matchingNetworkConfiguration = Object.values(networkConfigurations).find((networkConfiguration) => {
+            return networkConfiguration.rpcUrl === rpcUrl.toLowerCase();
+        });
+        if (matchingNetworkConfiguration) {
+            return matchingNetworkConfiguration.id;
+        }
+        return rpcUrl.toLowerCase();
+    }
+    return id;
+}
+/**
+ * Returns whether the given provider config refers to an Infura network.
+ *
+ * @param providerConfig - The provider config.
+ * @returns True if the provider config refers to an Infura network, false
+ * otherwise.
+ */
+function isInfuraProviderConfig(providerConfig) {
+    return isInfuraProviderType(providerConfig.type);
+}
+/**
+ * Returns whether the given provider config refers to an Infura network.
+ *
+ * @param providerConfig - The provider config.
+ * @returns True if the provider config refers to an Infura network, false
+ * otherwise.
+ */
+function isCustomProviderConfig(providerConfig) {
+    return providerConfig.type === controller_utils_1.NetworkType.rpc;
+}
+/**
+ * As a provider config represents the settings that are used to interface with
+ * an RPC endpoint, it must have both a chain ID and an RPC URL if it represents
+ * a custom network. These properties _should_ be set as they are validated in
+ * the UI when a user adds a custom network, but just to be safe we validate
+ * them here.
+ *
+ * In addition, historically the `rpcUrl` property on the ProviderConfig type
+ * has been optional, even though it should not be. Making this non-optional
+ * would be a breaking change, so this function types the provider config
+ * correctly so that we don't have to check `rpcUrl` in other places.
+ *
+ * @param providerConfig - A provider config.
+ * @throws if the provider config does not have a chain ID or an RPC URL.
+ */
+function validateCustomProviderConfig(providerConfig) {
+    if (providerConfig.chainId === undefined) {
+        throw new Error('chainId must be provided for custom RPC endpoints');
+    }
+    if (providerConfig.rpcUrl === undefined) {
+        throw new Error('rpcUrl must be provided for custom RPC endpoints');
+    }
+}
+const name = 'NetworkController';
+exports.defaultState = {
+    selectedNetworkClientId: controller_utils_1.NetworkType.mainnet,
+    networkId: null,
+    providerConfig: {
+        type: controller_utils_1.NetworkType.mainnet,
+        chainId: controller_utils_1.ChainId.mainnet,
+        ticker: controller_utils_1.NetworksTicker.mainnet,
+    },
+    networksMetadata: {},
+    networkConfigurations: {},
+};
+/**
+ * Controller that creates and manages an Ethereum network provider.
+ */
+class NetworkController extends base_controller_1.BaseControllerV2 {
+    constructor({ messenger, state, infuraProjectId, trackMetaMetricsEvent, }) {
+        super({
+            name,
+            metadata: {
+                selectedNetworkClientId: {
+                    persist: true,
+                    anonymous: false,
+                },
+                networkId: {
+                    persist: true,
+                    anonymous: false,
+                },
+                networksMetadata: {
+                    persist: true,
+                    anonymous: false,
+                },
+                providerConfig: {
+                    persist: true,
+                    anonymous: false,
+                },
+                networkConfigurations: {
+                    persist: true,
+                    anonymous: false,
+                },
+            },
+            messenger,
+            state: Object.assign(Object.assign({}, exports.defaultState), state),
+        });
+        _NetworkController_instances.add(this);
+        _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_provider.set(this, void 0);
+        _NetworkController_blockTrackerProxy.set(this, void 0);
+        _NetworkController_autoManagedNetworkClientRegistry.set(this, void 0);
+        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 __classPrivateFieldGet(this, _NetworkController_ethQuery, "f");
+        });
+        __classPrivateFieldSet(this, _NetworkController_previousProviderConfig, this.state.providerConfig, "f");
+    }
+    /**
+     * Accesses the provider and block tracker for the currently selected network.
+     *
+     * @returns The proxy and block tracker proxies.
+     */
+    getProviderAndBlockTracker() {
+        return {
+            provider: __classPrivateFieldGet(this, _NetworkController_providerProxy, "f"),
+            blockTracker: __classPrivateFieldGet(this, _NetworkController_blockTrackerProxy, "f"),
+        };
+    }
+    /**
+     * Returns all of the network clients that have been created so far, keyed by
+     * their identifier in the network client registry. This collection represents
+     * not only built-in networks but also any custom networks that consumers have
+     * added.
+     *
+     * @returns The list of known network clients.
+     */
+    getNetworkClientRegistry() {
+        const autoManagedNetworkClientRegistry = __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_ensureAutoManagedNetworkClientRegistryPopulated).call(this);
+        return Object.assign({}, autoManagedNetworkClientRegistry[types_1.NetworkClientType.Infura], autoManagedNetworkClientRegistry[types_1.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);
+        if (isInfuraProviderType(networkClientId)) {
+            const infuraNetworkClient = autoManagedNetworkClientRegistry[types_1.NetworkClientType.Infura][networkClientId];
+            if (!infuraNetworkClient) {
+                throw new Error(`No Infura network client was found with the ID "${networkClientId}".`);
+            }
+            return infuraNetworkClient;
+        }
+        const customNetworkClient = autoManagedNetworkClientRegistry[types_1.NetworkClientType.Custom][networkClientId];
+        if (!customNetworkClient) {
+            throw new Error(`No custom network client was found with the ID "${networkClientId}".`);
+        }
+        return customNetworkClient;
+    }
+    /**
+     * Populates the network clients and establishes the initial network based on
+     * the provider configuration in state.
+     */
+    initializeProvider() {
+        return __awaiter(this, void 0, void 0, function* () {
+            __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_ensureAutoManagedNetworkClientRegistryPopulated).call(this);
+            __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_applyNetworkSelection).call(this);
+            yield this.lookupNetwork();
+        });
+    }
+    /**
+     * 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 (!__classPrivateFieldGet(this, _NetworkController_ethQuery, "f")) {
+                return;
+            }
+            const isInfura = isInfuraProviderConfig(this.state.providerConfig);
+            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;
+            try {
+                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;
+                    }
+                }
+                else {
+                    log('NetworkController - could not determine network status', error);
+                    updatedNetworkStatus = constants_1.NetworkStatus.Unknown;
+                }
+            }
+            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;
+                const meta = state.networksMetadata[state.selectedNetworkClientId];
+                meta.status = updatedNetworkStatus;
+                if (updatedIsEIP1559Compatible === undefined) {
+                    delete meta.EIPS[1559];
+                }
+                else {
+                    meta.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');
+            }
+        });
+    }
+    /**
+     * Convenience method to update provider network type settings.
+     *
+     * @param type - Human readable network name.
+     */
+    setProviderType(type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            assert_1.strict.notStrictEqual(type, controller_utils_1.NetworkType.rpc, `NetworkController - cannot call "setProviderType" with type "${controller_utils_1.NetworkType.rpc}". Use "setActiveNetwork"`);
+            assert_1.strict.ok(isInfuraProviderType(type), `Unknown Infura provider type "${type}".`);
+            __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';
+            __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_ensureAutoManagedNetworkClientRegistryPopulated).call(this);
+            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);
+        });
+    }
+    /**
+     * Convenience method to update provider RPC settings.
+     *
+     * @param networkConfigurationId - The unique id for the network configuration to set as the active provider.
+     */
+    setActiveNetwork(networkConfigurationId) {
+        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`);
+            }
+            __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_ensureAutoManagedNetworkClientRegistryPopulated).call(this);
+            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);
+        });
+    }
+    /**
+     * 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
+     * , false otherwise, or `undefined` if unable to determine the compatibility.
+     */
+    getEIP1559Compatibility() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!__classPrivateFieldGet(this, _NetworkController_ethQuery, "f")) {
+                return false;
+            }
+            const { EIPS } = this.state.networksMetadata[this.state.selectedNetworkClientId];
+            if (EIPS[1559] !== undefined) {
+                return EIPS[1559];
+            }
+            const isEIP1559Compatible = yield __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_determineEIP1559Compatibility).call(this);
+            this.update((state) => {
+                if (isEIP1559Compatible !== undefined) {
+                    state.networksMetadata[state.selectedNetworkClientId].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* () {
+            __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_ensureAutoManagedNetworkClientRegistryPopulated).call(this);
+            yield __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_refreshNetwork).call(this);
+        });
+    }
+    /**
+     * Adds a new custom network or updates the information for an existing
+     * network.
+     *
+     * This may involve updating the `networkConfigurations` property in
+     * state as well and/or adding a new network client to the network client
+     * registry. The `rpcUrl` and `chainId` of the given object are used to
+     * determine which action to take:
+     *
+     * - If the `rpcUrl` corresponds to an existing network configuration
+     * (case-insensitively), then it is overwritten with the object. Furthermore,
+     * if the `chainId` is different from the existing network configuration, then
+     * the existing network client is replaced with a new one.
+     * - If the `rpcUrl` does not correspond to an existing network configuration
+     * (case-insensitively), then the object is used to add a new network
+     * configuration along with a new network client.
+     *
+     * @param networkConfiguration - The network configuration to add or update.
+     * @param options - Additional configuration options.
+     * @param options.referrer - Used to create a metrics event; the site from which the call originated, or 'metamask' for internal calls.
+     * @param options.source - Used to create a metrics event; where the event originated (i.e. from a dapp or from the network form).
+     * @param options.setActive - If true, switches to the network upon adding or updating it (default: false).
+     * @returns The ID for the added or updated network configuration.
+     */
+    upsertNetworkConfiguration(networkConfiguration, { referrer, source, setActive = false, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sanitizedNetworkConfiguration = pick(networkConfiguration, ['rpcUrl', 'chainId', 'ticker', 'nickname', 'rpcPrefs']);
+            const { rpcUrl, chainId, ticker } = sanitizedNetworkConfiguration;
+            (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 (!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 autoManagedNetworkClientRegistry = __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_ensureAutoManagedNetworkClientRegistryPopulated).call(this);
+            const existingNetworkConfiguration = Object.values(this.state.networkConfigurations).find((networkConfig) => networkConfig.rpcUrl.toLowerCase() === rpcUrl.toLowerCase());
+            const upsertedNetworkConfigurationId = existingNetworkConfiguration
+                ? existingNetworkConfiguration.id
+                : (0, uuid_1.v4)();
+            const networkClientId = buildCustomNetworkClientId(upsertedNetworkConfigurationId);
+            this.update((state) => {
+                state.networkConfigurations[upsertedNetworkConfigurationId] = Object.assign({ id: upsertedNetworkConfigurationId }, sanitizedNetworkConfiguration);
+            });
+            const customNetworkClientRegistry = autoManagedNetworkClientRegistry[types_1.NetworkClientType.Custom];
+            const existingAutoManagedNetworkClient = customNetworkClientRegistry[networkClientId];
+            const shouldDestroyExistingNetworkClient = existingAutoManagedNetworkClient &&
+                existingAutoManagedNetworkClient.configuration.chainId !== chainId;
+            if (shouldDestroyExistingNetworkClient) {
+                existingAutoManagedNetworkClient.destroy();
+            }
+            if (!existingAutoManagedNetworkClient ||
+                shouldDestroyExistingNetworkClient) {
+                customNetworkClientRegistry[networkClientId] =
+                    (0, create_auto_managed_network_client_1.createAutoManagedNetworkClient)({
+                        type: types_1.NetworkClientType.Custom,
+                        chainId,
+                        rpcUrl,
+                    });
+            }
+            if (!existingNetworkConfiguration) {
+                __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(upsertedNetworkConfigurationId);
+            }
+            return upsertedNetworkConfigurationId;
+        });
+    }
+    /**
+     * Removes a custom network from state.
+     *
+     * This involves updating the `networkConfigurations` property in state as
+     * well and removing the network client that corresponds to the network from
+     * the client registry.
+     *
+     * @param networkConfigurationId - The ID of an existing network
+     * configuration.
+     */
+    removeNetworkConfiguration(networkConfigurationId) {
+        if (!this.state.networkConfigurations[networkConfigurationId]) {
+            throw new Error(`networkConfigurationId ${networkConfigurationId} does not match a configured networkConfiguration`);
+        }
+        const autoManagedNetworkClientRegistry = __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_ensureAutoManagedNetworkClientRegistryPopulated).call(this);
+        const networkClientId = buildCustomNetworkClientId(networkConfigurationId);
+        this.update((state) => {
+            delete state.networkConfigurations[networkConfigurationId];
+        });
+        const customNetworkClientRegistry = autoManagedNetworkClientRegistry[types_1.NetworkClientType.Custom];
+        const existingAutoManagedNetworkClient = customNetworkClientRegistry[networkClientId];
+        existingAutoManagedNetworkClient.destroy();
+        delete customNetworkClientRegistry[networkClientId];
+    }
+    /**
+     * Switches to the previously selected network, assuming that there is one
+     * (if not and `initializeProvider` has not been previously called, then this
+     * method is equivalent to calling `resetConnection`).
+     */
+    rollbackToPreviousProvider() {
+        return __awaiter(this, void 0, void 0, function* () {
+            __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_ensureAutoManagedNetworkClientRegistryPopulated).call(this);
+            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());
+        });
+    }
+    /**
+     * Updates the controller using the given backup data.
+     *
+     * @param backup - The data that has been backed up.
+     * @param backup.networkConfigurations - Network configurations in the backup.
+     */
+    loadBackup({ networkConfigurations, }) {
+        this.update((state) => {
+            state.networkConfigurations = Object.assign(Object.assign({}, state.networkConfigurations), networkConfigurations);
+        });
+    }
+    /**
+     * Searches for a network configuration ID with the given ChainID and returns it.
+     *
+     * @param chainId - ChainId to search for
+     * @returns networkClientId of the network configuration with the given chainId
+     */
+    findNetworkClientIdByChainId(chainId) {
+        const networkClients = this.getNetworkClientRegistry();
+        const networkClientEntry = Object.entries(networkClients).find(([_, networkClient]) => networkClient.configuration.chainId === chainId);
+        if (networkClientEntry === undefined) {
+            throw new Error("Couldn't find networkClientId for chainId");
+        }
+        return networkClientEntry[0];
+    }
+}
+exports.NetworkController = NetworkController;
+_NetworkController_ethQuery = new WeakMap(), _NetworkController_infuraProjectId = new WeakMap(), _NetworkController_trackMetaMetricsEvent = new WeakMap(), _NetworkController_previousProviderConfig = new WeakMap(), _NetworkController_providerProxy = new WeakMap(), _NetworkController_provider = new WeakMap(), _NetworkController_blockTrackerProxy = new WeakMap(), _NetworkController_autoManagedNetworkClientRegistry = new WeakMap(), _NetworkController_instances = new WeakSet(), _NetworkController_refreshNetwork = function _NetworkController_refreshNetwork() {
+    return __awaiter(this, void 0, void 0, function* () {
+        this.messagingSystem.publish('NetworkController:networkWillChange');
+        this.update((state) => {
+            state.networkId = null;
+        });
+        __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_applyNetworkSelection).call(this);
+        this.messagingSystem.publish('NetworkController:networkDidChange');
+        yield this.lookupNetwork();
+    });
+}, _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_getLatestBlock = function _NetworkController_getLatestBlock() {
+    return 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: '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);
+        if (!latestBlock) {
+            return undefined;
+        }
+        return latestBlock.baseFeePerGas !== undefined;
+    });
+}, _NetworkController_ensureAutoManagedNetworkClientRegistryPopulated = function _NetworkController_ensureAutoManagedNetworkClientRegistryPopulated() {
+    var _a;
+    const autoManagedNetworkClientRegistry = (_a = __classPrivateFieldGet(this, _NetworkController_autoManagedNetworkClientRegistry, "f")) !== null && _a !== void 0 ? _a : __classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_createAutoManagedNetworkClientRegistry).call(this);
+    __classPrivateFieldSet(this, _NetworkController_autoManagedNetworkClientRegistry, autoManagedNetworkClientRegistry, "f");
+    return autoManagedNetworkClientRegistry;
+}, _NetworkController_createAutoManagedNetworkClientRegistry = function _NetworkController_createAutoManagedNetworkClientRegistry() {
+    return [
+        ...__classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_buildIdentifiedInfuraNetworkClientConfigurations).call(this),
+        ...__classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_buildIdentifiedCustomNetworkClientConfigurations).call(this),
+        ...__classPrivateFieldGet(this, _NetworkController_instances, "m", _NetworkController_buildIdentifiedNetworkClientConfigurationsFromProviderConfig).call(this),
+    ].reduce((registry, [networkClientType, networkClientId, networkClientConfiguration]) => {
+        const autoManagedNetworkClient = (0, create_auto_managed_network_client_1.createAutoManagedNetworkClient)(networkClientConfiguration);
+        if (networkClientId in registry[networkClientType]) {
+            return registry;
+        }
+        return Object.assign(Object.assign({}, registry), { [networkClientType]: Object.assign(Object.assign({}, registry[networkClientType]), { [networkClientId]: autoManagedNetworkClient }) });
+    }, {
+        [types_1.NetworkClientType.Infura]: {},
+        [types_1.NetworkClientType.Custom]: {},
+    });
+}, _NetworkController_buildIdentifiedInfuraNetworkClientConfigurations = function _NetworkController_buildIdentifiedInfuraNetworkClientConfigurations() {
+    return knownKeysOf(controller_utils_1.InfuraNetworkType).map((network) => {
+        const networkClientId = buildInfuraNetworkClientId(network);
+        const networkClientConfiguration = {
+            type: types_1.NetworkClientType.Infura,
+            network,
+            infuraProjectId: __classPrivateFieldGet(this, _NetworkController_infuraProjectId, "f"),
+            chainId: controller_utils_1.BUILT_IN_NETWORKS[network].chainId,
+        };
+        return [
+            types_1.NetworkClientType.Infura,
+            networkClientId,
+            networkClientConfiguration,
+        ];
+    });
+}, _NetworkController_buildIdentifiedCustomNetworkClientConfigurations = function _NetworkController_buildIdentifiedCustomNetworkClientConfigurations() {
+    return Object.entries(this.state.networkConfigurations).map(([networkConfigurationId, networkConfiguration]) => {
+        if (networkConfiguration.chainId === undefined) {
+            throw new Error('chainId must be provided for custom RPC endpoints');
+        }
+        if (networkConfiguration.rpcUrl === undefined) {
+            throw new Error('rpcUrl must be provided for custom RPC endpoints');
+        }
+        const networkClientId = buildCustomNetworkClientId(networkConfigurationId);
+        const networkClientConfiguration = {
+            type: types_1.NetworkClientType.Custom,
+            chainId: networkConfiguration.chainId,
+            rpcUrl: networkConfiguration.rpcUrl,
+        };
+        return [
+            types_1.NetworkClientType.Custom,
+            networkClientId,
+            networkClientConfiguration,
+        ];
+    });
+}, _NetworkController_buildIdentifiedNetworkClientConfigurationsFromProviderConfig = function _NetworkController_buildIdentifiedNetworkClientConfigurationsFromProviderConfig() {
+    const { providerConfig } = this.state;
+    if (isCustomProviderConfig(providerConfig)) {
+        validateCustomProviderConfig(providerConfig);
+        const networkClientId = buildCustomNetworkClientId(providerConfig, this.state.networkConfigurations);
+        const networkClientConfiguration = {
+            chainId: providerConfig.chainId,
+            rpcUrl: providerConfig.rpcUrl,
+            type: types_1.NetworkClientType.Custom,
+        };
+        return [
+            [types_1.NetworkClientType.Custom, networkClientId, networkClientConfiguration],
+        ];
+    }
+    if (isInfuraProviderConfig(providerConfig)) {
+        return [];
+    }
+    throw new Error(`Unrecognized network type: '${providerConfig.type}'`);
+}, _NetworkController_applyNetworkSelection = function _NetworkController_applyNetworkSelection() {
+    if (!__classPrivateFieldGet(this, _NetworkController_autoManagedNetworkClientRegistry, "f")) {
+        throw new Error('initializeProvider must be called first in order to switch the network');
+    }
+    const { providerConfig } = this.state;
+    let autoManagedNetworkClient;
+    let networkClientId;
+    if (isInfuraProviderConfig(providerConfig)) {
+        const networkClientType = types_1.NetworkClientType.Infura;
+        networkClientId = buildInfuraNetworkClientId(providerConfig);
+        const builtInNetworkClientRegistry = __classPrivateFieldGet(this, _NetworkController_autoManagedNetworkClientRegistry, "f")[networkClientType];
+        autoManagedNetworkClient =
+            builtInNetworkClientRegistry[networkClientId];
+        if (!autoManagedNetworkClient) {
+            throw new Error(`Could not find custom network matching ${networkClientId}`);
+        }
+    }
+    else if (isCustomProviderConfig(providerConfig)) {
+        validateCustomProviderConfig(providerConfig);
+        const networkClientType = types_1.NetworkClientType.Custom;
+        networkClientId = buildCustomNetworkClientId(providerConfig, this.state.networkConfigurations);
+        const customNetworkClientRegistry = __classPrivateFieldGet(this, _NetworkController_autoManagedNetworkClientRegistry, "f")[networkClientType];
+        autoManagedNetworkClient = customNetworkClientRegistry[networkClientId];
+        if (!autoManagedNetworkClient) {
+            throw new Error(`Could not find built-in network matching ${networkClientId}`);
+        }
+    }
+    else {
+        throw new Error('Could not determine type of provider config');
+    }
+    this.update((state) => {
+        state.selectedNetworkClientId = networkClientId;
+        if (state.networksMetadata[networkClientId] === undefined) {
+            state.networksMetadata[networkClientId] = {
+                status: constants_1.NetworkStatus.Unknown,
+                EIPS: {},
+            };
+        }
+    });
+    const { provider, blockTracker } = autoManagedNetworkClient;
+    if (__classPrivateFieldGet(this, _NetworkController_providerProxy, "f")) {
+        __classPrivateFieldGet(this, _NetworkController_providerProxy, "f").setTarget(provider);
+    }
+    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);
+    }
+    else {
+        __classPrivateFieldSet(this, _NetworkController_blockTrackerProxy, (0, swappable_obj_proxy_1.createEventEmitterProxy)(blockTracker, {
+            eventFilter: 'skipInternal',
+        }), "f");
+    }
+    __classPrivateFieldSet(this, _NetworkController_ethQuery, new eth_query_1.default(__classPrivateFieldGet(this, _NetworkController_providerProxy, "f")), "f");
+};
+//# sourceMappingURL=NetworkController.js.map