@metamask-previews/network-controller 20.2.0-preview-b5937ee4 → 20.2.0-preview-b59ee0c8

package/dist/chunk-YJXBTFAE.mjs

@@ -0,0 +1,1467 @@
+import {
+  INFURA_BLOCKED_KEY
+} from "./chunk-2QJYHWIP.mjs";
+import {
+  createAutoManagedNetworkClient
+} from "./chunk-TZA3CBEI.mjs";
+import {
+  createModuleLogger,
+  projectLogger
+} from "./chunk-VTLOAS2R.mjs";
+import {
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet
+} from "./chunk-XUI43LEZ.mjs";
+
+// src/NetworkController.ts
+import { BaseController } from "@metamask/base-controller";
+import {
+  InfuraNetworkType,
+  NetworkType,
+  isSafeChainId,
+  isInfuraNetworkType,
+  ChainId,
+  NetworksTicker,
+  NetworkNickname
+} from "@metamask/controller-utils";
+import EthQuery from "@metamask/eth-query";
+import { errorCodes } from "@metamask/rpc-errors";
+import { createEventEmitterProxy } from "@metamask/swappable-obj-proxy";
+import { isStrictHexString, hasProperty, isPlainObject } from "@metamask/utils";
+import { strict as assert } from "assert";
+import * as URI from "uri-js";
+import { inspect } from "util";
+import { v4 as uuidV4 } from "uuid";
+var debugLog = createModuleLogger(projectLogger, "NetworkController");
+var INFURA_URL_REGEX = /^https:\/\/(?<networkName>[^.]+)\.infura\.io\/v\d+\/(?<apiKey>.+)$/u;
+var RpcEndpointType = /* @__PURE__ */ ((RpcEndpointType2) => {
+  RpcEndpointType2["Custom"] = "custom";
+  RpcEndpointType2["Infura"] = "infura";
+  return RpcEndpointType2;
+})(RpcEndpointType || {});
+function knownKeysOf(object) {
+  return Object.keys(object);
+}
+function isErrorWithCode(error) {
+  return typeof error === "object" && error !== null && "code" in error;
+}
+var controllerName = "NetworkController";
+function getDefaultNetworkConfigurationsByChainId() {
+  return Object.values(InfuraNetworkType).reduce((obj, infuraNetworkType) => {
+    const chainId = ChainId[infuraNetworkType];
+    const rpcEndpointUrl = (
+      // False negative - this is a string.
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `https://${infuraNetworkType}.infura.io/v3/{infuraProjectId}`
+    );
+    const networkConfiguration = {
+      blockExplorerUrls: [],
+      chainId,
+      defaultRpcEndpointIndex: 0,
+      name: NetworkNickname[infuraNetworkType],
+      nativeCurrency: NetworksTicker[infuraNetworkType],
+      rpcEndpoints: [
+        {
+          networkClientId: infuraNetworkType,
+          type: "infura" /* Infura */,
+          url: rpcEndpointUrl
+        }
+      ]
+    };
+    return { ...obj, [chainId]: networkConfiguration };
+  }, {});
+}
+function getDefaultNetworkControllerState() {
+  const networksMetadata = {};
+  const networkConfigurationsByChainId = getDefaultNetworkConfigurationsByChainId();
+  return {
+    selectedNetworkClientId: InfuraNetworkType.mainnet,
+    networksMetadata,
+    networkConfigurationsByChainId
+  };
+}
+function isValidUrl(url) {
+  const uri = URI.parse(url);
+  return uri.error === void 0 && (uri.scheme === "http" || uri.scheme === "https");
+}
+function deriveInfuraNetworkNameFromRpcEndpointUrl(rpcEndpointUrl) {
+  const match = INFURA_URL_REGEX.exec(rpcEndpointUrl);
+  if (match?.groups) {
+    if (isInfuraNetworkType(match.groups.networkName)) {
+      return match.groups.networkName;
+    }
+    throw new Error(`Unknown Infura network '${match.groups.networkName}'`);
+  }
+  throw new Error("Could not derive Infura network from RPC endpoint URL");
+}
+function validateNetworkControllerState(state) {
+  const networkConfigurationEntries = Object.entries(
+    state.networkConfigurationsByChainId
+  );
+  const networkClientIds = Object.values(
+    state.networkConfigurationsByChainId
+  ).flatMap(
+    (networkConfiguration) => networkConfiguration.rpcEndpoints.map(
+      (rpcEndpoint) => rpcEndpoint.networkClientId
+    )
+  );
+  if (networkConfigurationEntries.length === 0) {
+    throw new Error(
+      "NetworkController state is invalid: `networkConfigurationsByChainId` cannot be empty"
+    );
+  }
+  for (const [chainId, networkConfiguration] of networkConfigurationEntries) {
+    if (chainId !== networkConfiguration.chainId) {
+      throw new Error(
+        `NetworkController state has invalid \`networkConfigurationsByChainId\`: Network configuration '${networkConfiguration.name}' is filed under '${chainId}' which does not match its \`chainId\` of '${networkConfiguration.chainId}'`
+      );
+    }
+    const isInvalidDefaultBlockExplorerUrlIndex = networkConfiguration.blockExplorerUrls.length > 0 ? networkConfiguration.defaultBlockExplorerUrlIndex === void 0 || networkConfiguration.blockExplorerUrls[networkConfiguration.defaultBlockExplorerUrlIndex] === void 0 : networkConfiguration.defaultBlockExplorerUrlIndex !== void 0;
+    if (isInvalidDefaultBlockExplorerUrlIndex) {
+      throw new Error(
+        `NetworkController state has invalid \`networkConfigurationsByChainId\`: Network configuration '${networkConfiguration.name}' has a \`defaultBlockExplorerUrlIndex\` that does not refer to an entry in \`blockExplorerUrls\``
+      );
+    }
+    if (networkConfiguration.rpcEndpoints[networkConfiguration.defaultRpcEndpointIndex] === void 0) {
+      throw new Error(
+        `NetworkController state has invalid \`networkConfigurationsByChainId\`: Network configuration '${networkConfiguration.name}' has a \`defaultRpcEndpointIndex\` that does not refer to an entry in \`rpcEndpoints\``
+      );
+    }
+  }
+  if ([...new Set(networkClientIds)].length < networkClientIds.length) {
+    throw new Error(
+      "NetworkController state has invalid `networkConfigurationsByChainId`: Every RPC endpoint across all network configurations must have a unique `networkClientId`"
+    );
+  }
+  if (!networkClientIds.includes(state.selectedNetworkClientId)) {
+    throw new Error(
+      `NetworkController state is invalid: \`selectedNetworkClientId\` ${inspect(
+        state.selectedNetworkClientId
+      )} does not refer to an RPC endpoint within a network configuration`
+    );
+  }
+}
+function buildNetworkConfigurationsByNetworkClientId(networkConfigurationsByChainId) {
+  return new Map(
+    Object.values(networkConfigurationsByChainId).flatMap(
+      (networkConfiguration) => {
+        return networkConfiguration.rpcEndpoints.map((rpcEndpoint) => {
+          return [rpcEndpoint.networkClientId, networkConfiguration];
+        });
+      }
+    )
+  );
+}
+var _ethQuery, _infuraProjectId, _previouslySelectedNetworkClientId, _providerProxy, _blockTrackerProxy, _autoManagedNetworkClientRegistry, _autoManagedNetworkClient, _log, _networkConfigurationsByNetworkClientId, _refreshNetwork, refreshNetwork_fn, _getLatestBlock, getLatestBlock_fn, _determineEIP1559Compatibility, determineEIP1559Compatibility_fn, _validateNetworkFields, validateNetworkFields_fn, _determineNetworkConfigurationToPersist, determineNetworkConfigurationToPersist_fn, _registerNetworkClientsAsNeeded, registerNetworkClientsAsNeeded_fn, _unregisterNetworkClientsAsNeeded, unregisterNetworkClientsAsNeeded_fn, _updateNetworkConfigurations, updateNetworkConfigurations_fn, _ensureAutoManagedNetworkClientRegistryPopulated, ensureAutoManagedNetworkClientRegistryPopulated_fn, _createAutoManagedNetworkClientRegistry, createAutoManagedNetworkClientRegistry_fn, _applyNetworkSelection, applyNetworkSelection_fn;
+var NetworkController = class extends BaseController {
+  constructor({
+    messenger,
+    state,
+    infuraProjectId,
+    log
+  }) {
+    const initialState = { ...getDefaultNetworkControllerState(), ...state };
+    validateNetworkControllerState(initialState);
+    if (!infuraProjectId || typeof infuraProjectId !== "string") {
+      throw new Error("Invalid Infura project ID");
+    }
+    super({
+      name: controllerName,
+      metadata: {
+        selectedNetworkClientId: {
+          persist: true,
+          anonymous: false
+        },
+        networksMetadata: {
+          persist: true,
+          anonymous: false
+        },
+        networkConfigurationsByChainId: {
+          persist: true,
+          anonymous: false
+        }
+      },
+      messenger,
+      state: initialState
+    });
+    /**
+     * 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.
+     */
+    __privateAdd(this, _refreshNetwork);
+    /**
+     * 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.
+     */
+    __privateAdd(this, _getLatestBlock);
+    /**
+     * 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.
+     */
+    __privateAdd(this, _determineEIP1559Compatibility);
+    /**
+     * Ensure that the given fields which will be used to either add or update a
+     * network are valid.
+     *
+     * @param args - The arguments.
+     */
+    __privateAdd(this, _validateNetworkFields);
+    /**
+     * 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.
+     */
+    __privateAdd(this, _determineNetworkConfigurationToPersist);
+    /**
+     * 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.
+     */
+    __privateAdd(this, _registerNetworkClientsAsNeeded);
+    /**
+     * 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.
+     */
+    __privateAdd(this, _unregisterNetworkClientsAsNeeded);
+    /**
+     * 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.
+     */
+    __privateAdd(this, _updateNetworkConfigurations);
+    /**
+     * 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.
+     */
+    __privateAdd(this, _ensureAutoManagedNetworkClientRegistryPopulated);
+    /**
+     * Constructs the registry of network clients based on the set of default
+     * and custom networks in state.
+     *
+     * @returns The network clients keyed by ID.
+     */
+    __privateAdd(this, _createAutoManagedNetworkClientRegistry);
+    /**
+     * 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.
+     */
+    __privateAdd(this, _applyNetworkSelection);
+    __privateAdd(this, _ethQuery, void 0);
+    __privateAdd(this, _infuraProjectId, void 0);
+    __privateAdd(this, _previouslySelectedNetworkClientId, void 0);
+    __privateAdd(this, _providerProxy, void 0);
+    __privateAdd(this, _blockTrackerProxy, void 0);
+    __privateAdd(this, _autoManagedNetworkClientRegistry, void 0);
+    __privateAdd(this, _autoManagedNetworkClient, void 0);
+    __privateAdd(this, _log, void 0);
+    __privateAdd(this, _networkConfigurationsByNetworkClientId, void 0);
+    __privateSet(this, _infuraProjectId, infuraProjectId);
+    __privateSet(this, _log, log);
+    __privateSet(this, _previouslySelectedNetworkClientId, this.state.selectedNetworkClientId);
+    __privateSet(this, _networkConfigurationsByNetworkClientId, buildNetworkConfigurationsByNetworkClientId(
+      this.state.networkConfigurationsByChainId
+    ));
+    this.messagingSystem.registerActionHandler(
+      // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `${this.name}:getEthQuery`,
+      () => {
+        return __privateGet(this, _ethQuery);
+      }
+    );
+    this.messagingSystem.registerActionHandler(
+      // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `${this.name}:getNetworkClientById`,
+      this.getNetworkClientById.bind(this)
+    );
+    this.messagingSystem.registerActionHandler(
+      // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `${this.name}:getEIP1559Compatibility`,
+      this.getEIP1559Compatibility.bind(this)
+    );
+    this.messagingSystem.registerActionHandler(
+      // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `${this.name}:setActiveNetwork`,
+      this.setActiveNetwork.bind(this)
+    );
+    this.messagingSystem.registerActionHandler(
+      // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `${this.name}:setProviderType`,
+      this.setProviderType.bind(this)
+    );
+    this.messagingSystem.registerActionHandler(
+      // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `${this.name}:findNetworkClientIdByChainId`,
+      this.findNetworkClientIdByChainId.bind(this)
+    );
+    this.messagingSystem.registerActionHandler(
+      // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `${this.name}:getNetworkConfigurationByChainId`,
+      this.getNetworkConfigurationByChainId.bind(this)
+    );
+    this.messagingSystem.registerActionHandler(
+      // ESLint is mistaken here; `name` is a string.
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `${this.name}:getNetworkConfigurationByNetworkClientId`,
+      this.getNetworkConfigurationByNetworkClientId.bind(this)
+    );
+    this.messagingSystem.registerActionHandler(
+      // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `${this.name}:getSelectedNetworkClient`,
+      this.getSelectedNetworkClient.bind(this)
+    );
+  }
+  /**
+   * Accesses the provider and block tracker for the currently selected network.
+   * @returns The proxy and block tracker proxies.
+   * @deprecated This method has been replaced by `getSelectedNetworkClient` (which has a more easily used return type) and will be removed in a future release.
+   */
+  getProviderAndBlockTracker() {
+    return {
+      provider: __privateGet(this, _providerProxy),
+      blockTracker: __privateGet(this, _blockTrackerProxy)
+    };
+  }
+  /**
+   * Accesses the provider and block tracker for the currently selected network.
+   *
+   * @returns an object with the provider and block tracker proxies for the currently selected network.
+   */
+  getSelectedNetworkClient() {
+    if (__privateGet(this, _providerProxy) && __privateGet(this, _blockTrackerProxy)) {
+      return {
+        provider: __privateGet(this, _providerProxy),
+        blockTracker: __privateGet(this, _blockTrackerProxy)
+      };
+    }
+    return void 0;
+  }
+  /**
+   * Internally, the Infura and custom network clients are categorized by type
+   * so that when accessing either kind of network client, TypeScript knows
+   * which type to assign to the network client. For some cases it's more useful
+   * to be able to access network clients by ID instead of by type and then ID,
+   * so this function makes that possible.
+   *
+   * @returns The network clients registered so far, keyed by ID.
+   */
+  getNetworkClientRegistry() {
+    const autoManagedNetworkClientRegistry = __privateMethod(this, _ensureAutoManagedNetworkClientRegistryPopulated, ensureAutoManagedNetworkClientRegistryPopulated_fn).call(this);
+    return Object.assign(
+      {},
+      autoManagedNetworkClientRegistry["infura" /* Infura */],
+      autoManagedNetworkClientRegistry["custom" /* Custom */]
+    );
+  }
+  getNetworkClientById(networkClientId) {
+    if (!networkClientId) {
+      throw new Error("No network client ID was provided.");
+    }
+    const autoManagedNetworkClientRegistry = __privateMethod(this, _ensureAutoManagedNetworkClientRegistryPopulated, ensureAutoManagedNetworkClientRegistryPopulated_fn).call(this);
+    if (isInfuraNetworkType(networkClientId)) {
+      const infuraNetworkClient = autoManagedNetworkClientRegistry["infura" /* Infura */][networkClientId];
+      if (!infuraNetworkClient) {
+        throw new Error(
+          // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+          // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+          `No Infura network client was found with the ID "${networkClientId}".`
+        );
+      }
+      return infuraNetworkClient;
+    }
+    const customNetworkClient = autoManagedNetworkClientRegistry["custom" /* Custom */][networkClientId];
+    if (!customNetworkClient) {
+      throw new Error(
+        // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+        `No custom network client was found with the ID "${networkClientId}".`
+      );
+    }
+    return customNetworkClient;
+  }
+  /**
+   * Ensures that network clients for Infura and custom RPC endpoints have been
+   * created. Then, consulting state, initializes and establishes the currently
+   * selected network client.
+   */
+  async initializeProvider() {
+    __privateMethod(this, _applyNetworkSelection, applyNetworkSelection_fn).call(this, this.state.selectedNetworkClientId);
+    await this.lookupNetwork();
+  }
+  /**
+   * Refreshes the network meta with EIP-1559 support and the network status
+   * based on the given network client ID.
+   *
+   * @param networkClientId - The ID of the network client to update.
+   */
+  async lookupNetworkByClientId(networkClientId) {
+    const isInfura = isInfuraNetworkType(networkClientId);
+    let updatedNetworkStatus;
+    let updatedIsEIP1559Compatible;
+    try {
+      updatedIsEIP1559Compatible = await __privateMethod(this, _determineEIP1559Compatibility, determineEIP1559Compatibility_fn).call(this, networkClientId);
+      updatedNetworkStatus = "available" /* Available */;
+    } catch (error) {
+      debugLog("NetworkController: lookupNetworkByClientId: ", error);
+      if (isErrorWithCode(error)) {
+        let responseBody;
+        if (isInfura && hasProperty(error, "message") && typeof error.message === "string") {
+          try {
+            responseBody = JSON.parse(error.message);
+          } catch {
+            __privateGet(this, _log)?.warn(
+              "NetworkController: lookupNetworkByClientId: json parse error: ",
+              error
+            );
+          }
+        }
+        if (isPlainObject(responseBody) && responseBody.error === INFURA_BLOCKED_KEY) {
+          updatedNetworkStatus = "blocked" /* Blocked */;
+        } else if (error.code === errorCodes.rpc.internal) {
+          updatedNetworkStatus = "unknown" /* Unknown */;
+          __privateGet(this, _log)?.warn(
+            "NetworkController: lookupNetworkByClientId: rpc internal error: ",
+            error
+          );
+        } else {
+          updatedNetworkStatus = "unavailable" /* Unavailable */;
+          __privateGet(this, _log)?.warn(
+            "NetworkController: lookupNetworkByClientId: ",
+            error
+          );
+        }
+      } else if (typeof Error !== "undefined" && hasProperty(error, "message") && typeof error.message === "string" && error.message.includes(
+        "No custom network client was found with the ID"
+      )) {
+        throw error;
+      } else {
+        debugLog(
+          "NetworkController - could not determine network status",
+          error
+        );
+        updatedNetworkStatus = "unknown" /* Unknown */;
+        __privateGet(this, _log)?.warn("NetworkController: lookupNetworkByClientId: ", error);
+      }
+    }
+    this.update((state) => {
+      if (state.networksMetadata[networkClientId] === void 0) {
+        state.networksMetadata[networkClientId] = {
+          status: "unknown" /* Unknown */,
+          EIPS: {}
+        };
+      }
+      const meta = state.networksMetadata[networkClientId];
+      meta.status = updatedNetworkStatus;
+      if (updatedIsEIP1559Compatible === void 0) {
+        delete meta.EIPS[1559];
+      } else {
+        meta.EIPS[1559] = updatedIsEIP1559Compatible;
+      }
+    });
+  }
+  /**
+   * Persists the following metadata about the given or selected network to
+   * state:
+   *
+   * - The status of the network, namely, whether it is available, geo-blocked
+   * (Infura only), or unavailable, or whether the status is unknown
+   * - Whether the network supports EIP-1559, or whether it is unknown
+   *
+   * Note that it is possible for the network to be switched while this data is
+   * being collected. If that is the case, no metadata for the (now previously)
+   * selected network will be updated.
+   *
+   * @param networkClientId - The ID of the network client to update.
+   * If no ID is provided, uses the currently selected network.
+   */
+  async lookupNetwork(networkClientId) {
+    if (networkClientId) {
+      await this.lookupNetworkByClientId(networkClientId);
+      return;
+    }
+    if (!__privateGet(this, _ethQuery)) {
+      return;
+    }
+    const isInfura = __privateGet(this, _autoManagedNetworkClient)?.configuration.type === "infura" /* Infura */;
+    let networkChanged = false;
+    const listener = () => {
+      networkChanged = true;
+      this.messagingSystem.unsubscribe(
+        "NetworkController:networkDidChange",
+        listener
+      );
+    };
+    this.messagingSystem.subscribe(
+      "NetworkController:networkDidChange",
+      listener
+    );
+    let updatedNetworkStatus;
+    let updatedIsEIP1559Compatible;
+    try {
+      const isEIP1559Compatible = await __privateMethod(this, _determineEIP1559Compatibility, determineEIP1559Compatibility_fn).call(this, this.state.selectedNetworkClientId);
+      updatedNetworkStatus = "available" /* Available */;
+      updatedIsEIP1559Compatible = isEIP1559Compatible;
+    } catch (error) {
+      if (isErrorWithCode(error)) {
+        let responseBody;
+        if (isInfura && hasProperty(error, "message") && typeof error.message === "string") {
+          try {
+            responseBody = JSON.parse(error.message);
+          } catch (parseError) {
+            __privateGet(this, _log)?.warn(
+              "NetworkController: lookupNetwork: json parse error",
+              parseError
+            );
+          }
+        }
+        if (isPlainObject(responseBody) && responseBody.error === INFURA_BLOCKED_KEY) {
+          updatedNetworkStatus = "blocked" /* Blocked */;
+        } else if (error.code === errorCodes.rpc.internal) {
+          updatedNetworkStatus = "unknown" /* Unknown */;
+          __privateGet(this, _log)?.warn(
+            "NetworkController: lookupNetwork: rpc internal error",
+            error
+          );
+        } else {
+          updatedNetworkStatus = "unavailable" /* Unavailable */;
+          __privateGet(this, _log)?.warn("NetworkController: lookupNetwork: ", error);
+        }
+      } else {
+        debugLog(
+          "NetworkController - could not determine network status",
+          error
+        );
+        updatedNetworkStatus = "unknown" /* Unknown */;
+        __privateGet(this, _log)?.warn("NetworkController: lookupNetwork: ", error);
+      }
+    }
+    if (networkChanged) {
+      return;
+    }
+    this.messagingSystem.unsubscribe(
+      "NetworkController:networkDidChange",
+      listener
+    );
+    this.update((state) => {
+      const meta = state.networksMetadata[state.selectedNetworkClientId];
+      meta.status = updatedNetworkStatus;
+      if (updatedIsEIP1559Compatible === void 0) {
+        delete meta.EIPS[1559];
+      } else {
+        meta.EIPS[1559] = updatedIsEIP1559Compatible;
+      }
+    });
+    if (isInfura) {
+      if (updatedNetworkStatus === "available" /* Available */) {
+        this.messagingSystem.publish("NetworkController:infuraIsUnblocked");
+      } else if (updatedNetworkStatus === "blocked" /* Blocked */) {
+        this.messagingSystem.publish("NetworkController:infuraIsBlocked");
+      }
+    } else {
+      this.messagingSystem.publish("NetworkController:infuraIsUnblocked");
+    }
+  }
+  /**
+   * Convenience method to update provider network type settings.
+   *
+   * @param type - Human readable network name.
+   * @deprecated This has been replaced by `setActiveNetwork`, and will be
+   * removed in a future release
+   */
+  async setProviderType(type) {
+    assert.notStrictEqual(
+      type,
+      NetworkType.rpc,
+      // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `NetworkController - cannot call "setProviderType" with type "${NetworkType.rpc}". Use "setActiveNetwork"`
+    );
+    assert.ok(
+      isInfuraNetworkType(type),
+      // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `Unknown Infura provider type "${type}".`
+    );
+    await this.setActiveNetwork(type);
+  }
+  /**
+   * Changes the selected network.
+   *
+   * @param networkClientId - The ID of a network client that will be used to
+   * make requests.
+   * @param options - Options for this method.
+   * @param options.updateState - Allows for updating state.
+   * @throws if no network client is associated with the given
+   * network client ID.
+   */
+  async setActiveNetwork(networkClientId, options = {}) {
+    __privateSet(this, _previouslySelectedNetworkClientId, this.state.selectedNetworkClientId);
+    await __privateMethod(this, _refreshNetwork, refreshNetwork_fn).call(this, networkClientId, options);
+  }
+  /**
+   * Determines whether the network supports EIP-1559 by checking whether the
+   * latest block has a `baseFeePerGas` property, then updates state
+   * appropriately.
+   *
+   * @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 determine the compatibility.
+   */
+  async getEIP1559Compatibility(networkClientId) {
+    if (networkClientId) {
+      return this.get1559CompatibilityWithNetworkClientId(networkClientId);
+    }
+    if (!__privateGet(this, _ethQuery)) {
+      return false;
+    }
+    const { EIPS } = this.state.networksMetadata[this.state.selectedNetworkClientId];
+    if (EIPS[1559] !== void 0) {
+      return EIPS[1559];
+    }
+    const isEIP1559Compatible = await __privateMethod(this, _determineEIP1559Compatibility, determineEIP1559Compatibility_fn).call(this, this.state.selectedNetworkClientId);
+    this.update((state) => {
+      if (isEIP1559Compatible !== void 0) {
+        state.networksMetadata[state.selectedNetworkClientId].EIPS[1559] = isEIP1559Compatible;
+      }
+    });
+    return isEIP1559Compatible;
+  }
+  async get1559CompatibilityWithNetworkClientId(networkClientId) {
+    let metadata = this.state.networksMetadata[networkClientId];
+    if (metadata === void 0) {
+      await this.lookupNetwork(networkClientId);
+      metadata = this.state.networksMetadata[networkClientId];
+    }
+    const { EIPS } = metadata;
+    return EIPS[1559];
+  }
+  /**
+   * Ensures that the provider and block tracker proxies are pointed to the
+   * currently selected network and refreshes the metadata for the
+   */
+  async resetConnection() {
+    await __privateMethod(this, _refreshNetwork, refreshNetwork_fn).call(this, this.state.selectedNetworkClientId);
+  }
+  /**
+   * Returns the network configuration that has been filed under the given chain
+   * ID.
+   *
+   * @param chainId - The chain ID to use as a key.
+   * @returns The network configuration if one exists, or undefined.
+   */
+  getNetworkConfigurationByChainId(chainId) {
+    return this.state.networkConfigurationsByChainId[chainId];
+  }
+  /**
+   * Returns the network configuration that contains an RPC endpoint with the
+   * given network client ID.
+   *
+   * @param networkClientId - The network client ID to use as a key.
+   * @returns The network configuration if one exists, or undefined.
+   */
+  getNetworkConfigurationByNetworkClientId(networkClientId) {
+    return __privateGet(this, _networkConfigurationsByNetworkClientId).get(networkClientId);
+  }
+  /**
+   * Creates and registers network clients for the collection of Infura and
+   * custom RPC endpoints that can be used to make requests for a particular
+   * chain, storing the given configuration object in state for later reference.
+   *
+   * @param fields - The object that describes the new network/chain and lists
+   * the RPC endpoints which front that chain.
+   * @returns The newly added network configuration.
+   * @throws if any part of `fields` would produce invalid state.
+   * @see {@link NetworkConfiguration}
+   */
+  addNetwork(fields) {
+    const { rpcEndpoints: setOfRpcEndpointFields } = fields;
+    const autoManagedNetworkClientRegistry = __privateMethod(this, _ensureAutoManagedNetworkClientRegistryPopulated, ensureAutoManagedNetworkClientRegistryPopulated_fn).call(this);
+    __privateMethod(this, _validateNetworkFields, validateNetworkFields_fn).call(this, {
+      mode: "add",
+      networkFields: fields,
+      autoManagedNetworkClientRegistry
+    });
+    const networkClientOperations = setOfRpcEndpointFields.map(
+      (defaultOrCustomRpcEndpointFields) => {
+        const rpcEndpoint = defaultOrCustomRpcEndpointFields.type === "custom" /* Custom */ ? {
+          ...defaultOrCustomRpcEndpointFields,
+          networkClientId: uuidV4()
+        } : defaultOrCustomRpcEndpointFields;
+        return {
+          type: "add",
+          rpcEndpoint
+        };
+      }
+    );
+    const newNetworkConfiguration = __privateMethod(this, _determineNetworkConfigurationToPersist, determineNetworkConfigurationToPersist_fn).call(this, {
+      networkFields: fields,
+      networkClientOperations
+    });
+    __privateMethod(this, _registerNetworkClientsAsNeeded, registerNetworkClientsAsNeeded_fn).call(this, {
+      networkFields: fields,
+      networkClientOperations,
+      autoManagedNetworkClientRegistry
+    });
+    this.update((state) => {
+      __privateMethod(this, _updateNetworkConfigurations, updateNetworkConfigurations_fn).call(this, {
+        state,
+        mode: "add",
+        networkFields: fields,
+        networkConfigurationToPersist: newNetworkConfiguration
+      });
+    });
+    this.messagingSystem.publish(
+      `${controllerName}:networkAdded`,
+      newNetworkConfiguration
+    );
+    return newNetworkConfiguration;
+  }
+  /**
+   * Updates the configuration for a previously stored network filed under the
+   * given chain ID, creating + registering new network clients to represent RPC
+   * endpoints that have been added and destroying + unregistering existing
+   * network clients for RPC endpoints that have been removed.
+   *
+   * Note that if `chainId` is changed, then all network clients associated with
+   * that chain will be removed and re-added, even if none of the RPC endpoints
+   * have changed.
+   *
+   * @param chainId - The chain ID associated with an existing network.
+   * @param fields - The object that describes the updates to the network/chain,
+   * including the new set of RPC endpoints which should front that chain.
+   * @param options - Options to provide.
+   * @param options.replacementSelectedRpcEndpointIndex - Usually you cannot
+   * remove an RPC endpoint that is being represented by the currently selected
+   * network client. This option allows you to specify another RPC endpoint
+   * (either an existing one or a new one) that should be used to select a new
+   * network instead.
+   * @returns The updated network configuration.
+   * @throws if `chainId` does not refer to an existing network configuration,
+   * if any part of `fields` would produce invalid state, etc.
+   * @see {@link NetworkConfiguration}
+   */
+  async updateNetwork(chainId, fields, {
+    replacementSelectedRpcEndpointIndex
+  } = {}) {
+    const existingNetworkConfiguration = this.state.networkConfigurationsByChainId[chainId];
+    if (existingNetworkConfiguration === void 0) {
+      throw new Error(
+        `Could not update network: Cannot find network configuration for chain ${inspect(
+          chainId
+        )}`
+      );
+    }
+    const existingChainId = chainId;
+    const { chainId: newChainId, rpcEndpoints: setOfNewRpcEndpointFields } = fields;
+    const autoManagedNetworkClientRegistry = __privateMethod(this, _ensureAutoManagedNetworkClientRegistryPopulated, ensureAutoManagedNetworkClientRegistryPopulated_fn).call(this);
+    __privateMethod(this, _validateNetworkFields, validateNetworkFields_fn).call(this, {
+      mode: "update",
+      networkFields: fields,
+      existingNetworkConfiguration,
+      autoManagedNetworkClientRegistry
+    });
+    const networkClientOperations = [];
+    for (const newRpcEndpointFields of setOfNewRpcEndpointFields) {
+      const existingRpcEndpointForNoop = existingNetworkConfiguration.rpcEndpoints.find((rpcEndpoint) => {
+        return rpcEndpoint.type === newRpcEndpointFields.type && rpcEndpoint.url === newRpcEndpointFields.url && (rpcEndpoint.networkClientId === newRpcEndpointFields.networkClientId || newRpcEndpointFields.networkClientId === void 0);
+      });
+      const existingRpcEndpointForReplaceWhenChainChanged = existingNetworkConfiguration.rpcEndpoints.find((rpcEndpoint) => {
+        return rpcEndpoint.type === "infura" /* Infura */ && newRpcEndpointFields.type === "infura" /* Infura */ || rpcEndpoint.type === newRpcEndpointFields.type && rpcEndpoint.networkClientId === newRpcEndpointFields.networkClientId && rpcEndpoint.url === newRpcEndpointFields.url;
+      });
+      const existingRpcEndpointForReplaceWhenChainNotChanged = existingNetworkConfiguration.rpcEndpoints.find((rpcEndpoint) => {
+        return rpcEndpoint.type === newRpcEndpointFields.type && (rpcEndpoint.url === newRpcEndpointFields.url || rpcEndpoint.networkClientId === newRpcEndpointFields.networkClientId);
+      });
+      if (newChainId !== existingChainId && existingRpcEndpointForReplaceWhenChainChanged !== void 0) {
+        const newRpcEndpoint = newRpcEndpointFields.type === "infura" /* Infura */ ? newRpcEndpointFields : { ...newRpcEndpointFields, networkClientId: uuidV4() };
+        networkClientOperations.push({
+          type: "replace",
+          oldRpcEndpoint: existingRpcEndpointForReplaceWhenChainChanged,
+          newRpcEndpoint
+        });
+      } else if (existingRpcEndpointForNoop !== void 0) {
+        let newRpcEndpoint;
+        if (existingRpcEndpointForNoop.type === "infura" /* Infura */) {
+          newRpcEndpoint = existingRpcEndpointForNoop;
+        } else {
+          newRpcEndpoint = Object.assign({}, newRpcEndpointFields, {
+            networkClientId: existingRpcEndpointForNoop.networkClientId
+          });
+        }
+        networkClientOperations.push({
+          type: "noop",
+          rpcEndpoint: newRpcEndpoint
+        });
+      } else if (existingRpcEndpointForReplaceWhenChainNotChanged !== void 0) {
+        let newRpcEndpoint;
+        if (newRpcEndpointFields.type === "infura" /* Infura */) {
+          newRpcEndpoint = newRpcEndpointFields;
+        } else {
+          newRpcEndpoint = {
+            ...newRpcEndpointFields,
+            networkClientId: uuidV4()
+          };
+        }
+        networkClientOperations.push({
+          type: "replace",
+          oldRpcEndpoint: existingRpcEndpointForReplaceWhenChainNotChanged,
+          newRpcEndpoint
+        });
+      } else {
+        const newRpcEndpoint = newRpcEndpointFields.type === "infura" /* Infura */ ? newRpcEndpointFields : { ...newRpcEndpointFields, networkClientId: uuidV4() };
+        const networkClientOperation = {
+          type: "add",
+          rpcEndpoint: newRpcEndpoint
+        };
+        networkClientOperations.push(networkClientOperation);
+      }
+    }
+    for (const existingRpcEndpoint of existingNetworkConfiguration.rpcEndpoints) {
+      if (!networkClientOperations.some((networkClientOperation) => {
+        const otherRpcEndpoint = networkClientOperation.type === "replace" ? networkClientOperation.oldRpcEndpoint : networkClientOperation.rpcEndpoint;
+        return otherRpcEndpoint.type === existingRpcEndpoint.type && otherRpcEndpoint.networkClientId === existingRpcEndpoint.networkClientId && otherRpcEndpoint.url === existingRpcEndpoint.url;
+      })) {
+        const networkClientOperation = {
+          type: "remove",
+          rpcEndpoint: existingRpcEndpoint
+        };
+        networkClientOperations.push(networkClientOperation);
+      }
+    }
+    const updatedNetworkConfiguration = __privateMethod(this, _determineNetworkConfigurationToPersist, determineNetworkConfigurationToPersist_fn).call(this, {
+      networkFields: fields,
+      networkClientOperations
+    });
+    if (replacementSelectedRpcEndpointIndex === void 0 && networkClientOperations.some((networkClientOperation) => {
+      return networkClientOperation.type === "remove" && networkClientOperation.rpcEndpoint.networkClientId === this.state.selectedNetworkClientId;
+    }) && !networkClientOperations.some((networkClientOperation) => {
+      return networkClientOperation.type === "replace" && networkClientOperation.oldRpcEndpoint.networkClientId === this.state.selectedNetworkClientId;
+    })) {
+      throw new Error(
+        // False negative - this is a string.
+        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+        `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.`
+      );
+    }
+    __privateMethod(this, _registerNetworkClientsAsNeeded, registerNetworkClientsAsNeeded_fn).call(this, {
+      networkFields: fields,
+      networkClientOperations,
+      autoManagedNetworkClientRegistry
+    });
+    const replacementSelectedRpcEndpointWithIndex = networkClientOperations.map(
+      (networkClientOperation, index) => [networkClientOperation, index]
+    ).find(([networkClientOperation, _index]) => {
+      return networkClientOperation.type === "replace" && networkClientOperation.oldRpcEndpoint.networkClientId === this.state.selectedNetworkClientId;
+    });
+    const correctedReplacementSelectedRpcEndpointIndex = replacementSelectedRpcEndpointIndex ?? replacementSelectedRpcEndpointWithIndex?.[1];
+    let rpcEndpointToSelect;
+    if (correctedReplacementSelectedRpcEndpointIndex !== void 0) {
+      rpcEndpointToSelect = updatedNetworkConfiguration.rpcEndpoints[correctedReplacementSelectedRpcEndpointIndex];
+      if (rpcEndpointToSelect === void 0) {
+        throw new Error(
+          `Could not update network: \`replacementSelectedRpcEndpointIndex\` ${correctedReplacementSelectedRpcEndpointIndex} does not refer to an entry in \`rpcEndpoints\``
+        );
+      }
+    }
+    if (rpcEndpointToSelect && rpcEndpointToSelect.networkClientId !== this.state.selectedNetworkClientId) {
+      await this.setActiveNetwork(rpcEndpointToSelect.networkClientId, {
+        updateState: (state) => {
+          __privateMethod(this, _updateNetworkConfigurations, updateNetworkConfigurations_fn).call(this, {
+            state,
+            mode: "update",
+            networkFields: fields,
+            networkConfigurationToPersist: updatedNetworkConfiguration,
+            existingNetworkConfiguration
+          });
+        }
+      });
+    } else {
+      this.update((state) => {
+        __privateMethod(this, _updateNetworkConfigurations, updateNetworkConfigurations_fn).call(this, {
+          state,
+          mode: "update",
+          networkFields: fields,
+          networkConfigurationToPersist: updatedNetworkConfiguration,
+          existingNetworkConfiguration
+        });
+      });
+    }
+    __privateMethod(this, _unregisterNetworkClientsAsNeeded, unregisterNetworkClientsAsNeeded_fn).call(this, {
+      networkClientOperations,
+      autoManagedNetworkClientRegistry
+    });
+    return updatedNetworkConfiguration;
+  }
+  /**
+   * Destroys and unregisters the network identified by the given chain ID, also
+   * removing the associated network configuration from state.
+   *
+   * @param chainId - The chain ID associated with an existing network.
+   * @throws if `chainId` does not refer to an existing network configuration,
+   * or if the currently selected network is being removed.
+   * @see {@link NetworkConfiguration}
+   */
+  removeNetwork(chainId) {
+    const existingNetworkConfiguration = this.state.networkConfigurationsByChainId[chainId];
+    if (existingNetworkConfiguration === void 0) {
+      throw new Error(
+        `Cannot find network configuration for chain ${inspect(chainId)}`
+      );
+    }
+    if (existingNetworkConfiguration.rpcEndpoints.some(
+      (rpcEndpoint) => rpcEndpoint.networkClientId === this.state.selectedNetworkClientId
+    )) {
+      throw new Error(`Cannot remove the currently selected network`);
+    }
+    const autoManagedNetworkClientRegistry = __privateMethod(this, _ensureAutoManagedNetworkClientRegistryPopulated, ensureAutoManagedNetworkClientRegistryPopulated_fn).call(this);
+    const networkClientOperations = existingNetworkConfiguration.rpcEndpoints.map((rpcEndpoint) => {
+      return {
+        type: "remove",
+        rpcEndpoint
+      };
+    });
+    __privateMethod(this, _unregisterNetworkClientsAsNeeded, unregisterNetworkClientsAsNeeded_fn).call(this, {
+      networkClientOperations,
+      autoManagedNetworkClientRegistry
+    });
+    this.update((state) => {
+      __privateMethod(this, _updateNetworkConfigurations, updateNetworkConfigurations_fn).call(this, {
+        state,
+        mode: "remove",
+        existingNetworkConfiguration
+      });
+    });
+  }
+  /**
+   * Assuming that the network has been previously switched, switches to this
+   * new network.
+   *
+   * If the network has not been previously switched, this method is equivalent
+   * to {@link resetConnection}.
+   */
+  async rollbackToPreviousProvider() {
+    await __privateMethod(this, _refreshNetwork, refreshNetwork_fn).call(this, __privateGet(this, _previouslySelectedNetworkClientId));
+  }
+  /**
+   * Deactivates the controller, stopping any ongoing polling.
+   *
+   * In-progress requests will not be aborted.
+   */
+  async destroy() {
+    await __privateGet(this, _blockTrackerProxy)?.destroy();
+  }
+  /**
+   * Merges the given backup data into controller state.
+   *
+   * @param backup - The data that has been backed up.
+   * @param backup.networkConfigurationsByChainId - Network configurations,
+   * keyed by chain ID.
+   */
+  loadBackup({
+    networkConfigurationsByChainId
+  }) {
+    this.update((state) => {
+      state.networkConfigurationsByChainId = {
+        ...state.networkConfigurationsByChainId,
+        ...networkConfigurationsByChainId
+      };
+    });
+  }
+  /**
+   * 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 === void 0) {
+      throw new Error("Couldn't find networkClientId for chainId");
+    }
+    return networkClientEntry[0];
+  }
+};
+_ethQuery = new WeakMap();
+_infuraProjectId = new WeakMap();
+_previouslySelectedNetworkClientId = new WeakMap();
+_providerProxy = new WeakMap();
+_blockTrackerProxy = new WeakMap();
+_autoManagedNetworkClientRegistry = new WeakMap();
+_autoManagedNetworkClient = new WeakMap();
+_log = new WeakMap();
+_networkConfigurationsByNetworkClientId = new WeakMap();
+_refreshNetwork = new WeakSet();
+refreshNetwork_fn = async function(networkClientId, options = {}) {
+  this.messagingSystem.publish(
+    "NetworkController:networkWillChange",
+    this.state
+  );
+  __privateMethod(this, _applyNetworkSelection, applyNetworkSelection_fn).call(this, networkClientId, options);
+  this.messagingSystem.publish(
+    "NetworkController:networkDidChange",
+    this.state
+  );
+  await this.lookupNetwork();
+};
+_getLatestBlock = new WeakSet();
+getLatestBlock_fn = function(networkClientId) {
+  if (networkClientId === void 0) {
+    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) {
+          reject(error);
+        } else {
+          resolve(block);
+        }
+      }
+    );
+  });
+};
+_determineEIP1559Compatibility = new WeakSet();
+determineEIP1559Compatibility_fn = async function(networkClientId) {
+  const latestBlock = await __privateMethod(this, _getLatestBlock, getLatestBlock_fn).call(this, networkClientId);
+  if (!latestBlock) {
+    return void 0;
+  }
+  return latestBlock.baseFeePerGas !== void 0;
+};
+_validateNetworkFields = new WeakSet();
+validateNetworkFields_fn = function(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\` ${inspect(
+        networkFields.chainId
+      )} (must start with "0x" and not exceed the maximum)`
+    );
+  }
+  if (existingNetworkConfiguration === null || networkFields.chainId !== existingNetworkConfiguration.chainId) {
+    const existingNetworkConfigurationViaChainId = this.state.networkConfigurationsByChainId[networkFields.chainId];
+    if (existingNetworkConfigurationViaChainId !== void 0) {
+      if (existingNetworkConfiguration === null) {
+        throw new Error(
+          // False negative - these are strings.
+          // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+          `Could not add network for chain ${args.networkFields.chainId} as another network for that chain already exists ('${existingNetworkConfigurationViaChainId.name}')`
+        );
+      } else {
+        throw new Error(
+          // False negative - these are strings.
+          // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+          `Cannot move network from chain ${existingNetworkConfiguration.chainId} to ${networkFields.chainId} as another network for that chain already exists ('${existingNetworkConfigurationViaChainId.name}')`
+        );
+      }
+    }
+  }
+  const isInvalidDefaultBlockExplorerUrlIndex = networkFields.blockExplorerUrls.length > 0 ? networkFields.defaultBlockExplorerUrlIndex === void 0 || networkFields.blockExplorerUrls[networkFields.defaultBlockExplorerUrlIndex] === void 0 : networkFields.defaultBlockExplorerUrlIndex !== void 0;
+  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 ${inspect(
+          rpcEndpointFields.url
+        )}`
+      );
+    }
+    const networkClientId = "networkClientId" in rpcEndpointFields ? rpcEndpointFields.networkClientId : void 0;
+    if (rpcEndpointFields.type === "custom" /* Custom */ && networkClientId !== void 0 && isInfuraNetworkType(networkClientId)) {
+      throw new Error(
+        // This is a string.
+        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+        `${errorMessagePrefix}: Custom RPC endpoint '${rpcEndpointFields.url}' has invalid network client ID '${networkClientId}'`
+      );
+    }
+    if (mode === "update" && networkClientId !== void 0 && rpcEndpointFields.type === "custom" /* Custom */ && !Object.values(autoManagedNetworkClientRegistry).some(
+      (networkClientsById) => networkClientId in networkClientsById
+    )) {
+      throw new Error(
+        `${errorMessagePrefix}: RPC endpoint '${// This is a string.
+        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+        rpcEndpointFields.url}' refers to network client ${inspect(
+          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) {
+        throw new Error(
+          mode === "update" ? (
+            // False negative - these are strings.
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+            `Could not update network to point to same RPC endpoint as existing network for chain ${networkConfiguration.chainId} ('${networkConfiguration.name}')`
+          ) : (
+            // False negative - these are strings.
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+            `Could not add network that points to same RPC endpoint as existing network for chain ${networkConfiguration.chainId} ('${networkConfiguration.name}')`
+          )
+        );
+      }
+    }
+  }
+  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 : void 0
+  ).filter(
+    (networkClientId) => networkClientId !== void 0
+  );
+  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 === "infura" /* Infura */
+  );
+  if (infuraRpcEndpoints.length > 1) {
+    throw new Error(
+      `${errorMessagePrefix}: There cannot be more than one Infura RPC endpoint`
+    );
+  }
+  const soleInfuraRpcEndpoint = infuraRpcEndpoints[0];
+  if (soleInfuraRpcEndpoint) {
+    const infuraNetworkName = deriveInfuraNetworkNameFromRpcEndpointUrl(
+      soleInfuraRpcEndpoint.url
+    );
+    const infuraNetworkNickname = NetworkNickname[infuraNetworkName];
+    const infuraChainId = ChainId[infuraNetworkName];
+    if (networkFields.chainId !== infuraChainId) {
+      throw new Error(
+        mode === "add" ? (
+          // This is a string.
+          // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+          `Could not add network with chain ID ${networkFields.chainId} and Infura RPC endpoint for '${infuraNetworkNickname}' which represents ${infuraChainId}, as the two conflict`
+        ) : (
+          // This is a string.
+          // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+          `Could not update network with chain ID ${networkFields.chainId} and Infura RPC endpoint for '${infuraNetworkNickname}' which represents ${infuraChainId}, as the two conflict`
+        )
+      );
+    }
+  }
+  if (networkFields.rpcEndpoints[networkFields.defaultRpcEndpointIndex] === void 0) {
+    throw new Error(
+      `${errorMessagePrefix}: \`defaultRpcEndpointIndex\` must refer to an entry in \`rpcEndpoints\``
+    );
+  }
+};
+_determineNetworkConfigurationToPersist = new WeakSet();
+determineNetworkConfigurationToPersist_fn = function({
+  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 };
+};
+_registerNetworkClientsAsNeeded = new WeakSet();
+registerNetworkClientsAsNeeded_fn = function({
+  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
+    )
+  );
+  for (const addedRpcEndpoint of addedRpcEndpoints) {
+    if (addedRpcEndpoint.type === "infura" /* Infura */) {
+      autoManagedNetworkClientRegistry["infura" /* Infura */][addedRpcEndpoint.networkClientId] = createAutoManagedNetworkClient({
+        type: "infura" /* Infura */,
+        chainId: networkFields.chainId,
+        network: addedRpcEndpoint.networkClientId,
+        infuraProjectId: __privateGet(this, _infuraProjectId),
+        ticker: networkFields.nativeCurrency
+      });
+    } else {
+      autoManagedNetworkClientRegistry["custom" /* Custom */][addedRpcEndpoint.networkClientId] = createAutoManagedNetworkClient({
+        type: "custom" /* Custom */,
+        chainId: networkFields.chainId,
+        rpcUrl: addedRpcEndpoint.url,
+        ticker: networkFields.nativeCurrency
+      });
+    }
+  }
+};
+_unregisterNetworkClientsAsNeeded = new WeakSet();
+unregisterNetworkClientsAsNeeded_fn = function({
+  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];
+  }
+};
+_updateNetworkConfigurations = new WeakSet();
+updateNetworkConfigurations_fn = function(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") {
+    state.networkConfigurationsByChainId[args.networkFields.chainId] = args.networkConfigurationToPersist;
+  }
+  __privateSet(this, _networkConfigurationsByNetworkClientId, buildNetworkConfigurationsByNetworkClientId(
+    state.networkConfigurationsByChainId
+  ));
+};
+_ensureAutoManagedNetworkClientRegistryPopulated = new WeakSet();
+ensureAutoManagedNetworkClientRegistryPopulated_fn = function() {
+  return __privateGet(this, _autoManagedNetworkClientRegistry) ?? __privateSet(this, _autoManagedNetworkClientRegistry, __privateMethod(this, _createAutoManagedNetworkClientRegistry, createAutoManagedNetworkClientRegistry_fn).call(this));
+};
+_createAutoManagedNetworkClientRegistry = new WeakSet();
+createAutoManagedNetworkClientRegistry_fn = function() {
+  const chainIds = knownKeysOf(this.state.networkConfigurationsByChainId);
+  const networkClientsWithIds = chainIds.flatMap((chainId) => {
+    const networkConfiguration = this.state.networkConfigurationsByChainId[chainId];
+    return networkConfiguration.rpcEndpoints.map((rpcEndpoint) => {
+      if (rpcEndpoint.type === "infura" /* Infura */) {
+        const infuraNetworkName = deriveInfuraNetworkNameFromRpcEndpointUrl(
+          rpcEndpoint.url
+        );
+        return [
+          rpcEndpoint.networkClientId,
+          createAutoManagedNetworkClient({
+            type: "infura" /* Infura */,
+            network: infuraNetworkName,
+            infuraProjectId: __privateGet(this, _infuraProjectId),
+            chainId: networkConfiguration.chainId,
+            ticker: networkConfiguration.nativeCurrency
+          })
+        ];
+      }
+      return [
+        rpcEndpoint.networkClientId,
+        createAutoManagedNetworkClient({
+          type: "custom" /* Custom */,
+          chainId: networkConfiguration.chainId,
+          rpcUrl: rpcEndpoint.url,
+          ticker: networkConfiguration.nativeCurrency
+        })
+      ];
+    });
+  });
+  return networkClientsWithIds.reduce(
+    (obj, [networkClientId, networkClient]) => {
+      return {
+        ...obj,
+        [networkClient.configuration.type]: {
+          ...obj[networkClient.configuration.type],
+          [networkClientId]: networkClient
+        }
+      };
+    },
+    {
+      ["custom" /* Custom */]: {},
+      ["infura" /* Infura */]: {}
+    }
+  );
+};
+_applyNetworkSelection = new WeakSet();
+applyNetworkSelection_fn = function(networkClientId, {
+  updateState
+} = {}) {
+  const autoManagedNetworkClientRegistry = __privateMethod(this, _ensureAutoManagedNetworkClientRegistryPopulated, ensureAutoManagedNetworkClientRegistryPopulated_fn).call(this);
+  let autoManagedNetworkClient;
+  if (isInfuraNetworkType(networkClientId)) {
+    const possibleAutoManagedNetworkClient = autoManagedNetworkClientRegistry["infura" /* Infura */][networkClientId];
+    if (!possibleAutoManagedNetworkClient) {
+      throw new Error(
+        `No Infura network client found with ID ${inspect(networkClientId)}`
+      );
+    }
+    autoManagedNetworkClient = possibleAutoManagedNetworkClient;
+  } else {
+    const possibleAutoManagedNetworkClient = autoManagedNetworkClientRegistry["custom" /* Custom */][networkClientId];
+    if (!possibleAutoManagedNetworkClient) {
+      throw new Error(
+        `No network client found with ID ${inspect(networkClientId)}`
+      );
+    }
+    autoManagedNetworkClient = possibleAutoManagedNetworkClient;
+  }
+  __privateSet(this, _autoManagedNetworkClient, autoManagedNetworkClient);
+  this.update((state) => {
+    state.selectedNetworkClientId = networkClientId;
+    if (state.networksMetadata[networkClientId] === void 0) {
+      state.networksMetadata[networkClientId] = {
+        status: "unknown" /* Unknown */,
+        EIPS: {}
+      };
+    }
+    updateState?.(state);
+  });
+  if (__privateGet(this, _providerProxy)) {
+    __privateGet(this, _providerProxy).setTarget(__privateGet(this, _autoManagedNetworkClient).provider);
+  } else {
+    __privateSet(this, _providerProxy, createEventEmitterProxy(
+      __privateGet(this, _autoManagedNetworkClient).provider
+    ));
+  }
+  if (__privateGet(this, _blockTrackerProxy)) {
+    __privateGet(this, _blockTrackerProxy).setTarget(
+      __privateGet(this, _autoManagedNetworkClient).blockTracker
+    );
+  } else {
+    __privateSet(this, _blockTrackerProxy, createEventEmitterProxy(
+      __privateGet(this, _autoManagedNetworkClient).blockTracker,
+      { eventFilter: "skipInternal" }
+    ));
+  }
+  __privateSet(this, _ethQuery, new EthQuery(__privateGet(this, _providerProxy)));
+};
+
+export {
+  RpcEndpointType,
+  knownKeysOf,
+  getDefaultNetworkControllerState,
+  NetworkController
+};
+//# sourceMappingURL=chunk-YJXBTFAE.mjs.map