@openfort/react 1.3.0 → 1.5.0

package/build/wagmi/components/ChainSelectList/index.js

@@ -1,13 +1,14 @@
 import { jsxs, jsx } from 'react/jsx-runtime';
 import { motion, AnimatePresence } from 'framer-motion';
 import { useState, useEffect, useId } from 'react';
-import { useAccount, useChainId, useSwitchChain } from 'wagmi';
+import { useAccount, useChainId } from 'wagmi';
 import ChainIcons from '../../../assets/chains.js';
 import Alert from '../../../components/Common/Alert/index.js';
 import { useOpenfort } from '../../../components/Openfort/useOpenfort.js';
 import { chainConfigs } from '../../../constants/chainConfigs.js';
 import useLocales from '../../../hooks/useLocales.js';
 import { isMobile, isCoinbaseWalletConnector } from '../../../utils/index.js';
+import { useSwitchChainFiltered } from '../../useSwitchChainFiltered.js';
 import { SwitchNetworksContainer, ChainButtonContainer, ChainButtons, ChainButton, ChainLogoContainer, ChainLogoSpinner, ChainIcon, ChainButtonStatus, ChainButtonBg } from './styles.js';
 
 const Spinner = () => {
@@ -17,7 +18,7 @@ const Spinner = () => {
 const ChainSelectList = ({ variant }) => {
     const { connector } = useAccount();
     const activeChainId = useChainId();
-    const { chains, isPending: bridgeIsPending, switchChain: switchChainFn, error: bridgeError } = useSwitchChain();
+    const { chains, isPending: bridgeIsPending, switchChain: switchChainFn, error: bridgeError, } = useSwitchChainFiltered();
     const [pendingChainId, setPendingChainId] = useState(undefined);
     const locales = useLocales({});
     const mobile = isMobile();

package/build/wagmi/components/ChainSelectList/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/wagmi/components/SwitchNetworks/index.js

@@ -1,5 +1,5 @@
 import { jsx, jsxs } from 'react/jsx-runtime';
-import { useChainId, useSwitchChain } from 'wagmi';
+import { useChainId } from 'wagmi';
 import { DisconnectIcon } from '../../../assets/icons.js';
 import Button from '../../../components/Common/Button/index.js';
 import { OrDivider } from '../../../components/Common/Modal/index.js';
@@ -7,11 +7,12 @@ import { ModalContent, ModalBody } from '../../../components/Common/Modal/styles
 import { PageContent } from '../../../components/PageContent/index.js';
 import useLocales from '../../../hooks/useLocales.js';
 import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
+import { useSwitchChainFiltered } from '../../useSwitchChainFiltered.js';
 import ChainSelectList from '../ChainSelectList/index.js';
 
 const SwitchNetworks = () => {
     const chainId = useChainId();
-    const { chains } = useSwitchChain();
+    const { chains } = useSwitchChainFiltered();
     const { logout } = useOpenfortCore();
     const locales = useLocales({});
     const chainIsSupported = chainId != null && chains.some((c) => c.id === chainId);

package/build/wagmi/components/SwitchNetworks/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;"}

package/build/wagmi/useSwitchChainFiltered.d.ts

@@ -0,0 +1,199 @@
+/**
+ * Wraps wagmi's `useSwitchChain`, restricting the switchable chains to those
+ * matching the Openfort publishable key environment.
+ *
+ * - `pk_test_…` keys expose only testnet chains (`chain.testnet === true`)
+ * - `pk_live_…` keys expose only mainnet chains (`chain.testnet !== true`)
+ *
+ * The chain the wallet is currently connected to is always kept in the list,
+ * even when it doesn't match the environment, so the selector can still display
+ * it and let the user switch away (without it, the active-chain lookups in the
+ * UI would resolve to `undefined` and the switch control would disappear).
+ *
+ * Chains rely on viem's `testnet` flag; custom chains defined without it are
+ * treated as mainnet. When the key prefix is unknown, or no configured chain
+ * matches the environment, the developer's full chain list is returned
+ * unchanged to avoid an empty selector.
+ */
+export declare const useSwitchChainFiltered: () => {
+    chains: readonly [import("viem").Chain, ...import("viem").Chain[]] | import("viem").Chain[];
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: import("@wagmi/core").SwitchChainErrorType | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutate: import("wagmi/query").SwitchChainMutate<import("wagmi").Config, unknown>;
+    mutateAsync: import("wagmi/query").SwitchChainMutateAsync<import("wagmi").Config, unknown>;
+    switchChain: import("wagmi/query").SwitchChainMutate<import("wagmi").Config, unknown>;
+    switchChainAsync: import("wagmi/query").SwitchChainMutateAsync<import("wagmi").Config, unknown>;
+} | {
+    chains: readonly [import("viem").Chain, ...import("viem").Chain[]] | import("viem").Chain[];
+    data: undefined;
+    variables: {
+        connector?: import("wagmi").Connector | undefined;
+        chainId: number;
+        addEthereumChainParameter?: {
+            nativeCurrency?: {
+                name: string;
+                symbol: string;
+                decimals: number;
+            } | undefined | undefined;
+            rpcUrls?: readonly string[] | undefined;
+            chainName?: string | undefined;
+            blockExplorerUrls?: string[] | undefined | undefined;
+            iconUrls?: string[] | undefined | undefined;
+        } | undefined;
+    };
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: import("@wagmi/core").SwitchChainErrorType | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutate: import("wagmi/query").SwitchChainMutate<import("wagmi").Config, unknown>;
+    mutateAsync: import("wagmi/query").SwitchChainMutateAsync<import("wagmi").Config, unknown>;
+    switchChain: import("wagmi/query").SwitchChainMutate<import("wagmi").Config, unknown>;
+    switchChainAsync: import("wagmi/query").SwitchChainMutateAsync<import("wagmi").Config, unknown>;
+} | {
+    chains: readonly [import("viem").Chain, ...import("viem").Chain[]] | import("viem").Chain[];
+    data: undefined;
+    variables: {
+        connector?: import("wagmi").Connector | undefined;
+        chainId: number;
+        addEthereumChainParameter?: {
+            nativeCurrency?: {
+                name: string;
+                symbol: string;
+                decimals: number;
+            } | undefined | undefined;
+            rpcUrls?: readonly string[] | undefined;
+            chainName?: string | undefined;
+            blockExplorerUrls?: string[] | undefined | undefined;
+            iconUrls?: string[] | undefined | undefined;
+        } | undefined;
+    };
+    error: import("@wagmi/core").SwitchChainErrorType;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: import("@wagmi/core").SwitchChainErrorType | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutate: import("wagmi/query").SwitchChainMutate<import("wagmi").Config, unknown>;
+    mutateAsync: import("wagmi/query").SwitchChainMutateAsync<import("wagmi").Config, unknown>;
+    switchChain: import("wagmi/query").SwitchChainMutate<import("wagmi").Config, unknown>;
+    switchChainAsync: import("wagmi/query").SwitchChainMutateAsync<import("wagmi").Config, unknown>;
+} | {
+    chains: readonly [import("viem").Chain, ...import("viem").Chain[]] | import("viem").Chain[];
+    data: {
+        blockExplorers?: {
+            [key: string]: {
+                name: string;
+                url: string;
+                apiUrl?: string | undefined;
+            };
+            default: {
+                name: string;
+                url: string;
+                apiUrl?: string | undefined;
+            };
+        } | undefined | undefined;
+        blockTime?: number | undefined | undefined;
+        contracts?: {
+            [x: string]: import("viem").ChainContract | {
+                [sourceId: number]: import("viem").ChainContract | undefined;
+            } | undefined;
+            ensRegistry?: import("viem").ChainContract | undefined;
+            ensUniversalResolver?: import("viem").ChainContract | undefined;
+            multicall3?: import("viem").ChainContract | undefined;
+            erc6492Verifier?: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensTlds?: readonly string[] | undefined;
+        id: number;
+        name: string;
+        nativeCurrency: {
+            name: string;
+            symbol: string;
+            decimals: number;
+        };
+        experimental_preconfirmationTime?: number | undefined | undefined;
+        rpcUrls: {
+            [key: string]: {
+                http: readonly string[];
+                webSocket?: readonly string[] | undefined;
+            };
+            default: {
+                http: readonly string[];
+                webSocket?: readonly string[] | undefined;
+            };
+        };
+        sourceId?: number | undefined | undefined;
+        testnet?: boolean | undefined | undefined;
+        custom?: Record<string, unknown> | undefined;
+        extendSchema?: Record<string, unknown> | undefined;
+        fees?: import("viem").ChainFees<import("viem").ChainFormatters | undefined> | undefined;
+        formatters?: import("viem").ChainFormatters | undefined;
+        prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+            client: import("viem").Client;
+            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+        }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+            client: import("viem").Client;
+            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+        }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+            runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+        }] | undefined;
+        serializers?: import("viem").ChainSerializers<import("viem").ChainFormatters | undefined, import("viem").TransactionSerializable> | undefined;
+        verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+    };
+    variables: {
+        connector?: import("wagmi").Connector | undefined;
+        chainId: number;
+        addEthereumChainParameter?: {
+            nativeCurrency?: {
+                name: string;
+                symbol: string;
+                decimals: number;
+            } | undefined | undefined;
+            rpcUrls?: readonly string[] | undefined;
+            chainName?: string | undefined;
+            blockExplorerUrls?: string[] | undefined | undefined;
+            iconUrls?: string[] | undefined | undefined;
+        } | undefined;
+    };
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: import("@wagmi/core").SwitchChainErrorType | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutate: import("wagmi/query").SwitchChainMutate<import("wagmi").Config, unknown>;
+    mutateAsync: import("wagmi/query").SwitchChainMutateAsync<import("wagmi").Config, unknown>;
+    switchChain: import("wagmi/query").SwitchChainMutate<import("wagmi").Config, unknown>;
+    switchChainAsync: import("wagmi/query").SwitchChainMutateAsync<import("wagmi").Config, unknown>;
+};

package/build/wagmi/useSwitchChainFiltered.js

@@ -0,0 +1,53 @@
+import { useEffect, useMemo } from 'react';
+import { useSwitchChain, useChainId } from 'wagmi';
+import { useOpenfort } from '../components/Openfort/useOpenfort.js';
+import { logger } from '../utils/logger.js';
+import { getPublishableKeyEnvironment } from '../utils/validation.js';
+
+/**
+ * Wraps wagmi's `useSwitchChain`, restricting the switchable chains to those
+ * matching the Openfort publishable key environment.
+ *
+ * - `pk_test_…` keys expose only testnet chains (`chain.testnet === true`)
+ * - `pk_live_…` keys expose only mainnet chains (`chain.testnet !== true`)
+ *
+ * The chain the wallet is currently connected to is always kept in the list,
+ * even when it doesn't match the environment, so the selector can still display
+ * it and let the user switch away (without it, the active-chain lookups in the
+ * UI would resolve to `undefined` and the switch control would disappear).
+ *
+ * Chains rely on viem's `testnet` flag; custom chains defined without it are
+ * treated as mainnet. When the key prefix is unknown, or no configured chain
+ * matches the environment, the developer's full chain list is returned
+ * unchanged to avoid an empty selector.
+ */
+const useSwitchChainFiltered = () => {
+    const result = useSwitchChain();
+    const { publishableKey } = useOpenfort();
+    const activeChainId = useChainId();
+    const env = getPublishableKeyEnvironment(publishableKey);
+    const allChains = result.chains;
+    const noChainMatchesEnv = env != null && !allChains.some((c) => matchesEnvironment(c, env));
+    // Warn (dev only — gated behind debug mode) when the publishable key
+    // environment doesn't match any configured chain, since the env filter then
+    // falls back to the full list and silently does nothing.
+    useEffect(() => {
+        if (noChainMatchesEnv) {
+            logger.warn(`No configured chain matches the "${env}" publishable key environment; ` +
+                'showing all chains. Check your wagmi chains and publishable key.');
+        }
+    }, [noChainMatchesEnv, env]);
+    const chains = useMemo(() => {
+        if (!env)
+            return allChains;
+        const filtered = allChains.filter((c) => c.id === activeChainId || matchesEnvironment(c, env));
+        return filtered.length > 0 ? filtered : allChains;
+    }, [allChains, env, activeChainId]);
+    return { ...result, chains };
+};
+function matchesEnvironment(chain, env) {
+    return env === 'live' ? chain.testnet !== true : chain.testnet === true;
+}
+
+export { useSwitchChainFiltered };
+//# sourceMappingURL=useSwitchChainFiltered.js.map

package/build/wagmi/useSwitchChainFiltered.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSwitchChainFiltered.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfort/react",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "author": "Openfort (https://www.openfort.io)",
   "license": "BSD-2-Clause license",
   "description": "The easiest way to integrate Openfort to your project.",