@metamask-previews/network-enablement-controller 0.1.0-preview-037d305

package/dist/selectors.d.cts

@@ -0,0 +1,280 @@
+import type { CaipChainId, CaipNamespace, Hex } from "@metamask/utils";
+import type { NetworkEnablementControllerState } from "./NetworkEnablementController.cjs";
+/**
+ * Base selector to get the enabled network map from the controller state.
+ *
+ * @param state - The NetworkEnablementController state
+ * @returns The enabled network map
+ */
+export declare const selectEnabledNetworkMap: (state: NetworkEnablementControllerState) => {
+    [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+};
+/**
+ * Selector to check if a specific network is enabled.
+ *
+ * This selector accepts either a Hex chain ID (for EVM networks) or a CAIP-2 chain ID
+ * (for any blockchain network) and returns whether the network is currently enabled.
+ * It returns false for unknown networks or if there's an error parsing the chain ID.
+ *
+ * @param chainId - The chain ID to check (Hex or CAIP-2 format)
+ * @returns A selector function that returns true if the network is enabled, false otherwise
+ */
+export declare const selectIsNetworkEnabled: (chainId: Hex | CaipChainId) => ((state: NetworkEnablementControllerState) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+    }) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+    }) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: NetworkEnablementControllerState) => {
+        [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Selector builder to get all enabled networks for a specific namespace.
+ *
+ * The selector returned by this function returns an array of chain IDs (as strings) for all enabled networks
+ * within the specified namespace (e.g., 'eip155' for EVM networks, 'solana' for Solana).
+ *
+ * @param namespace - The CAIP namespace to get enabled networks for (e.g., 'eip155', 'solana')
+ * @returns A selector function that returns an array of chain ID strings for enabled networks in the namespace
+ */
+export declare const createSelectorForEnabledNetworksForNamespace: (namespace: CaipNamespace) => ((state: NetworkEnablementControllerState) => string[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+    }) => string[];
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+    }) => string[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string[];
+    dependencies: [(state: NetworkEnablementControllerState) => {
+        [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Selector to get all enabled networks across all namespaces.
+ *
+ * This selector returns a record where keys are CAIP namespaces and values are arrays
+ * of enabled chain IDs within each namespace.
+ *
+ * @returns A selector function that returns a record mapping namespace to array of enabled chain IDs
+ */
+export declare const selectAllEnabledNetworks: ((state: NetworkEnablementControllerState) => Record<string, string[]>) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+    }) => Record<string, string[]>;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+    }) => Record<string, string[]>) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Record<string, string[]>;
+    dependencies: [(state: NetworkEnablementControllerState) => {
+        [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Selector to get the total count of enabled networks across all namespaces.
+ *
+ * @returns A selector function that returns the total number of enabled networks
+ */
+export declare const selectEnabledNetworksCount: ((state: NetworkEnablementControllerState) => number) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, string[]>) => number;
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, string[]>) => number) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => number;
+    dependencies: [((state: NetworkEnablementControllerState) => Record<string, string[]>) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: {
+            [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+        }) => Record<string, string[]>;
+        memoizedResultFunc: ((resultFuncArgs_0: {
+            [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+        }) => Record<string, string[]>) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => Record<string, string[]>;
+        dependencies: [(state: NetworkEnablementControllerState) => {
+            [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Selector to get all enabled EVM networks.
+ *
+ * This is a convenience selector that specifically targets EIP-155 networks.
+ *
+ * @returns A selector function that returns an array of enabled EVM chain IDs
+ */
+export declare const selectEnabledEvmNetworks: ((state: NetworkEnablementControllerState) => string[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: string[]) => string[];
+    memoizedResultFunc: ((resultFuncArgs_0: string[]) => string[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string[];
+    dependencies: [((state: NetworkEnablementControllerState) => string[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: {
+            [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+        }) => string[];
+        memoizedResultFunc: ((resultFuncArgs_0: {
+            [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+        }) => string[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => string[];
+        dependencies: [(state: NetworkEnablementControllerState) => {
+            [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Selector to get all enabled Solana networks.
+ *
+ * This is a convenience selector that specifically targets Solana networks.
+ *
+ * @returns A selector function that returns an array of enabled Solana chain IDs
+ */
+export declare const selectEnabledSolanaNetworks: ((state: NetworkEnablementControllerState) => string[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: string[]) => string[];
+    memoizedResultFunc: ((resultFuncArgs_0: string[]) => string[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string[];
+    dependencies: [((state: NetworkEnablementControllerState) => string[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: {
+            [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+        }) => string[];
+        memoizedResultFunc: ((resultFuncArgs_0: {
+            [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+        }) => string[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => string[];
+        dependencies: [(state: NetworkEnablementControllerState) => {
+            [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+//# sourceMappingURL=selectors.d.cts.map

package/dist/selectors.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.d.cts","sourceRoot":"","sources":["../src/selectors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,GAAG,EAAE,wBAAwB;AAIvE,OAAO,KAAK,EAAE,gCAAgC,EAAE,0CAAsC;AAGtF;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,UAC3B,gCAAgC;;CACb,CAAC;AAE7B;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB,YAAa,GAAG,GAAG,WAAW;;;;;;;;;;;;;;;;2BAbxD,gCAAgC;;;;;;;;;;CAsBrC,CAAC;AAEL;;;;;;;;GAQG;AACH,eAAO,MAAM,4CAA4C,cAC5C,aAAa;;;;;;;;;;;;;;;;2BAlCjB,gCAAgC;;;;;;;;;;CAwCrC,CAAC;AAEL;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;2BAlD5B,gCAAgC;;;;;;;;;;CA+DxC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAtE9B,gCAAgC;;;;;;;;;;;;;;;;;;CA2ExC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BApF5B,gCAAgC;;;;;;;;;;;;;;;;;;CAuFxC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAhG/B,gCAAgC;;;;;;;;;;;;;;;;;;CAmGxC,CAAC"}

package/dist/selectors.d.mts

@@ -0,0 +1,280 @@
+import type { CaipChainId, CaipNamespace, Hex } from "@metamask/utils";
+import type { NetworkEnablementControllerState } from "./NetworkEnablementController.mjs";
+/**
+ * Base selector to get the enabled network map from the controller state.
+ *
+ * @param state - The NetworkEnablementController state
+ * @returns The enabled network map
+ */
+export declare const selectEnabledNetworkMap: (state: NetworkEnablementControllerState) => {
+    [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+};
+/**
+ * Selector to check if a specific network is enabled.
+ *
+ * This selector accepts either a Hex chain ID (for EVM networks) or a CAIP-2 chain ID
+ * (for any blockchain network) and returns whether the network is currently enabled.
+ * It returns false for unknown networks or if there's an error parsing the chain ID.
+ *
+ * @param chainId - The chain ID to check (Hex or CAIP-2 format)
+ * @returns A selector function that returns true if the network is enabled, false otherwise
+ */
+export declare const selectIsNetworkEnabled: (chainId: Hex | CaipChainId) => ((state: NetworkEnablementControllerState) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+    }) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+    }) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: NetworkEnablementControllerState) => {
+        [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Selector builder to get all enabled networks for a specific namespace.
+ *
+ * The selector returned by this function returns an array of chain IDs (as strings) for all enabled networks
+ * within the specified namespace (e.g., 'eip155' for EVM networks, 'solana' for Solana).
+ *
+ * @param namespace - The CAIP namespace to get enabled networks for (e.g., 'eip155', 'solana')
+ * @returns A selector function that returns an array of chain ID strings for enabled networks in the namespace
+ */
+export declare const createSelectorForEnabledNetworksForNamespace: (namespace: CaipNamespace) => ((state: NetworkEnablementControllerState) => string[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+    }) => string[];
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+    }) => string[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string[];
+    dependencies: [(state: NetworkEnablementControllerState) => {
+        [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Selector to get all enabled networks across all namespaces.
+ *
+ * This selector returns a record where keys are CAIP namespaces and values are arrays
+ * of enabled chain IDs within each namespace.
+ *
+ * @returns A selector function that returns a record mapping namespace to array of enabled chain IDs
+ */
+export declare const selectAllEnabledNetworks: ((state: NetworkEnablementControllerState) => Record<string, string[]>) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+    }) => Record<string, string[]>;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+    }) => Record<string, string[]>) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Record<string, string[]>;
+    dependencies: [(state: NetworkEnablementControllerState) => {
+        [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Selector to get the total count of enabled networks across all namespaces.
+ *
+ * @returns A selector function that returns the total number of enabled networks
+ */
+export declare const selectEnabledNetworksCount: ((state: NetworkEnablementControllerState) => number) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, string[]>) => number;
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, string[]>) => number) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => number;
+    dependencies: [((state: NetworkEnablementControllerState) => Record<string, string[]>) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: {
+            [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+        }) => Record<string, string[]>;
+        memoizedResultFunc: ((resultFuncArgs_0: {
+            [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+        }) => Record<string, string[]>) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => Record<string, string[]>;
+        dependencies: [(state: NetworkEnablementControllerState) => {
+            [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Selector to get all enabled EVM networks.
+ *
+ * This is a convenience selector that specifically targets EIP-155 networks.
+ *
+ * @returns A selector function that returns an array of enabled EVM chain IDs
+ */
+export declare const selectEnabledEvmNetworks: ((state: NetworkEnablementControllerState) => string[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: string[]) => string[];
+    memoizedResultFunc: ((resultFuncArgs_0: string[]) => string[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string[];
+    dependencies: [((state: NetworkEnablementControllerState) => string[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: {
+            [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+        }) => string[];
+        memoizedResultFunc: ((resultFuncArgs_0: {
+            [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+        }) => string[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => string[];
+        dependencies: [(state: NetworkEnablementControllerState) => {
+            [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Selector to get all enabled Solana networks.
+ *
+ * This is a convenience selector that specifically targets Solana networks.
+ *
+ * @returns A selector function that returns an array of enabled Solana chain IDs
+ */
+export declare const selectEnabledSolanaNetworks: ((state: NetworkEnablementControllerState) => string[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: string[]) => string[];
+    memoizedResultFunc: ((resultFuncArgs_0: string[]) => string[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string[];
+    dependencies: [((state: NetworkEnablementControllerState) => string[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: {
+            [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+        }) => string[];
+        memoizedResultFunc: ((resultFuncArgs_0: {
+            [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+        }) => string[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => string[];
+        dependencies: [(state: NetworkEnablementControllerState) => {
+            [x: string]: Record<`0x${string}` | `${string}:${string}`, boolean>;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+//# sourceMappingURL=selectors.d.mts.map

package/dist/selectors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.d.mts","sourceRoot":"","sources":["../src/selectors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,GAAG,EAAE,wBAAwB;AAIvE,OAAO,KAAK,EAAE,gCAAgC,EAAE,0CAAsC;AAGtF;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,UAC3B,gCAAgC;;CACb,CAAC;AAE7B;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB,YAAa,GAAG,GAAG,WAAW;;;;;;;;;;;;;;;;2BAbxD,gCAAgC;;;;;;;;;;CAsBrC,CAAC;AAEL;;;;;;;;GAQG;AACH,eAAO,MAAM,4CAA4C,cAC5C,aAAa;;;;;;;;;;;;;;;;2BAlCjB,gCAAgC;;;;;;;;;;CAwCrC,CAAC;AAEL;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;2BAlD5B,gCAAgC;;;;;;;;;;CA+DxC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAtE9B,gCAAgC;;;;;;;;;;;;;;;;;;CA2ExC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BApF5B,gCAAgC;;;;;;;;;;;;;;;;;;CAuFxC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAhG/B,gCAAgC;;;;;;;;;;;;;;;;;;CAmGxC,CAAC"}

package/dist/selectors.mjs

@@ -0,0 +1,81 @@
+import { KnownCaipNamespace } from "@metamask/utils";
+import { createSelector } from "reselect";
+import { deriveKeys } from "./utils.mjs";
+/**
+ * Base selector to get the enabled network map from the controller state.
+ *
+ * @param state - The NetworkEnablementController state
+ * @returns The enabled network map
+ */
+export const selectEnabledNetworkMap = (state) => state.enabledNetworkMap;
+/**
+ * Selector to check if a specific network is enabled.
+ *
+ * This selector accepts either a Hex chain ID (for EVM networks) or a CAIP-2 chain ID
+ * (for any blockchain network) and returns whether the network is currently enabled.
+ * It returns false for unknown networks or if there's an error parsing the chain ID.
+ *
+ * @param chainId - The chain ID to check (Hex or CAIP-2 format)
+ * @returns A selector function that returns true if the network is enabled, false otherwise
+ */
+export const selectIsNetworkEnabled = (chainId) => createSelector(selectEnabledNetworkMap, (enabledNetworkMap) => {
+    const { namespace, storageKey } = deriveKeys(chainId);
+    return (namespace in enabledNetworkMap &&
+        storageKey in enabledNetworkMap[namespace] &&
+        enabledNetworkMap[namespace][storageKey]);
+});
+/**
+ * Selector builder to get all enabled networks for a specific namespace.
+ *
+ * The selector returned by this function returns an array of chain IDs (as strings) for all enabled networks
+ * within the specified namespace (e.g., 'eip155' for EVM networks, 'solana' for Solana).
+ *
+ * @param namespace - The CAIP namespace to get enabled networks for (e.g., 'eip155', 'solana')
+ * @returns A selector function that returns an array of chain ID strings for enabled networks in the namespace
+ */
+export const createSelectorForEnabledNetworksForNamespace = (namespace) => createSelector(selectEnabledNetworkMap, (enabledNetworkMap) => {
+    return Object.entries(enabledNetworkMap[namespace] ?? {})
+        .filter(([, enabled]) => enabled)
+        .map(([id]) => id);
+});
+/**
+ * Selector to get all enabled networks across all namespaces.
+ *
+ * This selector returns a record where keys are CAIP namespaces and values are arrays
+ * of enabled chain IDs within each namespace.
+ *
+ * @returns A selector function that returns a record mapping namespace to array of enabled chain IDs
+ */
+export const selectAllEnabledNetworks = createSelector(selectEnabledNetworkMap, (enabledNetworkMap) => {
+    return Object.keys(enabledNetworkMap).reduce((acc, ns) => {
+        acc[ns] = Object.entries(enabledNetworkMap[ns])
+            .filter(([, enabled]) => enabled)
+            .map(([id]) => id);
+        return acc;
+    }, {});
+});
+/**
+ * Selector to get the total count of enabled networks across all namespaces.
+ *
+ * @returns A selector function that returns the total number of enabled networks
+ */
+export const selectEnabledNetworksCount = createSelector(selectAllEnabledNetworks, (allEnabledNetworks) => {
+    return Object.values(allEnabledNetworks).flat().length;
+});
+/**
+ * Selector to get all enabled EVM networks.
+ *
+ * This is a convenience selector that specifically targets EIP-155 networks.
+ *
+ * @returns A selector function that returns an array of enabled EVM chain IDs
+ */
+export const selectEnabledEvmNetworks = createSelector(createSelectorForEnabledNetworksForNamespace(KnownCaipNamespace.Eip155), (enabledEvmNetworks) => enabledEvmNetworks);
+/**
+ * Selector to get all enabled Solana networks.
+ *
+ * This is a convenience selector that specifically targets Solana networks.
+ *
+ * @returns A selector function that returns an array of enabled Solana chain IDs
+ */
+export const selectEnabledSolanaNetworks = createSelector(createSelectorForEnabledNetworksForNamespace(KnownCaipNamespace.Solana), (enabledSolanaNetworks) => enabledSolanaNetworks);
+//# sourceMappingURL=selectors.mjs.map

package/dist/selectors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.mjs","sourceRoot":"","sources":["../src/selectors.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,wBAAwB;AACrD,OAAO,EAAE,cAAc,EAAE,iBAAiB;AAG1C,OAAO,EAAE,UAAU,EAAE,oBAAgB;AAErC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CACrC,KAAuC,EACvC,EAAE,CAAC,KAAK,CAAC,iBAAiB,CAAC;AAE7B;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,OAA0B,EAAE,EAAE,CACnE,cAAc,CAAC,uBAAuB,EAAE,CAAC,iBAAiB,EAAE,EAAE;IAC5D,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC;IAEtD,OAAO,CACL,SAAS,IAAI,iBAAiB;QAC9B,UAAU,IAAI,iBAAiB,CAAC,SAAS,CAAC;QAC1C,iBAAiB,CAAC,SAAS,CAAC,CAAC,UAAU,CAAC,CACzC,CAAC;AACJ,CAAC,CAAC,CAAC;AAEL;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,4CAA4C,GAAG,CAC1D,SAAwB,EACxB,EAAE,CACF,cAAc,CAAC,uBAAuB,EAAE,CAAC,iBAAiB,EAAE,EAAE;IAC5D,OAAO,MAAM,CAAC,OAAO,CAAC,iBAAiB,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;SACtD,MAAM,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC;SAChC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC;AACvB,CAAC,CAAC,CAAC;AAEL;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,cAAc,CACpD,uBAAuB,EACvB,CAAC,iBAAiB,EAAE,EAAE;IACpB,OAAQ,MAAM,CAAC,IAAI,CAAC,iBAAiB,CAAqB,CAAC,MAAM,CAC/D,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE;QACV,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC;aAC5C,MAAM,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC;aAChC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC;QACrB,OAAO,GAAG,CAAC;IACb,CAAC,EACD,EAAqC,CACtC,CAAC;AACJ,CAAC,CACF,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,cAAc,CACtD,wBAAwB,EACxB,CAAC,kBAAkB,EAAE,EAAE;IACrB,OAAO,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,CAAC;AACzD,CAAC,CACF,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,cAAc,CACpD,4CAA4C,CAAC,kBAAkB,CAAC,MAAM,CAAC,EACvE,CAAC,kBAAkB,EAAE,EAAE,CAAC,kBAAkB,CAC3C,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,cAAc,CACvD,4CAA4C,CAAC,kBAAkB,CAAC,MAAM,CAAC,EACvE,CAAC,qBAAqB,EAAE,EAAE,CAAC,qBAAqB,CACjD,CAAC","sourcesContent":["import type { CaipChainId, CaipNamespace, Hex } from '@metamask/utils';\nimport { KnownCaipNamespace } from '@metamask/utils';\nimport { createSelector } from 'reselect';\n\nimport type { NetworkEnablementControllerState } from './NetworkEnablementController';\nimport { deriveKeys } from './utils';\n\n/**\n * Base selector to get the enabled network map from the controller state.\n *\n * @param state - The NetworkEnablementController state\n * @returns The enabled network map\n */\nexport const selectEnabledNetworkMap = (\n  state: NetworkEnablementControllerState,\n) => state.enabledNetworkMap;\n\n/**\n * Selector to check if a specific network is enabled.\n *\n * This selector accepts either a Hex chain ID (for EVM networks) or a CAIP-2 chain ID\n * (for any blockchain network) and returns whether the network is currently enabled.\n * It returns false for unknown networks or if there's an error parsing the chain ID.\n *\n * @param chainId - The chain ID to check (Hex or CAIP-2 format)\n * @returns A selector function that returns true if the network is enabled, false otherwise\n */\nexport const selectIsNetworkEnabled = (chainId: Hex | CaipChainId) =>\n  createSelector(selectEnabledNetworkMap, (enabledNetworkMap) => {\n    const { namespace, storageKey } = deriveKeys(chainId);\n\n    return (\n      namespace in enabledNetworkMap &&\n      storageKey in enabledNetworkMap[namespace] &&\n      enabledNetworkMap[namespace][storageKey]\n    );\n  });\n\n/**\n * Selector builder to get all enabled networks for a specific namespace.\n *\n * The selector returned by this function returns an array of chain IDs (as strings) for all enabled networks\n * within the specified namespace (e.g., 'eip155' for EVM networks, 'solana' for Solana).\n *\n * @param namespace - The CAIP namespace to get enabled networks for (e.g., 'eip155', 'solana')\n * @returns A selector function that returns an array of chain ID strings for enabled networks in the namespace\n */\nexport const createSelectorForEnabledNetworksForNamespace = (\n  namespace: CaipNamespace,\n) =>\n  createSelector(selectEnabledNetworkMap, (enabledNetworkMap) => {\n    return Object.entries(enabledNetworkMap[namespace] ?? {})\n      .filter(([, enabled]) => enabled)\n      .map(([id]) => id);\n  });\n\n/**\n * Selector to get all enabled networks across all namespaces.\n *\n * This selector returns a record where keys are CAIP namespaces and values are arrays\n * of enabled chain IDs within each namespace.\n *\n * @returns A selector function that returns a record mapping namespace to array of enabled chain IDs\n */\nexport const selectAllEnabledNetworks = createSelector(\n  selectEnabledNetworkMap,\n  (enabledNetworkMap) => {\n    return (Object.keys(enabledNetworkMap) as CaipNamespace[]).reduce(\n      (acc, ns) => {\n        acc[ns] = Object.entries(enabledNetworkMap[ns])\n          .filter(([, enabled]) => enabled)\n          .map(([id]) => id);\n        return acc;\n      },\n      {} as Record<CaipNamespace, string[]>,\n    );\n  },\n);\n\n/**\n * Selector to get the total count of enabled networks across all namespaces.\n *\n * @returns A selector function that returns the total number of enabled networks\n */\nexport const selectEnabledNetworksCount = createSelector(\n  selectAllEnabledNetworks,\n  (allEnabledNetworks) => {\n    return Object.values(allEnabledNetworks).flat().length;\n  },\n);\n\n/**\n * Selector to get all enabled EVM networks.\n *\n * This is a convenience selector that specifically targets EIP-155 networks.\n *\n * @returns A selector function that returns an array of enabled EVM chain IDs\n */\nexport const selectEnabledEvmNetworks = createSelector(\n  createSelectorForEnabledNetworksForNamespace(KnownCaipNamespace.Eip155),\n  (enabledEvmNetworks) => enabledEvmNetworks,\n);\n\n/**\n * Selector to get all enabled Solana networks.\n *\n * This is a convenience selector that specifically targets Solana networks.\n *\n * @returns A selector function that returns an array of enabled Solana chain IDs\n */\nexport const selectEnabledSolanaNetworks = createSelector(\n  createSelectorForEnabledNetworksForNamespace(KnownCaipNamespace.Solana),\n  (enabledSolanaNetworks) => enabledSolanaNetworks,\n);\n"]}

package/dist/types.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolScope = void 0;
+/**
+ * Scopes for Solana account type. See {@link KeyringAccount.scopes}.
+ */
+var SolScope;
+(function (SolScope) {
+    SolScope["Devnet"] = "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1";
+    SolScope["Mainnet"] = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+    SolScope["Testnet"] = "solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z";
+})(SolScope || (exports.SolScope = SolScope = {}));
+//# sourceMappingURL=types.cjs.map