@metamask-previews/network-enablement-controller 6.0.5-preview-8bfa290fb → 7.0.0-preview-97d6b86c0

package/CHANGELOG.md

@@ -7,10 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [7.0.0]
+
 ### Changed
 
-- Bump `@metamask/transaction-controller` from `^69.6.1` to `^69.7.0` ([#10046](https://github.com/MetaMask/core/pull/10046))
+- **BREAKING:** Drop CommonJS support ([#9536](https://github.com/MetaMask/core/pull/9536))
+  - This package is now ESM-only, but can still be used in CommonJS projects via `require(esm)` in modern Node.js versions (22+), or dynamic imports in older Node.js versions.
+- **BREAKING:** Bump minimum Node.js version to 22 ([#9976](https://github.com/MetaMask/core/pull/9976))
+- **BREAKING:** Bump TypeScript target to ES2022 ([#10019](https://github.com/MetaMask/core/pull/10019))
+  - This package now ships ES2022 code, requiring a compatible modern environment or bundler configuration to consume.
+- Bump `@metamask/transaction-controller` from `^69.6.1` to `^70.0.0` ([#10046](https://github.com/MetaMask/core/pull/10046), [#10080](https://github.com/MetaMask/core/pull/10080), [#10124](https://github.com/MetaMask/core/pull/10124), [#10160](https://github.com/MetaMask/core/pull/10160))
 - Bump `@metamask/utils` from `^11.11.0` to `^11.12.0` ([#10076](https://github.com/MetaMask/core/pull/10076))
+- Bump `@metamask/base-controller` from `^9.1.0` to `^10.0.0` ([#10160](https://github.com/MetaMask/core/pull/10160))
+- Bump `@metamask/config-registry-controller` from `^3.1.0` to `^4.0.0` ([#10160](https://github.com/MetaMask/core/pull/10160))
+- Bump `@metamask/controller-utils` from `^12.3.0` to `^13.0.0` ([#10160](https://github.com/MetaMask/core/pull/10160))
+- Bump `@metamask/messenger` from `^2.0.0` to `^3.0.0` ([#10160](https://github.com/MetaMask/core/pull/10160))
+- Bump `@metamask/multichain-network-controller` from `^3.2.4` to `^4.0.0` ([#10160](https://github.com/MetaMask/core/pull/10160))
+- Bump `@metamask/network-controller` from `^36.0.0` to `^37.0.0` ([#10160](https://github.com/MetaMask/core/pull/10160))
 
 ## [6.0.5]
 
@@ -417,7 +430,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Initial release ([#6028](https://github.com/MetaMask/core/pull/6028))
 
-[Unreleased]: https://github.com/MetaMask/core/compare/@metamask/network-enablement-controller@6.0.5...HEAD
+[Unreleased]: https://github.com/MetaMask/core/compare/@metamask/network-enablement-controller@7.0.0...HEAD
+[7.0.0]: https://github.com/MetaMask/core/compare/@metamask/network-enablement-controller@6.0.5...@metamask/network-enablement-controller@7.0.0
 [6.0.5]: https://github.com/MetaMask/core/compare/@metamask/network-enablement-controller@6.0.4...@metamask/network-enablement-controller@6.0.5
 [6.0.4]: https://github.com/MetaMask/core/compare/@metamask/network-enablement-controller@6.0.3...@metamask/network-enablement-controller@6.0.4
 [6.0.3]: https://github.com/MetaMask/core/compare/@metamask/network-enablement-controller@6.0.2...@metamask/network-enablement-controller@6.0.3

package/dist/{NetworkEnablementController-method-action-types.d.mts → NetworkEnablementController-method-action-types.d.ts}

@@ -2,7 +2,7 @@
  * This file is auto generated.
  * Do not edit manually.
  */
-import type { NetworkEnablementController } from "./NetworkEnablementController.mjs";
+import type { NetworkEnablementController } from './NetworkEnablementController.js';
 /**
  * Enables or disables a network for the user.
  *
@@ -182,4 +182,4 @@ export type NetworkEnablementControllerListPopularNetworksAction = {
  * Union of all NetworkEnablementController action types.
  */
 export type NetworkEnablementControllerMethodActions = NetworkEnablementControllerEnableNetworkAction | NetworkEnablementControllerEnableNetworkInNamespaceAction | NetworkEnablementControllerEnableAllPopularNetworksAction | NetworkEnablementControllerInitAction | NetworkEnablementControllerInitNativeAssetIdentifiersAction | NetworkEnablementControllerDisableNetworkAction | NetworkEnablementControllerRestoreEnabledNetworkMapAction | NetworkEnablementControllerIsNetworkEnabledAction | NetworkEnablementControllerListPopularEvmNetworksAction | NetworkEnablementControllerListPopularMultichainNetworksAction | NetworkEnablementControllerListPopularNetworksAction;
-//# sourceMappingURL=NetworkEnablementController-method-action-types.d.mts.map
+//# sourceMappingURL=NetworkEnablementController-method-action-types.d.ts.map

package/dist/NetworkEnablementController-method-action-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkEnablementController-method-action-types.d.ts","sourceRoot":"","sources":["../src/NetworkEnablementController-method-action-types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,kCAAkC,CAAC;AAEpF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,8CAA8C,GAAG;IAC3D,IAAI,EAAE,2CAA2C,CAAC;IAClD,OAAO,EAAE,2BAA2B,CAAC,eAAe,CAAC,CAAC;CACvD,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,yDAAyD,GAAG;IACtE,IAAI,EAAE,sDAAsD,CAAC;IAC7D,OAAO,EAAE,2BAA2B,CAAC,0BAA0B,CAAC,CAAC;CAClE,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,MAAM,yDAAyD,GAAG;IACtE,IAAI,EAAE,sDAAsD,CAAC;IAC7D,OAAO,EAAE,2BAA2B,CAAC,0BAA0B,CAAC,CAAC;CAClE,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,qCAAqC,GAAG;IAClD,IAAI,EAAE,kCAAkC,CAAC;IACzC,OAAO,EAAE,2BAA2B,CAAC,MAAM,CAAC,CAAC;CAC9C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,2DAA2D,GAAG;IACxE,IAAI,EAAE,wDAAwD,CAAC;IAC/D,OAAO,EAAE,2BAA2B,CAAC,4BAA4B,CAAC,CAAC;CACpE,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,+CAA+C,GAAG;IAC5D,IAAI,EAAE,4CAA4C,CAAC;IACnD,OAAO,EAAE,2BAA2B,CAAC,gBAAgB,CAAC,CAAC;CACxD,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,MAAM,yDAAyD,GAAG;IACtE,IAAI,EAAE,sDAAsD,CAAC;IAC7D,OAAO,EAAE,2BAA2B,CAAC,0BAA0B,CAAC,CAAC;CAClE,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,MAAM,iDAAiD,GAAG;IAC9D,IAAI,EAAE,8CAA8C,CAAC;IACrD,OAAO,EAAE,2BAA2B,CAAC,kBAAkB,CAAC,CAAC;CAC1D,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,uDAAuD,GAAG;IACpE,IAAI,EAAE,oDAAoD,CAAC;IAC3D,OAAO,EAAE,2BAA2B,CAAC,wBAAwB,CAAC,CAAC;CAChE,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,8DAA8D,GAAG;IAC3E,IAAI,EAAE,2DAA2D,CAAC;IAClE,OAAO,EAAE,2BAA2B,CAAC,+BAA+B,CAAC,CAAC;CACvE,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,oDAAoD,GAAG;IACjE,IAAI,EAAE,iDAAiD,CAAC;IACxD,OAAO,EAAE,2BAA2B,CAAC,qBAAqB,CAAC,CAAC;CAC7D,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,wCAAwC,GAChD,8CAA8C,GAC9C,yDAAyD,GACzD,yDAAyD,GACzD,qCAAqC,GACrC,2DAA2D,GAC3D,+CAA+C,GAC/C,yDAAyD,GACzD,iDAAiD,GACjD,uDAAuD,GACvD,8DAA8D,GAC9D,oDAAoD,CAAC"}

package/dist/{NetworkEnablementController-method-action-types.mjs → NetworkEnablementController-method-action-types.js}

@@ -3,4 +3,4 @@
  * Do not edit manually.
  */
 export {};
-//# sourceMappingURL=NetworkEnablementController-method-action-types.mjs.map
+//# sourceMappingURL=NetworkEnablementController-method-action-types.js.map

package/dist/NetworkEnablementController-method-action-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkEnablementController-method-action-types.js","sourceRoot":"","sources":["../src/NetworkEnablementController-method-action-types.ts"],"names":[],"mappings":"AAAA;;;GAGG","sourcesContent":["/**\n * This file is auto generated.\n * Do not edit manually.\n */\n\nimport type { NetworkEnablementController } from './NetworkEnablementController.js';\n\n/**\n * Enables or disables a network for the user.\n *\n * This method accepts either a Hex chain ID (for EVM networks) or a CAIP-2 chain ID\n * (for any blockchain network). The method will automatically convert Hex chain IDs\n * to CAIP-2 format internally. This dual parameter support allows for backward\n * compatibility with existing EVM chain ID formats while supporting newer\n * multi-chain standards.\n *\n * When enabling a non-popular network, this method will disable all other networks\n * to ensure only one network is active at a time (exclusive mode).\n *\n * @param chainId - The chain ID of the network to enable or disable. Can be either:\n * - A Hex string (e.g., '0x1' for Ethereum mainnet) for EVM networks\n * - A CAIP-2 chain ID (e.g., 'eip155:1' for Ethereum mainnet, 'solana:mainnet' for Solana)\n */\nexport type NetworkEnablementControllerEnableNetworkAction = {\n  type: `NetworkEnablementController:enableNetwork`;\n  handler: NetworkEnablementController['enableNetwork'];\n};\n\n/**\n * Enables a network for the user within a specific namespace.\n *\n * This method accepts either a Hex chain ID (for EVM networks) or a CAIP-2 chain ID\n * (for any blockchain network) and enables it within the specified namespace.\n * The method validates that the chainId belongs to the specified namespace for safety.\n *\n * Before enabling the target network, this method disables all other networks\n * in the same namespace to ensure exclusive behavior within the namespace.\n *\n * @param chainId - The chain ID of the network to enable. Can be either:\n * - A Hex string (e.g., '0x1' for Ethereum mainnet) for EVM networks\n * - A CAIP-2 chain ID (e.g., 'eip155:1' for Ethereum mainnet, 'solana:mainnet' for Solana)\n * @param namespace - The CAIP namespace where the network should be enabled\n * @throws Error if the chainId's derived namespace doesn't match the provided namespace\n */\nexport type NetworkEnablementControllerEnableNetworkInNamespaceAction = {\n  type: `NetworkEnablementController:enableNetworkInNamespace`;\n  handler: NetworkEnablementController['enableNetworkInNamespace'];\n};\n\n/**\n * Enables all popular networks and Solana mainnet.\n *\n * This method first disables all networks across all namespaces, then enables\n * all networks defined in POPULAR_NETWORKS (EVM networks), Solana mainnet, and\n * Bitcoin mainnet. This provides exclusive behavior - only popular networks will\n * be enabled after calling this method.\n *\n * Popular networks that don't exist in NetworkController or MultichainNetworkController configurations will be skipped silently.\n */\nexport type NetworkEnablementControllerEnableAllPopularNetworksAction = {\n  type: `NetworkEnablementController:enableAllPopularNetworks`;\n  handler: NetworkEnablementController['enableAllPopularNetworks'];\n};\n\n/**\n * Initializes the network enablement state from network controller configurations.\n *\n * This method reads the current network configurations from both NetworkController\n * and MultichainNetworkController and syncs the enabled network map and nativeAssetIdentifiers accordingly.\n * It ensures proper namespace buckets exist for all configured networks and only\n * adds missing networks with a default value of false, preserving existing user settings.\n *\n * This method should be called after the NetworkController and MultichainNetworkController\n * have been initialized and their configurations are available.\n */\nexport type NetworkEnablementControllerInitAction = {\n  type: `NetworkEnablementController:init`;\n  handler: NetworkEnablementController['init'];\n};\n\n/**\n * Initializes the native asset identifiers from network configurations.\n * This method should be called from the client during controller initialization\n * to populate the nativeAssetIdentifiers state based on actual network configurations.\n *\n * @param networks - Array of network configurations with chainId and nativeCurrency\n * @example\n * ```typescript\n * const evmNetworks = Object.values(networkControllerState.networkConfigurationsByChainId)\n * .map(config => ({\n * chainId: toEvmCaipChainId(config.chainId),\n * nativeCurrency: config.nativeCurrency,\n * }));\n *\n * const multichainNetworks = Object.values(multichainState.multichainNetworkConfigurationsByChainId)\n * .map(config => ({\n * chainId: config.chainId,\n * nativeCurrency: config.nativeCurrency,\n * }));\n *\n * await controller.initNativeAssetIdentifiers([...evmNetworks, ...multichainNetworks]);\n * ```\n */\nexport type NetworkEnablementControllerInitNativeAssetIdentifiersAction = {\n  type: `NetworkEnablementController:initNativeAssetIdentifiers`;\n  handler: NetworkEnablementController['initNativeAssetIdentifiers'];\n};\n\n/**\n * Disables a network for the user.\n *\n * This method accepts either a Hex chain ID (for EVM networks) or a CAIP-2 chain ID\n * (for any blockchain network). The method will automatically convert Hex chain IDs\n * to CAIP-2 format internally.\n *\n * Note: This method will prevent disabling the last remaining enabled network\n * to ensure at least one network is always available.\n *\n * @param chainId - The chain ID of the network to disable. Can be either:\n * - A Hex string (e.g., '0x1' for Ethereum mainnet) for EVM networks\n * - A CAIP-2 chain ID (e.g., 'eip155:1' for Ethereum mainnet, 'solana:mainnet' for Solana)\n */\nexport type NetworkEnablementControllerDisableNetworkAction = {\n  type: `NetworkEnablementController:disableNetwork`;\n  handler: NetworkEnablementController['disableNetwork'];\n};\n\n/**\n * Restores the enabled network map to a previously snapshotted state.\n *\n * Not a general merge API: only updates keys already present in the current\n * map. Missing snapshot values default to `false`. Intended for callers with\n * direct controller access (e.g. extension) to undo `#onAddNetwork` filter\n * switches when adding a network without changing the active selection.\n *\n * @param enabledNetworkMap - Previously snapshotted enabledNetworkMap.\n */\nexport type NetworkEnablementControllerRestoreEnabledNetworkMapAction = {\n  type: `NetworkEnablementController:restoreEnabledNetworkMap`;\n  handler: NetworkEnablementController['restoreEnabledNetworkMap'];\n};\n\n/**\n * Checks if a network is enabled.\n *\n * @param chainId - The chain ID of the network to check. Can be either:\n * - A Hex string (e.g., '0x1' for Ethereum mainnet) for EVM networks\n * - A CAIP-2 chain ID (e.g., 'eip155:1' for Ethereum mainnet, 'solana:mainnet' for Solana)\n * @returns True if the network is enabled, false otherwise\n */\nexport type NetworkEnablementControllerIsNetworkEnabledAction = {\n  type: `NetworkEnablementController:isNetworkEnabled`;\n  handler: NetworkEnablementController['isNetworkEnabled'];\n};\n\n/**\n * Returns popular EVM network chain IDs in hex form, restricted to networks\n * that exist in NetworkController (networkConfigurationsByChainId). Source is\n * the bundled `POPULAR_NETWORKS` unioned with registry-featured EVM chains.\n *\n * @returns Hex chain IDs for popular EVM networks that are configured.\n */\nexport type NetworkEnablementControllerListPopularEvmNetworksAction = {\n  type: `NetworkEnablementController:listPopularEvmNetworks`;\n  handler: NetworkEnablementController['listPopularEvmNetworks'];\n};\n\n/**\n * Returns popular multichain (Bitcoin, Solana, Tron, Stellar) mainnet chain IDs in\n * CAIP-2 form, restricted to networks that exist in MultichainNetworkController\n * (multichainNetworkConfigurationsByChainId).\n *\n * @returns CAIP-2 chain IDs for Bitcoin, Solana, Tron, and Stellar mainnets that are configured.\n */\nexport type NetworkEnablementControllerListPopularMultichainNetworksAction = {\n  type: `NetworkEnablementController:listPopularMultichainNetworks`;\n  handler: NetworkEnablementController['listPopularMultichainNetworks'];\n};\n\n/**\n * Returns the list of popular network chain IDs in CAIP-2 form, restricted to\n * networks that exist in NetworkController (networkConfigurationsByChainId) and\n * MultichainNetworkController (multichainNetworkConfigurationsByChainId). EVM\n * popular networks come from POPULAR_NETWORKS; multichain popular are Bitcoin,\n * Solana, Tron, and Stellar mainnets.\n *\n * @returns CAIP-2 chain IDs for popular EVM networks and multichain mainnets that are configured.\n */\nexport type NetworkEnablementControllerListPopularNetworksAction = {\n  type: `NetworkEnablementController:listPopularNetworks`;\n  handler: NetworkEnablementController['listPopularNetworks'];\n};\n\n/**\n * Union of all NetworkEnablementController action types.\n */\nexport type NetworkEnablementControllerMethodActions =\n  | NetworkEnablementControllerEnableNetworkAction\n  | NetworkEnablementControllerEnableNetworkInNamespaceAction\n  | NetworkEnablementControllerEnableAllPopularNetworksAction\n  | NetworkEnablementControllerInitAction\n  | NetworkEnablementControllerInitNativeAssetIdentifiersAction\n  | NetworkEnablementControllerDisableNetworkAction\n  | NetworkEnablementControllerRestoreEnabledNetworkMapAction\n  | NetworkEnablementControllerIsNetworkEnabledAction\n  | NetworkEnablementControllerListPopularEvmNetworksAction\n  | NetworkEnablementControllerListPopularMultichainNetworksAction\n  | NetworkEnablementControllerListPopularNetworksAction;\n"]}

package/dist/{NetworkEnablementController.d.cts → NetworkEnablementController.d.ts}

@@ -1,12 +1,12 @@
-import { BaseController } from "@metamask/base-controller";
-import type { ControllerGetStateAction, ControllerStateChangeEvent } from "@metamask/base-controller";
-import type { ConfigRegistryControllerGetStateAction } from "@metamask/config-registry-controller";
-import type { Messenger } from "@metamask/messenger";
-import type { MultichainNetworkControllerGetStateAction } from "@metamask/multichain-network-controller";
-import type { NetworkControllerGetStateAction, NetworkControllerNetworkAddedEvent, NetworkControllerNetworkRemovedEvent, NetworkControllerStateChangeEvent } from "@metamask/network-controller";
-import type { TransactionControllerTransactionSubmittedEvent } from "@metamask/transaction-controller";
-import type { CaipChainId, CaipNamespace, Hex } from "@metamask/utils";
-import type { NetworkEnablementControllerMethodActions } from "./NetworkEnablementController-method-action-types.cjs";
+import { BaseController } from '@metamask/base-controller';
+import type { ControllerGetStateAction, ControllerStateChangeEvent } from '@metamask/base-controller';
+import type { ConfigRegistryControllerGetStateAction } from '@metamask/config-registry-controller';
+import type { Messenger } from '@metamask/messenger';
+import type { MultichainNetworkControllerGetStateAction } from '@metamask/multichain-network-controller';
+import type { NetworkControllerGetStateAction, NetworkControllerNetworkAddedEvent, NetworkControllerNetworkRemovedEvent, NetworkControllerStateChangeEvent } from '@metamask/network-controller';
+import type { TransactionControllerTransactionSubmittedEvent } from '@metamask/transaction-controller';
+import type { CaipChainId, CaipNamespace, Hex } from '@metamask/utils';
+import type { NetworkEnablementControllerMethodActions } from './NetworkEnablementController-method-action-types.js';
 declare const controllerName = "NetworkEnablementController";
 /**
  * Information about an ordered network.
@@ -231,4 +231,4 @@ export declare class NetworkEnablementController extends BaseController<typeof c
     listPopularNetworks(): CaipChainId[];
 }
 export {};
-//# sourceMappingURL=NetworkEnablementController.d.cts.map
+//# sourceMappingURL=NetworkEnablementController.d.ts.map

package/dist/NetworkEnablementController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkEnablementController.d.ts","sourceRoot":"","sources":["../src/NetworkEnablementController.ts"],"names":[],"mappings":"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"}

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

@@ -1,17 +1,11 @@
-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 _NetworkEnablementController_instances, _NetworkEnablementController_ensureNamespaceBucket, _NetworkEnablementController_isInPopularNetworksMode, _NetworkEnablementController_removeNetworkEntry, _NetworkEnablementController_onAddNetwork, _NetworkEnablementController_getRegistryPopularEvmChainIds, _NetworkEnablementController_getPopularEvmChainIds;
-import { BaseController } from "@metamask/base-controller";
-import { BuiltInNetworkName, ChainId, toHex } from "@metamask/controller-utils";
-import { BtcScope, SolScope, TrxScope, XlmScope } from "@metamask/keyring-api";
-import { toEvmCaipChainId } from "@metamask/multichain-network-controller";
-import { KnownCaipNamespace, parseCaipChainId } from "@metamask/utils";
-import { POPULAR_NETWORKS } from "./constants.mjs";
-import { Slip44Service } from "./services/index.mjs";
-import { deriveKeys, isOnlyNetworkEnabledInNamespace } from "./utils.mjs";
+import { BaseController } from '@metamask/base-controller';
+import { BuiltInNetworkName, ChainId, toHex } from '@metamask/controller-utils';
+import { BtcScope, SolScope, TrxScope, XlmScope } from '@metamask/keyring-api';
+import { toEvmCaipChainId } from '@metamask/multichain-network-controller';
+import { KnownCaipNamespace, parseCaipChainId } from '@metamask/utils';
+import { POPULAR_NETWORKS } from './constants.js';
+import { Slip44Service } from './services/index.js';
+import { deriveKeys, isOnlyNetworkEnabledInNamespace } from './utils.js';
 const controllerName = 'NetworkEnablementController';
 const MESSENGER_EXPOSED_METHODS = [
     'init',
@@ -120,14 +114,13 @@ export class NetworkEnablementController extends BaseController {
                 ...state,
             },
         });
-        _NetworkEnablementController_instances.add(this);
         messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
         messenger.subscribe('NetworkController:networkAdded', ({ chainId }) => {
             // eslint-disable-next-line no-void
-            void __classPrivateFieldGet(this, _NetworkEnablementController_instances, "m", _NetworkEnablementController_onAddNetwork).call(this, chainId);
+            void this.#onAddNetwork(chainId);
         });
         messenger.subscribe('NetworkController:networkRemoved', ({ chainId }) => {
-            __classPrivateFieldGet(this, _NetworkEnablementController_instances, "m", _NetworkEnablementController_removeNetworkEntry).call(this, chainId);
+            this.#removeNetworkEntry(chainId);
         });
     }
     /**
@@ -188,7 +181,7 @@ export class NetworkEnablementController extends BaseController {
         }
         this.update((state) => {
             // Ensure the namespace bucket exists
-            __classPrivateFieldGet(this, _NetworkEnablementController_instances, "m", _NetworkEnablementController_ensureNamespaceBucket).call(this, state, namespace);
+            this.#ensureNamespaceBucket(state, namespace);
             // Disable all networks in the specified namespace first
             if (state.enabledNetworkMap[namespace]) {
                 Object.keys(state.enabledNetworkMap[namespace]).forEach((key) => {
@@ -221,12 +214,12 @@ export class NetworkEnablementController extends BaseController {
             const networkControllerState = this.messenger.call('NetworkController:getState');
             const multichainState = this.messenger.call('MultichainNetworkController:getState');
             // Enable all popular EVM networks that exist in NetworkController configurations
-            __classPrivateFieldGet(this, _NetworkEnablementController_instances, "m", _NetworkEnablementController_getPopularEvmChainIds).call(this).forEach((chainId) => {
+            this.#getPopularEvmChainIds().forEach((chainId) => {
                 const { namespace, storageKey } = deriveKeys(chainId);
                 // Check if network exists in NetworkController configurations
                 if (networkControllerState.networkConfigurationsByChainId[chainId]) {
                     // Ensure namespace bucket exists
-                    __classPrivateFieldGet(this, _NetworkEnablementController_instances, "m", _NetworkEnablementController_ensureNamespaceBucket).call(this, state, namespace);
+                    this.#ensureNamespaceBucket(state, namespace);
                     // Enable the network
                     state.enabledNetworkMap[namespace][storageKey] = true;
                 }
@@ -235,7 +228,7 @@ export class NetworkEnablementController extends BaseController {
             const solanaKeys = deriveKeys(SolScope.Mainnet);
             if (multichainState.multichainNetworkConfigurationsByChainId[SolScope.Mainnet]) {
                 // Ensure namespace bucket exists
-                __classPrivateFieldGet(this, _NetworkEnablementController_instances, "m", _NetworkEnablementController_ensureNamespaceBucket).call(this, state, solanaKeys.namespace);
+                this.#ensureNamespaceBucket(state, solanaKeys.namespace);
                 // Enable Solana mainnet
                 state.enabledNetworkMap[solanaKeys.namespace][solanaKeys.storageKey] =
                     true;
@@ -244,7 +237,7 @@ export class NetworkEnablementController extends BaseController {
             const bitcoinKeys = deriveKeys(BtcScope.Mainnet);
             if (multichainState.multichainNetworkConfigurationsByChainId[BtcScope.Mainnet]) {
                 // Ensure namespace bucket exists
-                __classPrivateFieldGet(this, _NetworkEnablementController_instances, "m", _NetworkEnablementController_ensureNamespaceBucket).call(this, state, bitcoinKeys.namespace);
+                this.#ensureNamespaceBucket(state, bitcoinKeys.namespace);
                 // Enable Bitcoin mainnet
                 state.enabledNetworkMap[bitcoinKeys.namespace][bitcoinKeys.storageKey] =
                     true;
@@ -253,14 +246,14 @@ export class NetworkEnablementController extends BaseController {
             const tronKeys = deriveKeys(TrxScope.Mainnet);
             if (multichainState.multichainNetworkConfigurationsByChainId[TrxScope.Mainnet]) {
                 // Ensure namespace bucket exists
-                __classPrivateFieldGet(this, _NetworkEnablementController_instances, "m", _NetworkEnablementController_ensureNamespaceBucket).call(this, state, tronKeys.namespace);
+                this.#ensureNamespaceBucket(state, tronKeys.namespace);
                 // Enable Tron mainnet
                 state.enabledNetworkMap[tronKeys.namespace][tronKeys.storageKey] = true;
             }
             // Enable Stellar mainnet if it exists in MultichainNetworkController configurations
             const stellarKeys = deriveKeys(XlmScope.Pubnet);
             if (multichainState.multichainNetworkConfigurationsByChainId[XlmScope.Pubnet]) {
-                __classPrivateFieldGet(this, _NetworkEnablementController_instances, "m", _NetworkEnablementController_ensureNamespaceBucket).call(this, state, stellarKeys.namespace);
+                this.#ensureNamespaceBucket(state, stellarKeys.namespace);
                 state.enabledNetworkMap[stellarKeys.namespace][stellarKeys.storageKey] =
                     true;
             }
@@ -303,11 +296,10 @@ export class NetworkEnablementController extends BaseController {
         this.update((state) => {
             // Initialize namespace buckets for EVM networks from NetworkController
             Object.entries(networkControllerState.networkConfigurationsByChainId).forEach(([chainId]) => {
-                var _a;
                 const { namespace, storageKey } = deriveKeys(chainId);
-                __classPrivateFieldGet(this, _NetworkEnablementController_instances, "m", _NetworkEnablementController_ensureNamespaceBucket).call(this, state, namespace);
+                this.#ensureNamespaceBucket(state, namespace);
                 // Only add network if it doesn't already exist in state (preserves user settings)
-                (_a = state.enabledNetworkMap[namespace])[storageKey] ?? (_a[storageKey] = false);
+                state.enabledNetworkMap[namespace][storageKey] ??= false;
             });
             // Apply nativeAssetIdentifier updates
             for (const { caipChainId, identifier } of evmNativeAssetUpdates) {
@@ -315,11 +307,10 @@ export class NetworkEnablementController extends BaseController {
             }
             // Initialize namespace buckets for all networks from MultichainNetworkController
             Object.keys(multichainState.multichainNetworkConfigurationsByChainId).forEach((chainId) => {
-                var _a;
                 const { namespace, storageKey } = deriveKeys(chainId);
-                __classPrivateFieldGet(this, _NetworkEnablementController_instances, "m", _NetworkEnablementController_ensureNamespaceBucket).call(this, state, namespace);
+                this.#ensureNamespaceBucket(state, namespace);
                 // Only add network if it doesn't already exist in state (preserves user settings)
-                (_a = state.enabledNetworkMap[namespace])[storageKey] ?? (_a[storageKey] = false);
+                state.enabledNetworkMap[namespace][storageKey] ??= false;
             });
         });
     }
@@ -441,6 +432,150 @@ export class NetworkEnablementController extends BaseController {
         const { namespace, storageKey } = derivedKeys;
         return this.state.enabledNetworkMap[namespace]?.[storageKey] ?? false;
     }
+    /**
+     * Ensures that a namespace bucket exists in the state.
+     *
+     * This method creates the namespace entry in the enabledNetworkMap if it doesn't
+     * already exist. This is used to prepare the state structure before adding
+     * network entries.
+     *
+     * @param state - The current controller state
+     * @param ns - The CAIP namespace to ensure exists
+     */
+    #ensureNamespaceBucket(state, ns) {
+        if (!state.enabledNetworkMap[ns]) {
+            state.enabledNetworkMap[ns] = {};
+        }
+    }
+    /**
+     * Checks if popular networks mode is active (more than 2 popular networks enabled).
+     *
+     * This method counts how many networks defined in POPULAR_NETWORKS are currently
+     * enabled in the state and returns true if more than 2 are enabled. It only checks
+     * networks that actually exist in the NetworkController configurations.
+     *
+     * @returns True if more than 2 popular networks are enabled, false otherwise
+     */
+    #isInPopularNetworksMode() {
+        // Get current network configurations to check which popular networks exist
+        const networkControllerState = this.messenger.call('NetworkController:getState');
+        // Count how many popular networks are enabled
+        const enabledPopularNetworksCount = this.#getPopularEvmChainIds().reduce((count, chainId) => {
+            // Only check networks that actually exist in NetworkController configurations
+            if (!networkControllerState.networkConfigurationsByChainId[chainId]) {
+                return count; // Skip networks that don't exist
+            }
+            const { namespace, storageKey } = deriveKeys(chainId);
+            const isEnabled = this.state.enabledNetworkMap[namespace]?.[storageKey];
+            return isEnabled ? count + 1 : count;
+        }, 0);
+        // Return true if more than 2 popular networks are enabled
+        return enabledPopularNetworksCount > 1;
+    }
+    /**
+     * Removes a network entry from the state.
+     *
+     * This method is called when a network is removed from the system. It cleans up
+     * the network entry from both enabledNetworkMap and nativeAssetIdentifiers, and ensures that
+     * at least one network remains enabled.
+     *
+     * @param chainId - The chain ID to remove (Hex or CAIP-2 format)
+     */
+    #removeNetworkEntry(chainId) {
+        const derivedKeys = deriveKeys(chainId);
+        const { namespace, storageKey, caipChainId } = derivedKeys;
+        this.update((state) => {
+            // fallback and enable ethereum mainnet
+            if (isOnlyNetworkEnabledInNamespace(this.state, derivedKeys)) {
+                state.enabledNetworkMap[namespace][ChainId[BuiltInNetworkName.Mainnet]] = true;
+            }
+            if (namespace in state.enabledNetworkMap) {
+                delete state.enabledNetworkMap[namespace][storageKey];
+            }
+            // Remove from nativeAssetIdentifiers as well
+            delete state.nativeAssetIdentifiers[caipChainId];
+        });
+    }
+    /**
+     * Handles the addition of a new EVM network to the controller.
+     *
+     * @param chainId - The chain ID to add (Hex format)
+     *
+     * @description
+     * - If in popular networks mode (>2 popular networks enabled) AND adding a popular network:
+     * - Keep current selection (add but don't enable the new network)
+     * - Otherwise:
+     * - Switch to the newly added network (disable all others, enable this one)
+     * - Also updates the nativeAssetIdentifiers with the CAIP-19-like identifier
+     */
+    async #onAddNetwork(chainId) {
+        const { namespace, storageKey, reference, caipChainId } = deriveKeys(chainId);
+        // Parse reference (decimal string from CAIP-2) to number for chainid.network lookup
+        const numericChainId = parseInt(reference, 10);
+        // EVM networks: use getEvmSlip44 (chainid.network data)
+        const slip44CoinType = await Slip44Service.getEvmSlip44(numericChainId);
+        this.update((state) => {
+            // Ensure the namespace bucket exists
+            this.#ensureNamespaceBucket(state, namespace);
+            // Check if popular networks mode is active (>2 popular networks enabled)
+            const inPopularNetworksMode = this.#isInPopularNetworksMode();
+            // Check if the network being added is a popular network
+            const isAddedNetworkPopular = this.#getPopularEvmChainIds().includes(chainId);
+            // Keep current selection only if in popular networks mode AND adding a popular network
+            const shouldKeepCurrentSelection = inPopularNetworksMode && isAddedNetworkPopular;
+            if (shouldKeepCurrentSelection) {
+                // Add the popular network but don't enable it (keep current selection)
+                state.enabledNetworkMap[namespace][storageKey] = true;
+            }
+            else {
+                // Switch to the newly added network (disable all others, enable this one)
+                Object.keys(state.enabledNetworkMap).forEach((ns) => {
+                    Object.keys(state.enabledNetworkMap[ns]).forEach((key) => {
+                        state.enabledNetworkMap[ns][key] = false;
+                    });
+                });
+                // Enable the newly added network
+                state.enabledNetworkMap[namespace][storageKey] = true;
+            }
+            // Update nativeAssetIdentifiers with the CAIP-19-like identifier
+            state.nativeAssetIdentifiers[caipChainId] = buildNativeAssetIdentifier(caipChainId, slip44CoinType);
+        });
+    }
+    /**
+     * Returns the hex chain IDs of EVM networks the config registry currently
+     * marks as "popular" (i.e. featured + active + non-testnet).
+     *
+     * @returns Hex chain IDs of registry-featured EVM networks.
+     */
+    #getRegistryPopularEvmChainIds() {
+        const { configs: { networks }, } = this.messenger.call('ConfigRegistryController:getState');
+        return Object.values(networks).reduce((popularChains, network) => {
+            if (network.config.isFeatured &&
+                network.config.isActive &&
+                !network.config.isTestnet &&
+                network.chainId.startsWith('eip155:')) {
+                const hexChainId = toHex(parseCaipChainId(network.chainId).reference);
+                popularChains.push(hexChainId);
+            }
+            return popularChains;
+        }, []);
+    }
+    /**
+     * Returns the set of popular EVM chain IDs using registry configs as primary source
+     * and the bundled `POPULAR_NETWORKS` as fallback. This ensures that the list of popular networks is always available,
+     * even if the registry is unavailable or doesn't have any featured networks.
+     *
+     * @returns De-duplicated hex chain IDs considered popular.
+     */
+    #getPopularEvmChainIds() {
+        return [
+            ...new Set([
+                // `toHex` is used to normalize chain IDs from the bundled POPULAR_NETWORKS.
+                ...POPULAR_NETWORKS.map((chainId) => toHex(chainId)),
+                ...this.#getRegistryPopularEvmChainIds(),
+            ]),
+        ];
+    }
     /**
      * Returns popular EVM network chain IDs in hex form, restricted to networks
      * that exist in NetworkController (networkConfigurationsByChainId). Source is
@@ -450,7 +585,7 @@ export class NetworkEnablementController extends BaseController {
      */
     listPopularEvmNetworks() {
         const networkControllerState = this.messenger.call('NetworkController:getState');
-        return __classPrivateFieldGet(this, _NetworkEnablementController_instances, "m", _NetworkEnablementController_getPopularEvmChainIds).call(this).filter((chainIdHex) => networkControllerState.networkConfigurationsByChainId[chainIdHex]);
+        return this.#getPopularEvmChainIds().filter((chainIdHex) => networkControllerState.networkConfigurationsByChainId[chainIdHex]);
     }
     /**
      * Returns popular multichain (Bitcoin, Solana, Tron, Stellar) mainnet chain IDs in
@@ -484,103 +619,4 @@ export class NetworkEnablementController extends BaseController {
         return [...evmCaip, ...this.listPopularMultichainNetworks()];
     }
 }
-_NetworkEnablementController_instances = new WeakSet(), _NetworkEnablementController_ensureNamespaceBucket = function _NetworkEnablementController_ensureNamespaceBucket(state, ns) {
-    if (!state.enabledNetworkMap[ns]) {
-        state.enabledNetworkMap[ns] = {};
-    }
-}, _NetworkEnablementController_isInPopularNetworksMode = function _NetworkEnablementController_isInPopularNetworksMode() {
-    // Get current network configurations to check which popular networks exist
-    const networkControllerState = this.messenger.call('NetworkController:getState');
-    // Count how many popular networks are enabled
-    const enabledPopularNetworksCount = __classPrivateFieldGet(this, _NetworkEnablementController_instances, "m", _NetworkEnablementController_getPopularEvmChainIds).call(this).reduce((count, chainId) => {
-        // Only check networks that actually exist in NetworkController configurations
-        if (!networkControllerState.networkConfigurationsByChainId[chainId]) {
-            return count; // Skip networks that don't exist
-        }
-        const { namespace, storageKey } = deriveKeys(chainId);
-        const isEnabled = this.state.enabledNetworkMap[namespace]?.[storageKey];
-        return isEnabled ? count + 1 : count;
-    }, 0);
-    // Return true if more than 2 popular networks are enabled
-    return enabledPopularNetworksCount > 1;
-}, _NetworkEnablementController_removeNetworkEntry = function _NetworkEnablementController_removeNetworkEntry(chainId) {
-    const derivedKeys = deriveKeys(chainId);
-    const { namespace, storageKey, caipChainId } = derivedKeys;
-    this.update((state) => {
-        // fallback and enable ethereum mainnet
-        if (isOnlyNetworkEnabledInNamespace(this.state, derivedKeys)) {
-            state.enabledNetworkMap[namespace][ChainId[BuiltInNetworkName.Mainnet]] = true;
-        }
-        if (namespace in state.enabledNetworkMap) {
-            delete state.enabledNetworkMap[namespace][storageKey];
-        }
-        // Remove from nativeAssetIdentifiers as well
-        delete state.nativeAssetIdentifiers[caipChainId];
-    });
-}, _NetworkEnablementController_onAddNetwork = 
-/**
- * Handles the addition of a new EVM network to the controller.
- *
- * @param chainId - The chain ID to add (Hex format)
- *
- * @description
- * - If in popular networks mode (>2 popular networks enabled) AND adding a popular network:
- * - Keep current selection (add but don't enable the new network)
- * - Otherwise:
- * - Switch to the newly added network (disable all others, enable this one)
- * - Also updates the nativeAssetIdentifiers with the CAIP-19-like identifier
- */
-async function _NetworkEnablementController_onAddNetwork(chainId) {
-    const { namespace, storageKey, reference, caipChainId } = deriveKeys(chainId);
-    // Parse reference (decimal string from CAIP-2) to number for chainid.network lookup
-    const numericChainId = parseInt(reference, 10);
-    // EVM networks: use getEvmSlip44 (chainid.network data)
-    const slip44CoinType = await Slip44Service.getEvmSlip44(numericChainId);
-    this.update((state) => {
-        // Ensure the namespace bucket exists
-        __classPrivateFieldGet(this, _NetworkEnablementController_instances, "m", _NetworkEnablementController_ensureNamespaceBucket).call(this, state, namespace);
-        // Check if popular networks mode is active (>2 popular networks enabled)
-        const inPopularNetworksMode = __classPrivateFieldGet(this, _NetworkEnablementController_instances, "m", _NetworkEnablementController_isInPopularNetworksMode).call(this);
-        // Check if the network being added is a popular network
-        const isAddedNetworkPopular = __classPrivateFieldGet(this, _NetworkEnablementController_instances, "m", _NetworkEnablementController_getPopularEvmChainIds).call(this).includes(chainId);
-        // Keep current selection only if in popular networks mode AND adding a popular network
-        const shouldKeepCurrentSelection = inPopularNetworksMode && isAddedNetworkPopular;
-        if (shouldKeepCurrentSelection) {
-            // Add the popular network but don't enable it (keep current selection)
-            state.enabledNetworkMap[namespace][storageKey] = true;
-        }
-        else {
-            // Switch to the newly added network (disable all others, enable this one)
-            Object.keys(state.enabledNetworkMap).forEach((ns) => {
-                Object.keys(state.enabledNetworkMap[ns]).forEach((key) => {
-                    state.enabledNetworkMap[ns][key] = false;
-                });
-            });
-            // Enable the newly added network
-            state.enabledNetworkMap[namespace][storageKey] = true;
-        }
-        // Update nativeAssetIdentifiers with the CAIP-19-like identifier
-        state.nativeAssetIdentifiers[caipChainId] = buildNativeAssetIdentifier(caipChainId, slip44CoinType);
-    });
-}, _NetworkEnablementController_getRegistryPopularEvmChainIds = function _NetworkEnablementController_getRegistryPopularEvmChainIds() {
-    const { configs: { networks }, } = this.messenger.call('ConfigRegistryController:getState');
-    return Object.values(networks).reduce((popularChains, network) => {
-        if (network.config.isFeatured &&
-            network.config.isActive &&
-            !network.config.isTestnet &&
-            network.chainId.startsWith('eip155:')) {
-            const hexChainId = toHex(parseCaipChainId(network.chainId).reference);
-            popularChains.push(hexChainId);
-        }
-        return popularChains;
-    }, []);
-}, _NetworkEnablementController_getPopularEvmChainIds = function _NetworkEnablementController_getPopularEvmChainIds() {
-    return [
-        ...new Set([
-            // `toHex` is used to normalize chain IDs from the bundled POPULAR_NETWORKS.
-            ...POPULAR_NETWORKS.map((chainId) => toHex(chainId)),
-            ...__classPrivateFieldGet(this, _NetworkEnablementController_instances, "m", _NetworkEnablementController_getRegistryPopularEvmChainIds).call(this),
-        ]),
-    ];
-};
-//# sourceMappingURL=NetworkEnablementController.mjs.map
+//# sourceMappingURL=NetworkEnablementController.js.map