@openfort/react 1.3.0 → 1.5.0

package/build/components/Pages/SendConfirmation/index.js

@@ -329,7 +329,7 @@ const SendConfirmation = () => {
     if (isSuccess) {
         const successAmount = normalisedAmount || '0';
         const successSymbol = getAssetSymbol(token);
-        return (jsxs(PageContent, { children: [jsx(Loader, { isSuccess: true, header: "Transfer Sent", description: `${successAmount} ${successSymbol} sent successfully` }), jsxs(ButtonRow, { children: [jsx(Button, { variant: "primary", onClick: handleOpenBlockExplorer, children: "View on Explorer" }), jsx(Button, { variant: "secondary", onClick: handleFinish, children: "Back to profile" })] })] }));
+        return (jsxs(PageContent, { children: [jsx(Loader, { isSuccess: true, header: "Transfer Sent", description: `${successAmount} ${successSymbol} sent successfully` }), jsxs(ButtonRow, { children: [blockExplorerUrl && (jsx(Button, { variant: "primary", onClick: handleOpenBlockExplorer, children: "View on Explorer" })), jsx(Button, { variant: "secondary", onClick: handleFinish, children: "Back to profile" })] })] }));
     }
     return (jsxs(PageContent, { children: [jsx(ModalHeading, { children: "Confirm transfer" }), jsx(ModalBody, { children: "Review the transaction details before sending." }), jsxs(SummaryList, { children: [jsxs(SummaryItem, { children: [jsx(SummaryLabel, { children: "Sending" }), jsxs(AmountValue, { children: [normalisedAmount || '0', " ", getAssetSymbol(token)] })] }), jsxs(SummaryItem, { children: [jsx(SummaryLabel, { children: "From" }), jsx(AddressValue, { children: address ? (jsx(CopyText, { size: "1rem", value: address, children: truncateEthAddress(address) })) : ('--') })] }), jsxs(SummaryItem, { children: [jsx(SummaryLabel, { children: "To" }), jsx(AddressValue, { children: recipientAddress ? (jsx(CopyText, { size: "1rem", value: recipientAddress, children: truncateEthAddress(recipientAddress) })) : ('--') })] }), jsxs("div", { children: [jsxs(SummaryItem, { children: [jsx(SummaryLabel, { children: "Estimated fees" }), jsxs(FeesValue, { "$completed": isSponsored, children: [jsx(EstimatedFees, { account: address, to: token.type === 'erc20' ? token.address : recipientAddress, value: token.type === 'native' && parsedAmount ? parsedAmount : undefined, data: transferData, chainId: chainId, nativeSymbol: nativeSymbol, enabled: Boolean(address && recipientAddress && parsedAmount && parsedAmount > BigInt(0)), hideInfoIcon: isSponsored }), jsx(CheckIconWrapper, { children: jsx(TickIcon, {}) })] })] }), isSponsored && (jsx("div", { style: {
                                     textAlign: 'end',

package/build/constants/chainConfigs.js

@@ -27,28 +27,28 @@ const chainConfigs = [
     {
         id: 37111,
         name: 'Lens Chain Testnet',
-        logo: jsx(ChainIcons.LensChain, { testnet: true }),
+        logo: jsx(ChainIcons.LensChain, {}),
     },
     {
         id: 3,
         name: 'Rinkeby',
-        logo: jsx(ChainIcons.Ethereum, { testnet: true }),
+        logo: jsx(ChainIcons.Ethereum, {}),
         rpcUrls: {},
     },
     {
         id: 4,
         name: 'Ropsten',
-        logo: jsx(ChainIcons.Ethereum, { testnet: true }),
+        logo: jsx(ChainIcons.Ethereum, {}),
     },
     {
         id: 5,
         name: 'Görli',
-        logo: jsx(ChainIcons.Ethereum, { testnet: true }),
+        logo: jsx(ChainIcons.Ethereum, {}),
     },
     {
         id: 42,
         name: 'Kovan',
-        logo: jsx(ChainIcons.Ethereum, { testnet: true }),
+        logo: jsx(ChainIcons.Ethereum, {}),
     },
     {
         id: 10,
@@ -58,17 +58,17 @@ const chainConfigs = [
     {
         id: 69, // nice
         name: 'Optimism Kovan',
-        logo: jsx(ChainIcons.Optimism, { testnet: true }),
+        logo: jsx(ChainIcons.Optimism, {}),
     },
     {
         id: 420, // nice
         name: 'Optimism Goerli',
-        logo: jsx(ChainIcons.Optimism, { testnet: true }),
+        logo: jsx(ChainIcons.Optimism, {}),
     },
     {
         id: 11155420,
         name: 'Optimism Sepolia',
-        logo: jsx(ChainIcons.Optimism, { testnet: true }),
+        logo: jsx(ChainIcons.Optimism, {}),
     },
     {
         id: 137,
@@ -78,27 +78,27 @@ const chainConfigs = [
     {
         id: 80001,
         name: 'Polygon Mumbai',
-        logo: jsx(ChainIcons.Polygon, { testnet: true }),
+        logo: jsx(ChainIcons.Polygon, {}),
     },
     {
         id: 80002,
         name: 'Polygon Amoy',
-        logo: jsx(ChainIcons.Polygon, { testnet: true }),
+        logo: jsx(ChainIcons.Polygon, {}),
     },
     {
         id: 13337,
         name: 'Beam Testnet',
-        logo: jsx(ChainIcons.Avalanche, { testnet: true }),
+        logo: jsx(ChainIcons.Avalanche, {}),
     },
     {
         id: 31337,
         name: 'Hardhat',
-        logo: jsx(ChainIcons.Ethereum, { testnet: true }),
+        logo: jsx(ChainIcons.Ethereum, {}),
     },
     {
         id: 1337,
         name: 'Localhost',
-        logo: jsx(ChainIcons.Ethereum, { testnet: true }),
+        logo: jsx(ChainIcons.Ethereum, {}),
     },
     {
         id: 42161,
@@ -118,12 +118,12 @@ const chainConfigs = [
     {
         id: 421611,
         name: 'Arbitrum Rinkeby',
-        logo: jsx(ChainIcons.Arbitrum, { testnet: true }),
+        logo: jsx(ChainIcons.Arbitrum, {}),
     },
     {
         id: 421613,
         name: 'Arbitrum Goerli',
-        logo: jsx(ChainIcons.Arbitrum, { testnet: true }),
+        logo: jsx(ChainIcons.Arbitrum, {}),
         rpcUrls: {
             alchemy: {
                 http: ['https://arb-goerli.g.alchemy.com/v2'],
@@ -143,7 +143,7 @@ const chainConfigs = [
     {
         id: 41,
         name: 'Telos Testnet',
-        logo: jsx(ChainIcons.Telos, { testnet: true }),
+        logo: jsx(ChainIcons.Telos, {}),
     },
     {
         id: 1313161554,
@@ -153,7 +153,7 @@ const chainConfigs = [
     {
         id: 1313161555,
         name: 'Aurora Testnet',
-        logo: jsx(ChainIcons.Aurora, { testnet: true }),
+        logo: jsx(ChainIcons.Aurora, {}),
     },
     {
         id: 43114,
@@ -163,12 +163,12 @@ const chainConfigs = [
     {
         id: 43113,
         name: 'Avalanche Fuji',
-        logo: jsx(ChainIcons.Avalanche, { testnet: true }),
+        logo: jsx(ChainIcons.Avalanche, {}),
     },
     {
         id: 31337,
         name: 'Foundry',
-        logo: jsx(ChainIcons.Foundry, { testnet: true }),
+        logo: jsx(ChainIcons.Foundry, {}),
     },
     {
         id: 100,
@@ -183,7 +183,7 @@ const chainConfigs = [
     {
         id: 9000,
         name: 'Evmos Testnet',
-        logo: jsx(ChainIcons.Evmos, { testnet: true }),
+        logo: jsx(ChainIcons.Evmos, {}),
     },
     {
         id: 56,
@@ -193,7 +193,7 @@ const chainConfigs = [
     {
         id: 97,
         name: 'Binance Smart Chain Testnet',
-        logo: jsx(ChainIcons.BinanceSmartChain, { testnet: true }),
+        logo: jsx(ChainIcons.BinanceSmartChain, {}),
     },
     {
         id: 11155111,
@@ -208,7 +208,7 @@ const chainConfigs = [
     {
         id: 842,
         name: 'Taraxa Testnet',
-        logo: jsx(ChainIcons.Taraxa, { testnet: true }),
+        logo: jsx(ChainIcons.Taraxa, {}),
     },
     {
         id: 324,
@@ -218,7 +218,7 @@ const chainConfigs = [
     {
         id: 280,
         name: 'zkSync Testnet',
-        logo: jsx(ChainIcons.zkSync, { testnet: true }),
+        logo: jsx(ChainIcons.zkSync, {}),
     },
     {
         id: 42220,
@@ -228,7 +228,7 @@ const chainConfigs = [
     {
         id: 44787,
         name: 'Celo Alfajores',
-        logo: jsx(ChainIcons.Celo, { testnet: true }),
+        logo: jsx(ChainIcons.Celo, {}),
     },
     {
         id: 7700,
@@ -253,12 +253,12 @@ const chainConfigs = [
     {
         id: 3141,
         name: 'Filecoin Hyperspace',
-        logo: jsx(ChainIcons.Filecoin, { testnet: true }),
+        logo: jsx(ChainIcons.Filecoin, {}),
     },
     {
         id: 314159,
         name: 'Filecoin Calibration',
-        logo: jsx(ChainIcons.Filecoin, { testnet: true }),
+        logo: jsx(ChainIcons.Filecoin, {}),
     },
     {
         id: 1088,
@@ -268,7 +268,7 @@ const chainConfigs = [
     {
         id: 599,
         name: 'Metis Goerli',
-        logo: jsx(ChainIcons.Metis, { testnet: true }),
+        logo: jsx(ChainIcons.Metis, {}),
     },
     {
         id: 4689,
@@ -278,7 +278,7 @@ const chainConfigs = [
     {
         id: 4690,
         name: 'IoTeX Testnet',
-        logo: jsx(ChainIcons.IoTeX, { testnet: true }),
+        logo: jsx(ChainIcons.IoTeX, {}),
     },
     {
         id: 8453,
@@ -288,12 +288,12 @@ const chainConfigs = [
     {
         id: 84531,
         name: 'Base Goerli',
-        logo: jsx(ChainIcons.Base, { testnet: true }),
+        logo: jsx(ChainIcons.Base, {}),
     },
     {
         id: 84532,
         name: 'Base Sepolia',
-        logo: jsx(ChainIcons.Base, { testnet: true }),
+        logo: jsx(ChainIcons.Base, {}),
     },
     {
         id: 7777777,
@@ -303,12 +303,12 @@ const chainConfigs = [
     {
         id: 999999999,
         name: 'Zora Sepolia',
-        logo: jsx(ChainIcons.Zora, { testnet: true }),
+        logo: jsx(ChainIcons.Zora, {}),
     },
     {
         id: 999,
         name: 'Zora Goerli Testnet',
-        logo: jsx(ChainIcons.Zora, { testnet: true }),
+        logo: jsx(ChainIcons.Zora, {}),
     },
 ];
 

package/build/constants/logos.d.ts

@@ -1,2 +1,6 @@
 export declare const TOKEN_LOGO: Record<string, string>;
 export declare function symbolToColor(symbol: string): string;
+/** Network logo for a chain: the curated brand first (clean + testnet-aware), then the backend value. */
+export declare function chainLogoUrl(chainId?: number, apiLogo?: string | null): string | null;
+/** Token logo for a symbol: the backend value first, then the curated map (covers native ETH/SOL/… which the rail returns null for). */
+export declare function currencyLogoUrl(symbol?: string, apiLogo?: string | null): string | null;

package/build/constants/logos.js

@@ -54,6 +54,30 @@ function symbolToColor(symbol) {
     const h = ((hash % 360) + 360) % 360;
     return `hsl(${h}, 55%, 50%)`;
 }
+// EVM chain id -> network logo URL. Testnet ids reuse their mainnet brand. Used
+// instead of the funding rail's icon CDN, which serves a generic prism for
+// testnets and a blank square for some mainnets.
+const CHAIN_LOGO = {
+    1: `${TW}/ethereum/info/logo.png`,
+    11155111: `${TW}/ethereum/info/logo.png`, // Sepolia
+    8453: `${TW}/base/info/logo.png`,
+    84532: `${TW}/base/info/logo.png`, // Base Sepolia
+    10: `${TW}/optimism/info/logo.png`,
+    11155420: `${TW}/optimism/info/logo.png`, // OP Sepolia
+    42161: `${TW}/arbitrum/info/logo.png`,
+    421614: `${TW}/arbitrum/info/logo.png`, // Arbitrum Sepolia
+    137: `${TW}/polygon/info/logo.png`,
+    80002: `${TW}/polygon/info/logo.png`, // Polygon Amoy
+    56: `${TW}/smartchain/info/logo.png`,
+};
+/** Network logo for a chain: the curated brand first (clean + testnet-aware), then the backend value. */
+function chainLogoUrl(chainId, apiLogo) {
+    return (chainId !== undefined && CHAIN_LOGO[chainId]) || apiLogo || null;
+}
+/** Token logo for a symbol: the backend value first, then the curated map (covers native ETH/SOL/… which the rail returns null for). */
+function currencyLogoUrl(symbol, apiLogo) {
+    return apiLogo || (symbol && TOKEN_LOGO[symbol.toUpperCase()]) || null;
+}
 
-export { TOKEN_LOGO, symbolToColor };
+export { TOKEN_LOGO, chainLogoUrl, currencyLogoUrl, symbolToColor };
 //# sourceMappingURL=logos.js.map

package/build/constants/logos.js.map

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

package/build/ethereum/hooks/useEthereumWalletAssets.js

@@ -195,7 +195,7 @@ const useEthereumWalletAssets = ({ assets: hookCustomAssets, multiChain = false,
             ? ['wallet-assets', 'multi', address, customAssetsMultiChain]
             : [...openfortKeys.walletAssets(chainId, customAssetsToFetch, address)],
         queryFn: async () => {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5;
             if (multiChain) {
                 if (!address) {
                     throw new OpenfortError('No wallet address available', OpenfortReactErrorType.UNEXPECTED_ERROR);
@@ -292,6 +292,26 @@ const useEthereumWalletAssets = ({ assets: hookCustomAssets, multiChain = false,
                         }
                     }
                 }
+                // The ERC-7811 proxy indexes mainnet; testnet natives (e.g. Base Sepolia ETH)
+                // come back missing or stale. For configured testnet chains, read the native
+                // balance straight from RPC — the same source Rabby uses — and upsert it.
+                const testnetChains = chains.filter((c) => c.testnet === true);
+                const rpcNatives = await Promise.all(testnetChains.map(async (c) => {
+                    var _a, _b, _c;
+                    const rpcUrl = (_c = (_b = (_a = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _a === void 0 ? void 0 : _a.rpcUrls) === null || _b === void 0 ? void 0 : _b[c.id]) !== null && _c !== void 0 ? _c : getDefaultEthereumRpcUrl(c.id);
+                    const read = await readEvmAssetsViaRpc({ address: address, chain: c, rpcUrl, tokens: [] });
+                    const native = read.find((a) => a.type === 'native');
+                    return native ? { ...native, chainId: c.id } : null;
+                }));
+                for (const native of rpcNatives) {
+                    if (!native)
+                        continue;
+                    const idx = allAssets.findIndex((a) => a.type === 'native' && a.chainId === native.chainId);
+                    if (idx >= 0)
+                        allAssets[idx] = native;
+                    else
+                        allAssets.push(native);
+                }
                 allAssets.sort((a, b) => getUsdValue(b) - getUsdValue(a));
                 return allAssets;
             }
@@ -389,9 +409,25 @@ const useEthereumWalletAssets = ({ assets: hookCustomAssets, multiChain = false,
                         mergedAssets.push(asset);
                     }
                 });
+                // The ERC-7811 proxy indexes mainnet; a testnet native (e.g. Base Sepolia
+                // ETH) comes back missing or stale, so the single-chain path would report
+                // "no assets" while the multi-chain inventory shows the balance. Read the
+                // native straight from RPC and upsert it to keep the two consistent.
+                if (chain.testnet === true) {
+                    const rpcUrl = (_z = (_y = (_x = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _x === void 0 ? void 0 : _x.rpcUrls) === null || _y === void 0 ? void 0 : _y[chainId]) !== null && _z !== void 0 ? _z : getDefaultEthereumRpcUrl(chainId);
+                    const read = await readEvmAssetsViaRpc({ address: address, chain, rpcUrl, tokens: [] });
+                    const native = read.find((a) => a.type === 'native');
+                    if (native) {
+                        const idx = mergedAssets.findIndex((a) => a.type === 'native');
+                        if (idx >= 0)
+                            mergedAssets[idx] = native;
+                        else
+                            mergedAssets.unshift(native);
+                    }
+                }
                 if (mergedAssets.length === 0 && customAssetsToFetch.length > 0) {
                     // Proxy succeeded but returned nothing while we expect tokens — read direct.
-                    const rpcUrl = (_z = (_y = (_x = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _x === void 0 ? void 0 : _x.rpcUrls) === null || _y === void 0 ? void 0 : _y[chainId]) !== null && _z !== void 0 ? _z : getDefaultEthereumRpcUrl(chainId);
+                    const rpcUrl = (_2 = (_1 = (_0 = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _0 === void 0 ? void 0 : _0.rpcUrls) === null || _1 === void 0 ? void 0 : _1[chainId]) !== null && _2 !== void 0 ? _2 : getDefaultEthereumRpcUrl(chainId);
                     const fb = await readEvmAssetsViaRpc({
                         address: address,
                         chain,
@@ -405,7 +441,7 @@ const useEthereumWalletAssets = ({ assets: hookCustomAssets, multiChain = false,
             }
             catch {
                 // ERC-7811 asset proxy failed — fall back to direct chain-RPC balance reads.
-                const rpcUrl = (_2 = (_1 = (_0 = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _0 === void 0 ? void 0 : _0.rpcUrls) === null || _1 === void 0 ? void 0 : _1[chainId]) !== null && _2 !== void 0 ? _2 : getDefaultEthereumRpcUrl(chainId);
+                const rpcUrl = (_5 = (_4 = (_3 = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _3 === void 0 ? void 0 : _3.rpcUrls) === null || _4 === void 0 ? void 0 : _4[chainId]) !== null && _5 !== void 0 ? _5 : getDefaultEthereumRpcUrl(chainId);
                 return (await readEvmAssetsViaRpc({
                     address: address,
                     chain,

package/build/ethereum/hooks/useEthereumWalletAssets.js.map

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

package/build/hooks/openfort/useFundingChains.d.ts

@@ -20,6 +20,12 @@ export type FundingChain = {
 };
 type UseFundingChains = {
     chains: FundingChain[];
+    /**
+     * The rail's full deliverable chain list (uncurated). Used to check whether a
+     * funding TARGET chain is supported, independent of the source allowlist that
+     * narrows {@link chains}.
+     */
+    railChains: FundingChain[];
     loading: boolean;
     error: Error | null;
 };

package/build/hooks/openfort/useFundingChains.js

@@ -1,6 +1,7 @@
 import { SDKConfiguration } from '@openfort/openfort-js';
 import { useState, useEffect } from 'react';
 import { useOpenfort } from '../../components/Openfort/useOpenfort.js';
+import { getPublishableKeyEnvironment } from '../../utils/validation.js';
 
 /**
  * Sensible default source chains — the common funding origins. Override with
@@ -32,16 +33,24 @@ const DEFAULT_SOURCE_CURRENCIES = ['native', 'USDC', 'USDT'];
  */
 function useFundingChains() {
     var _a, _b, _c, _d, _e;
-    const { uiConfig } = useOpenfort();
+    const { uiConfig, publishableKey } = useOpenfort();
     // Defaults to the SDK backend (api.openfort.io); override for a custom funding service.
     const baseUrl = uiConfig.fundingBaseUrl || ((_a = SDKConfiguration.getInstance()) === null || _a === void 0 ? void 0 : _a.backendUrl) || 'https://api.openfort.io';
     const sourceChains = (_c = (_b = uiConfig.funding) === null || _b === void 0 ? void 0 : _b.sourceChains) !== null && _c !== void 0 ? _c : DEFAULT_SOURCE_CHAINS;
     const sourceCurrencies = (_e = (_d = uiConfig.funding) === null || _d === void 0 ? void 0 : _d.sourceCurrencies) !== null && _e !== void 0 ? _e : DEFAULT_SOURCE_CURRENCIES;
-    const [state, setState] = useState({ chains: [], loading: true, error: null });
+    // Match the rail host to the key environment: test keys (`pk_test_…`) list the
+    // testnet rail, everything else the mainnet rail. The backend picks the same
+    // host from the request livemode for the authenticated session endpoints.
+    const livemode = getPublishableKeyEnvironment(publishableKey) !== 'test';
+    const [state, setState] = useState({
+        chains: [],
+        loading: true,
+        error: null,
+    });
     useEffect(() => {
         let cancelled = false;
         setState((s) => ({ ...s, loading: true }));
-        fetch(`${baseUrl}/v2/funding/chains`)
+        fetch(`${baseUrl}/v2/funding/chains?livemode=${livemode}`)
             .then((r) => {
             if (!r.ok)
                 throw new Error(`Failed to load chains (${r.status})`);
@@ -59,9 +68,14 @@ function useFundingChains() {
         return () => {
             cancelled = true;
         };
-    }, [baseUrl]);
+    }, [baseUrl, livemode]);
     // Narrow the provider dictionary to the selected subset (cheap, O(chains)).
-    return { ...state, chains: curateChains(state.chains, sourceChains, sourceCurrencies) };
+    return {
+        chains: curateChains(state.chains, sourceChains, sourceCurrencies),
+        railChains: state.chains,
+        loading: state.loading,
+        error: state.error,
+    };
 }
 /**
  * Narrow the fetched chains to a selection. `sourceChains` is a CAIP-2 allowlist

package/build/hooks/openfort/useFundingChains.js.map

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

package/build/hooks/openfort/useUI.d.ts

@@ -17,8 +17,14 @@
  *
  * ui.open(); // Opens modal with default route
  * ui.close(); // Closes modal
- * ui.openProfile(); // Opens user profile screen
+ * ui.openProfile(); // Opens the connected wallet overview
+ * ui.openSend(); // Opens the Send flow
+ * ui.openFunding(); // Opens the Deposit (funding) hub
  * ```
+ *
+ * The `open*` navigation helpers target connected-only screens. When called while
+ * the user is not connected they fall back to the login screen, so a caller can
+ * fire them directly and let the modal route the user through auth first.
  */
 export declare function useUI(): {
     isOpen: boolean;
@@ -29,4 +35,10 @@ export declare function useUI(): {
     openSwitchNetworks: () => void;
     openProviders: () => void;
     openWallets: () => void;
+    openSend: () => void;
+    openReceive: () => void;
+    openFunding: () => void;
+    openBuy: () => void;
+    openExportKey: () => void;
+    openSettings: () => void;
 };

package/build/hooks/openfort/useUI.js

@@ -20,6 +20,12 @@ const safeRoutes = {
         { route: routes.CONNECTORS, connectType: 'linkIfUserConnectIfNoUser' },
         routes.ETH_SWITCH_NETWORK,
         routes.PROVIDERS,
+        routes.PROFILE,
+        routes.SEND,
+        routes.RECEIVE,
+        routes.DEPOSIT,
+        routes.BUY,
+        routes.EXPORT_KEY,
     ],
 };
 /** Route can be selected by string (route name) or by object with `route` property */
@@ -51,8 +57,14 @@ function isAccountId(id) {
  *
  * ui.open(); // Opens modal with default route
  * ui.close(); // Closes modal
- * ui.openProfile(); // Opens user profile screen
+ * ui.openProfile(); // Opens the connected wallet overview
+ * ui.openSend(); // Opens the Send flow
+ * ui.openFunding(); // Opens the Deposit (funding) hub
  * ```
+ *
+ * The `open*` navigation helpers target connected-only screens. When called while
+ * the user is not connected they fall back to the login screen, so a caller can
+ * fire them directly and let the modal route the user through auth first.
  */
 function useUI() {
     var _a;
@@ -111,6 +123,12 @@ function useUI() {
         openSwitchNetworks: () => gotoAndOpen(routes.ETH_SWITCH_NETWORK),
         openProviders: () => gotoAndOpen(routes.PROVIDERS),
         openWallets: () => gotoAndOpen({ route: routes.CONNECTORS, connectType: 'linkIfUserConnectIfNoUser' }),
+        openSend: () => gotoAndOpen(routes.SEND),
+        openReceive: () => gotoAndOpen(routes.RECEIVE),
+        openFunding: () => gotoAndOpen(routes.DEPOSIT),
+        openBuy: () => gotoAndOpen(routes.BUY),
+        openExportKey: () => gotoAndOpen(routes.EXPORT_KEY),
+        openSettings: () => gotoAndOpen(routes.PROFILE),
     };
 }
 

package/build/hooks/openfort/useUI.js.map

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

package/build/shared/utils/explorer.js

@@ -29,15 +29,17 @@ function appendPath(base, options, queryParams) {
 const explorerRegistry = {
     [ChainTypeEnum.EVM]: (options) => {
         var _a;
+        // Never fall back to an unrelated chain's explorer — a valid hash on the wrong
+        // explorer reads as "transaction not found". Return '' so callers hide the link.
         if (!options.chainId) {
-            logger.warn('No chain ID provided. Configure explorerUrls in OpenfortProvider for better reliability and rate limits.');
-            return polygonAmoy.blockExplorers.default.url;
+            logger.warn('No chain ID provided; cannot build an explorer URL for this transaction.');
+            return '';
         }
         const chain = EVM_CHAINS_BY_ID[options.chainId];
         const explorerUrl = (_a = chain === null || chain === void 0 ? void 0 : chain.blockExplorers) === null || _a === void 0 ? void 0 : _a.default.url;
         if (!explorerUrl) {
-            logger.warn(`No explorer URL found for chain ${options.chainId}. Configure explorerUrls in OpenfortProvider for better reliability and rate limits.`);
-            return polygonAmoy.blockExplorers.default.url;
+            logger.warn(`No explorer URL known for chain ${options.chainId}. Configure explorerUrls in OpenfortProvider to enable the link.`);
+            return '';
         }
         return appendPath(explorerUrl, options);
     },

package/build/shared/utils/explorer.js.map

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

package/build/utils/validation.d.ts

@@ -1 +1,10 @@
 export declare const isValidEmail: (email: string) => boolean;
+type PublishableKeyEnvironment = 'test' | 'live';
+/**
+ * Derive the environment from an Openfort publishable key.
+ *
+ * Keys are formatted `pk_test_<uuid>` or `pk_live_<uuid>`. Returns `null` when
+ * the prefix is unrecognized so callers can fall back to default behavior.
+ */
+export declare const getPublishableKeyEnvironment: (publishableKey: string | undefined | null) => PublishableKeyEnvironment | null;
+export {};

package/build/utils/validation.js

@@ -2,6 +2,19 @@ const isValidEmail = (email) => {
     const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
     return emailRegex.test(email);
 };
+/**
+ * Derive the environment from an Openfort publishable key.
+ *
+ * Keys are formatted `pk_test_<uuid>` or `pk_live_<uuid>`. Returns `null` when
+ * the prefix is unrecognized so callers can fall back to default behavior.
+ */
+const getPublishableKeyEnvironment = (publishableKey) => {
+    if (publishableKey === null || publishableKey === void 0 ? void 0 : publishableKey.startsWith('pk_test_'))
+        return 'test';
+    if (publishableKey === null || publishableKey === void 0 ? void 0 : publishableKey.startsWith('pk_live_'))
+        return 'live';
+    return null;
+};
 
-export { isValidEmail };
+export { getPublishableKeyEnvironment, isValidEmail };
 //# sourceMappingURL=validation.js.map

package/build/utils/validation.js.map

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

package/build/version.d.ts

@@ -1 +1 @@
-export declare const OPENFORT_VERSION = "1.3.0";
+export declare const OPENFORT_VERSION = "1.5.0";

package/build/version.js

@@ -1,4 +1,4 @@
-const OPENFORT_VERSION = '1.3.0';
+const OPENFORT_VERSION = '1.5.0';
 
 export { OPENFORT_VERSION };
 //# sourceMappingURL=version.js.map

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

@@ -2,7 +2,7 @@ import { jsx, jsxs } from 'react/jsx-runtime';
 import { motion } from 'framer-motion';
 import { useState, useEffect } from 'react';
 import { css } from 'styled-components';
-import { useChainId, useSwitchChain } from 'wagmi';
+import { useChainId } from 'wagmi';
 import Chain from '../../../components/Common/Chain/index.js';
 import Tooltip from '../../../components/Common/Tooltip/index.js';
 import { routes } from '../../../components/Openfort/types.js';
@@ -11,6 +11,7 @@ import defaultTheme from '../../../constants/defaultTheme.js';
 import useLocales from '../../../hooks/useLocales.js';
 import styled from '../../../styles/styled/index.js';
 import { isMobile, flattenChildren } from '../../../utils/index.js';
+import { useSwitchChainFiltered } from '../../useSwitchChainFiltered.js';
 import ChainSelectDropdown from '../ChainSelectDropdown/index.js';
 
 const Container = styled(motion.div) ``;
@@ -112,7 +113,7 @@ const ChainSelector = () => {
     const { open, triggerResize, setRoute } = useOpenfort();
     const [isOpen, setIsOpen] = useState(false);
     const chainId = useChainId();
-    const { chains } = useSwitchChain();
+    const { chains } = useSwitchChainFiltered();
     const chain = chains.find((c) => c.id === chainId);
     const locales = useLocales({
         CHAIN: (_a = chain === null || chain === void 0 ? void 0 : chain.name) !== null && _a !== void 0 ? _a : 'UNKNOWN',

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

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