@openfort/react 1.1.4 → 1.3.0

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

@@ -5,6 +5,7 @@ import { useAsyncData } from '../../../shared/hooks/useAsyncData.js';
 import { logger } from '../../../utils/logger.js';
 import { getDefaultEthereumRpcUrl } from '../../../utils/rpc.js';
 import Tooltip from '../../Common/Tooltip/index.js';
+import { useOpenfort } from '../../Openfort/useOpenfort.js';
 import { formatBalance } from '../Send/utils.js';
 import { InfoIconWrapper } from './styles.js';
 
@@ -17,16 +18,17 @@ const usdFormatter = new Intl.NumberFormat('en-US', {
 });
 const EstimatedFees = ({ account, to, value, data, chainId, nativeSymbol, enabled = true, hideInfoIcon = false, }) => {
     var _a, _b, _c;
+    const { walletConfig } = useOpenfort();
     const { data: assets } = useEthereumWalletAssets();
     const pricePerToken = (_c = (_b = (_a = assets === null || assets === void 0 ? void 0 : assets.find((a) => a.type === 'native')) === null || _a === void 0 ? void 0 : _a.metadata) === null || _b === void 0 ? void 0 : _b.fiat) === null || _c === void 0 ? void 0 : _c.value;
     const gas = useAsyncData({
         queryKey: ['gas-estimate', account, to, value, data, chainId],
         queryFn: async () => {
-            var _a;
+            var _a, _b, _c, _d;
             if (!account || !to || !chainId)
                 return null;
             try {
-                const rpcUrl = getDefaultEthereumRpcUrl(chainId);
+                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[chainId]) !== null && _c !== void 0 ? _c : getDefaultEthereumRpcUrl(chainId);
                 const publicClient = createPublicClient({ transport: http(rpcUrl) });
                 const [gasEstimate, feesPerGas] = await Promise.all([
                     publicClient.estimateGas({
@@ -37,7 +39,7 @@ const EstimatedFees = ({ account, to, value, data, chainId, nativeSymbol, enable
                     }),
                     publicClient.estimateFeesPerGas(),
                 ]);
-                const estimatedCost = gasEstimate * ((_a = feesPerGas.maxFeePerGas) !== null && _a !== void 0 ? _a : BigInt(0));
+                const estimatedCost = gasEstimate * ((_d = feesPerGas.maxFeePerGas) !== null && _d !== void 0 ? _d : BigInt(0));
                 return { estimatedCost, gasLimit: gasEstimate };
             }
             catch (error) {

package/build/components/Pages/SendConfirmation/EstimatedFees.js.map

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

package/build/components/Pages/SendConfirmation/SolanaSendConfirmation.d.ts

@@ -0,0 +1 @@
+export declare const SolanaSendConfirmation: () => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,121 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { ChainTypeEnum } from '@openfort/openfort-js';
+import { useState, useEffect } from 'react';
+import { parseUnits } from 'viem';
+import { getExplorerUrl } from '../../../shared/utils/explorer.js';
+import { useSolanaEmbeddedWallet } from '../../../solana/hooks/useSolanaEmbeddedWallet.js';
+import { sendSplTokenGasless, sendSplToken, sendSolGasless, sendSol } from '../../../solana/transfer.js';
+import 'detect-browser';
+import { truncateSolanaAddress } from '../../../utils/format.js';
+import Button from '../../Common/Button/index.js';
+import { CopyText } from '../../Common/CopyToClipboard/CopyText.js';
+import Loader from '../../Common/Loading/index.js';
+import { ModalHeading, ModalBody } from '../../Common/Modal/styles.js';
+import { routes } from '../../Openfort/types.js';
+import { useOpenfort } from '../../Openfort/useOpenfort.js';
+import { PageContent } from '../../PageContent/index.js';
+import { ButtonRow, SummaryList, SummaryItem, SummaryLabel, AmountValue, AddressValue, FeesValue, ErrorContainer, ErrorTitle, ErrorMessage } from './styles.js';
+
+const SOL_DECIMALS = 9;
+const SolanaSendConfirmation = () => {
+    var _a, _b;
+    const { sendForm, setRoute, publishableKey, triggerResize, walletConfig } = useOpenfort();
+    const wallet = useSolanaEmbeddedWallet();
+    const address = wallet.status === 'connected' ? wallet.address : undefined;
+    const provider = wallet.status === 'connected' ? wallet.provider : undefined;
+    const cluster = (_a = wallet.cluster) !== null && _a !== void 0 ? _a : 'devnet';
+    const rpcUrl = wallet.rpcUrl;
+    const recipient = sendForm.recipient;
+    const amount = sendForm.amount;
+    const asset = sendForm.asset;
+    const symbol = asset.type === 'spl' ? asset.metadata.symbol : 'SOL';
+    const decimals = asset.type === 'spl' ? asset.metadata.decimals : SOL_DECIMALS;
+    // Fees are sponsored from config (the SVM counterpart of ethereumFeeSponsorshipId).
+    const isSponsored = Boolean((_b = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.solana) === null || _b === void 0 ? void 0 : _b.sponsorFees);
+    const [isLoading, setIsLoading] = useState(false);
+    const [signature, setSignature] = useState(null);
+    const [error, setError] = useState(null);
+    // Re-measure the modal when the result/error appears.
+    useEffect(() => {
+        const id = setTimeout(triggerResize, 10);
+        return () => clearTimeout(id);
+    }, [signature, error, isLoading, triggerResize]);
+    const handleConfirm = async () => {
+        if (!address || !provider || isLoading)
+            return;
+        // The Send screen validates these before navigating here; re-guard in case
+        // this page is reached directly with an unvalidated form.
+        if (!recipient.trim()) {
+            setError('Enter a recipient address.');
+            return;
+        }
+        const amountNum = Number(amount);
+        if (!Number.isFinite(amountNum) || amountNum <= 0) {
+            setError('Enter a valid amount.');
+            return;
+        }
+        if (!isSponsored && !rpcUrl) {
+            setError('No Solana RPC is configured for this network.');
+            return;
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            let sig;
+            if (asset.type === 'spl') {
+                const baseUnits = parseUnits(amount, decimals);
+                sig = isSponsored
+                    ? await sendSplTokenGasless({
+                        from: address,
+                        to: recipient,
+                        mint: asset.address,
+                        amount: baseUnits,
+                        provider,
+                        cluster,
+                        publishableKey,
+                    })
+                    : await sendSplToken({
+                        from: address,
+                        to: recipient,
+                        mint: asset.address,
+                        amount: baseUnits,
+                        decimals,
+                        provider,
+                        rpcUrl: rpcUrl !== null && rpcUrl !== void 0 ? rpcUrl : '',
+                    });
+            }
+            else {
+                sig = isSponsored
+                    ? await sendSolGasless({
+                        from: address,
+                        to: recipient,
+                        amountSol: amountNum,
+                        provider,
+                        cluster,
+                        publishableKey,
+                    })
+                    : await sendSol({ from: address, to: recipient, amountSol: amountNum, provider, rpcUrl: rpcUrl !== null && rpcUrl !== void 0 ? rpcUrl : '' });
+            }
+            setSignature(sig);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Transaction failed');
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    const handleFinish = () => setRoute(routes.SOL_CONNECTED);
+    const handleViewExplorer = () => {
+        if (!signature)
+            return;
+        window.open(getExplorerUrl(ChainTypeEnum.SVM, { txHash: signature, cluster }), '_blank', 'noopener,noreferrer');
+    };
+    if (signature) {
+        return (jsxs(PageContent, { children: [jsx(Loader, { isSuccess: true, header: "Transfer sent", description: `${amount} ${symbol} sent successfully` }), jsxs(ButtonRow, { children: [jsx(Button, { variant: "primary", onClick: handleViewExplorer, children: "View on Explorer" }), jsx(Button, { variant: "secondary", onClick: handleFinish, children: "Back to profile" })] })] }));
+    }
+    return (jsxs(PageContent, { onBack: routes.SOL_SEND, 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: [amount || '0', " ", symbol] })] }), jsxs(SummaryItem, { children: [jsx(SummaryLabel, { children: "From" }), jsx(AddressValue, { children: address ? (jsx(CopyText, { size: "1rem", value: address, children: truncateSolanaAddress(address) })) : ('--') })] }), jsxs(SummaryItem, { children: [jsx(SummaryLabel, { children: "To" }), jsx(AddressValue, { children: recipient ? (jsx(CopyText, { size: "1rem", value: recipient, children: truncateSolanaAddress(recipient) })) : ('--') })] }), isSponsored && (jsxs(SummaryItem, { children: [jsx(SummaryLabel, { children: "Network fee" }), jsx(FeesValue, { "$completed": true, children: "Sponsored" })] }))] }), error && (jsxs(ErrorContainer, { children: [jsx(ErrorTitle, { children: "Transaction failed" }), jsx(ErrorMessage, { children: error })] })), jsxs(ButtonRow, { children: [jsx(Button, { variant: "primary", onClick: handleConfirm, disabled: !address || isLoading, waiting: isLoading, children: isLoading ? 'Confirming...' : 'Confirm' }), jsx(Button, { variant: "secondary", onClick: () => setRoute(routes.SOL_SEND), disabled: isLoading, children: "Cancel" })] })] }));
+};
+
+export { SolanaSendConfirmation };
+//# sourceMappingURL=SolanaSendConfirmation.js.map

package/build/components/Pages/SendConfirmation/SolanaSendConfirmation.js.map

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

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

@@ -21,7 +21,7 @@ import { ModalHeading, ModalBody } from '../../Common/Modal/styles.js';
 import { routes } from '../../Openfort/types.js';
 import { useOpenfort } from '../../Openfort/useOpenfort.js';
 import { PageContent } from '../../PageContent/index.js';
-import { sanitizeForParsing, isSameToken, getAssetSymbol, getAssetDecimals } from '../Send/utils.js';
+import { sanitizeForParsing, isSameToken, getAssetDecimals, getAssetSymbol } from '../Send/utils.js';
 import { EstimatedFees } from './EstimatedFees.js';
 import { ButtonRow, SummaryList, SummaryItem, SummaryLabel, AmountValue, AddressValue, FeesValue, CheckIconWrapper, StatusMessage, ErrorContainer, ErrorTitle, ErrorMessage, ErrorAction } from './styles.js';
 
@@ -69,10 +69,11 @@ const SendConfirmation = () => {
     const erc20Balance = useAsyncData({
         queryKey: ['erc20-balance', address, token.type === 'erc20' ? token.address : null, chainId],
         queryFn: async () => {
+            var _a, _b, _c, _d;
             if (!isErc20 || !address || !chainId)
                 return { value: BigInt(0), decimals: 18, symbol: 'ERC20' };
             try {
-                const rpcUrl = getDefaultEthereumRpcUrl(chainId);
+                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[chainId]) !== null && _c !== void 0 ? _c : getDefaultEthereumRpcUrl(chainId);
                 const publicClient = createPublicClient({ transport: http(rpcUrl) });
                 const balance = await publicClient.readContract({
                     address: token.address,
@@ -80,7 +81,7 @@ const SendConfirmation = () => {
                     functionName: 'balanceOf',
                     args: [address],
                 });
-                return { value: balance, decimals: 18, symbol: getAssetSymbol(token) };
+                return { value: balance, decimals: (_d = getAssetDecimals(token)) !== null && _d !== void 0 ? _d : 18, symbol: getAssetSymbol(token) };
             }
             catch (error) {
                 logger.error('Failed to fetch ERC20 balance:', error);

package/build/components/Pages/SendConfirmation/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/constants/logos.js

@@ -7,6 +7,7 @@ const TOKEN_LOGO = {
     TBNB: `${TW}/smartchain/info/logo.png`,
     MATIC: `${TW}/polygon/info/logo.png`,
     POL: `${TW}/polygon/info/logo.png`,
+    SOL: `${TW}/solana/info/logo.png`,
     AVAX: `${TW}/avalanchec/info/logo.png`,
     FTM: `${TW}/fantom/info/logo.png`,
     CELO: `${TW}/celo/info/logo.png`,

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

@@ -1,11 +1,12 @@
 import { useCallback, useMemo } from 'react';
-import { numberToHex, custom, createWalletClient, formatUnits } from 'viem';
+import { numberToHex, custom, createWalletClient, formatUnits, createPublicClient, http, erc20Abi } from 'viem';
 import { erc7811Actions } from 'viem/experimental';
 import { useOpenfort } from '../../components/Openfort/useOpenfort.js';
 import { OpenfortError, OpenfortReactErrorType } from '../../types.js';
 import { useUser } from '../../hooks/openfort/useUser.js';
 import { openfortKeys } from '../../query/queryKeys.js';
 import { useAsyncData } from '../../shared/hooks/useAsyncData.js';
+import { getDefaultEthereumRpcUrl } from '../../utils/rpc.js';
 import { useEthereumEmbeddedWallet } from './useEthereumEmbeddedWallet.js';
 
 function getUsdValue(asset) {
@@ -17,6 +18,84 @@ function getUsdValue(asset) {
     const amount = Number.parseFloat(formatUnits(asset.balance, decimals));
     return Number.isFinite(amount) ? amount * fiat.value : 0;
 }
+/** Stablecoins approximated at $1 in fallback mode (no price feed available). */
+const STABLECOIN_SYMBOLS = new Set(['USDC', 'USDT', 'DAI']);
+/**
+ * Canonical Multicall3 address — same on every major chain. Passed explicitly so
+ * multicall works even when the SDK's chain config doesn't declare a multicall3.
+ */
+const MULTICALL3_ADDRESS = '0xcA11bde05977b3631167028862bE2a173976CA11';
+/**
+ * Reads native + configured ERC-20 balances directly from the chain RPC.
+ *
+ * Fallback for when Openfort's ERC-7811 asset proxy is unavailable: the widget
+ * still shows on-chain balances (no fiat valuation — that comes from the proxy,
+ * except stablecoins which are approximated at $1). Tokens that don't exist on
+ * the chain are skipped.
+ */
+async function readEvmAssetsViaRpc(args) {
+    const { address, chain, rpcUrl, tokens } = args;
+    const client = createPublicClient({ chain, transport: http(rpcUrl) });
+    const out = [];
+    // Native balance — one call. Skipped silently if it fails (best-effort).
+    try {
+        const native = await client.getBalance({ address });
+        out.push({
+            type: 'native',
+            address: 'native',
+            balance: native,
+            metadata: {
+                symbol: chain.nativeCurrency.symbol,
+                decimals: chain.nativeCurrency.decimals,
+                fiat: { value: 0, currency: 'USD' },
+            },
+        });
+    }
+    catch {
+        // native read failed for this chain — skip it
+    }
+    if (tokens.length === 0)
+        return out;
+    // Batch every token's balanceOf/decimals/symbol/name into ONE multicall request
+    // (via Multicall3) instead of 4 calls per token — keeps us well under public-RPC
+    // rate limits (429s) that previously broke the fallback.
+    const contracts = tokens.flatMap((token) => [
+        { address: token, abi: erc20Abi, functionName: 'balanceOf', args: [address] },
+        { address: token, abi: erc20Abi, functionName: 'decimals' },
+        { address: token, abi: erc20Abi, functionName: 'symbol' },
+        { address: token, abi: erc20Abi, functionName: 'name' },
+    ]);
+    try {
+        const results = await client.multicall({ contracts, allowFailure: true, multicallAddress: MULTICALL3_ADDRESS });
+        tokens.forEach((token, i) => {
+            const balance = results[i * 4];
+            const decimals = results[i * 4 + 1];
+            const symbol = results[i * 4 + 2];
+            const name = results[i * 4 + 3];
+            if ((balance === null || balance === void 0 ? void 0 : balance.status) !== 'success' || (decimals === null || decimals === void 0 ? void 0 : decimals.status) !== 'success' || (symbol === null || symbol === void 0 ? void 0 : symbol.status) !== 'success')
+                return;
+            const sym = symbol.result;
+            out.push({
+                type: 'erc20',
+                address: token,
+                balance: balance.result,
+                metadata: {
+                    name: ((name === null || name === void 0 ? void 0 : name.status) === 'success' ? name.result : sym),
+                    symbol: sym,
+                    decimals: decimals.result,
+                    // No price feed in fallback mode; approximate stablecoins at $1 so the
+                    // USD total isn't blank. Other tokens show their amount without a value.
+                    fiat: STABLECOIN_SYMBOLS.has(sym.toUpperCase()) ? { value: 1, currency: 'USD' } : undefined,
+                },
+            });
+        });
+    }
+    catch {
+        // Multicall request itself failed (RPC throttled, or no Multicall3 on the chain).
+        // Return whatever we have (native) rather than throwing away the whole fetch.
+    }
+    return out;
+}
 /**
  * Returns wallet assets (tokens, NFTs) for the connected Ethereum address.
  * Uses ERC-7811 via Openfort's authenticated RPC proxy.
@@ -116,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;
+            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;
             if (multiChain) {
                 if (!address) {
                     throw new OpenfortError('No wallet address available', OpenfortReactErrorType.UNEXPECTED_ERROR);
@@ -146,7 +225,19 @@ const useEthereumWalletAssets = ({ assets: hookCustomAssets, multiChain = false,
                     : null;
                 const responses = await Promise.all([defaultRequest, customRequest].filter(Boolean));
                 const [defaultData, customData] = await Promise.all(responses.map((r) => r.json()));
-                const result = { ...((_a = defaultData.result) !== null && _a !== void 0 ? _a : {}) };
+                if (defaultData === null || defaultData === void 0 ? void 0 : defaultData.error) {
+                    // ERC-7811 asset proxy failed — fall back to per-chain RPC reads.
+                    const out = [];
+                    for (const c of chains) {
+                        const tokens = ((_c = (_b = (_a = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _a === void 0 ? void 0 : _a.assets) === null || _b === void 0 ? void 0 : _b[c.id]) !== null && _c !== void 0 ? _c : []);
+                        const rpcUrl = (_f = (_e = (_d = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _d === void 0 ? void 0 : _d.rpcUrls) === null || _e === void 0 ? void 0 : _e[c.id]) !== null && _f !== void 0 ? _f : getDefaultEthereumRpcUrl(c.id);
+                        const rpcAssets = await readEvmAssetsViaRpc({ address: address, chain: c, rpcUrl, tokens });
+                        for (const a of rpcAssets)
+                            out.push({ ...a, chainId: c.id });
+                    }
+                    return out;
+                }
+                const result = { ...((_g = defaultData.result) !== null && _g !== void 0 ? _g : {}) };
                 if ((customData === null || customData === void 0 ? void 0 : customData.result) && typeof customData.result === 'object') {
                     for (const [chainKey, assets] of Object.entries(customData.result)) {
                         if (!Array.isArray(assets))
@@ -157,7 +248,7 @@ const useEthereumWalletAssets = ({ assets: hookCustomAssets, multiChain = false,
                         else {
                             const existing = new Map(result[chainKey].map((a) => { var _a; return [(_a = a.address) !== null && _a !== void 0 ? _a : '', a]; }));
                             for (const asset of assets) {
-                                existing.set((_b = asset.address) !== null && _b !== void 0 ? _b : '', asset);
+                                existing.set((_h = asset.address) !== null && _h !== void 0 ? _h : '', asset);
                             }
                             result[chainKey] = Array.from(existing.values());
                         }
@@ -172,28 +263,28 @@ const useEthereumWalletAssets = ({ assets: hookCustomAssets, multiChain = false,
                         if (a.type === 'erc20') {
                             const asset = {
                                 type: 'erc20',
-                                address: ((_c = a.address) !== null && _c !== void 0 ? _c : '0x0'),
-                                balance: BigInt((_d = a.balance) !== null && _d !== void 0 ? _d : 0),
+                                address: ((_j = a.address) !== null && _j !== void 0 ? _j : '0x0'),
+                                balance: BigInt((_k = a.balance) !== null && _k !== void 0 ? _k : 0),
                                 metadata: {
-                                    name: ((_e = a.metadata) === null || _e === void 0 ? void 0 : _e.name) || 'Unknown Token',
-                                    symbol: ((_f = a.metadata) === null || _f === void 0 ? void 0 : _f.symbol) || 'UNKNOWN',
-                                    decimals: (_g = a.metadata) === null || _g === void 0 ? void 0 : _g.decimals,
-                                    fiat: (_h = a.metadata) === null || _h === void 0 ? void 0 : _h.fiat,
+                                    name: ((_l = a.metadata) === null || _l === void 0 ? void 0 : _l.name) || 'Unknown Token',
+                                    symbol: ((_m = a.metadata) === null || _m === void 0 ? void 0 : _m.symbol) || 'UNKNOWN',
+                                    decimals: (_o = a.metadata) === null || _o === void 0 ? void 0 : _o.decimals,
+                                    fiat: (_p = a.metadata) === null || _p === void 0 ? void 0 : _p.fiat,
                                 },
                                 raw: a,
                             };
                             allAssets.push({ ...asset, chainId: cid });
                         }
                         else if (a.type === 'native') {
-                            const meta = ((_j = a.metadata) !== null && _j !== void 0 ? _j : {});
+                            const meta = ((_q = a.metadata) !== null && _q !== void 0 ? _q : {});
                             const asset = {
                                 type: 'native',
                                 address: 'native',
-                                balance: BigInt((_k = a.balance) !== null && _k !== void 0 ? _k : 0),
+                                balance: BigInt((_r = a.balance) !== null && _r !== void 0 ? _r : 0),
                                 metadata: {
                                     symbol: meta.symbol || 'ETH',
                                     decimals: meta.decimals,
-                                    fiat: (_l = meta.fiat) !== null && _l !== void 0 ? _l : { value: 0, currency: 'USD' },
+                                    fiat: (_s = meta.fiat) !== null && _s !== void 0 ? _s : { value: 0, currency: 'USD' },
                                 },
                                 raw: a,
                             };
@@ -210,92 +301,118 @@ const useEthereumWalletAssets = ({ assets: hookCustomAssets, multiChain = false,
                     error: new Error('Address, chainId, or chain not available'),
                 });
             }
-            const customClient = createWalletClient({
-                account: address,
-                chain,
-                transport: customTransport(),
-            });
-            const extendedClient = customClient.extend(erc7811Actions());
-            const defaultAssetsPromise = extendedClient.getAssets({
-                chainIds: [chainId],
-            });
-            const hexChainId = numberToHex(chainId);
-            const customAssetsPromise = customAssetsToFetch.length > 0
-                ? extendedClient.getAssets({
+            try {
+                const customClient = createWalletClient({
+                    account: address,
+                    chain,
+                    transport: customTransport(),
+                });
+                const extendedClient = customClient.extend(erc7811Actions());
+                const defaultAssetsPromise = extendedClient.getAssets({
                     chainIds: [chainId],
-                    assets: {
-                        [hexChainId]: customAssetsToFetch.map((a) => ({
-                            address: a,
+                });
+                const hexChainId = numberToHex(chainId);
+                const customAssetsPromise = customAssetsToFetch.length > 0
+                    ? extendedClient.getAssets({
+                        chainIds: [chainId],
+                        assets: {
+                            [hexChainId]: customAssetsToFetch.map((a) => ({
+                                address: a,
+                                type: 'erc20',
+                            })),
+                        },
+                    })
+                    : Promise.resolve({ [hexChainId]: [] });
+                const [defaultAssetsRaw, customAssets] = await Promise.all([defaultAssetsPromise, customAssetsPromise]);
+                // ERC-7811 response keys may be hex (e.g. "0x14a34") or numeric depending on the RPC
+                const rawByChain = defaultAssetsRaw;
+                const customByChain = customAssets;
+                const rawChainAssets = (_u = (_t = rawByChain[hexChainId]) !== null && _t !== void 0 ? _t : rawByChain[String(chainId)]) !== null && _u !== void 0 ? _u : [];
+                const customChainAssets = (_w = (_v = customByChain[hexChainId]) !== null && _v !== void 0 ? _v : customByChain[String(chainId)]) !== null && _w !== void 0 ? _w : [];
+                const defaultAssets = rawChainAssets.map((a) => {
+                    var _a;
+                    let asset;
+                    if (a.type === 'erc20') {
+                        const meta = a.metadata;
+                        asset = {
                             type: 'erc20',
-                        })),
-                    },
-                })
-                : Promise.resolve({ [hexChainId]: [] });
-            const [defaultAssetsRaw, customAssets] = await Promise.all([defaultAssetsPromise, customAssetsPromise]);
-            // ERC-7811 response keys may be hex (e.g. "0x14a34") or numeric depending on the RPC
-            const rawByChain = defaultAssetsRaw;
-            const customByChain = customAssets;
-            const rawChainAssets = (_o = (_m = rawByChain[hexChainId]) !== null && _m !== void 0 ? _m : rawByChain[String(chainId)]) !== null && _o !== void 0 ? _o : [];
-            const customChainAssets = (_q = (_p = customByChain[hexChainId]) !== null && _p !== void 0 ? _p : customByChain[String(chainId)]) !== null && _q !== void 0 ? _q : [];
-            const defaultAssets = rawChainAssets.map((a) => {
-                var _a;
-                let asset;
-                if (a.type === 'erc20') {
-                    const meta = a.metadata;
-                    asset = {
-                        type: 'erc20',
-                        address: a.address,
-                        balance: a.balance,
-                        metadata: {
-                            name: (meta === null || meta === void 0 ? void 0 : meta.name) || 'Unknown Token',
-                            symbol: (meta === null || meta === void 0 ? void 0 : meta.symbol) || 'UNKNOWN',
-                            decimals: meta === null || meta === void 0 ? void 0 : meta.decimals,
-                            fiat: meta === null || meta === void 0 ? void 0 : meta.fiat,
+                            address: a.address,
+                            balance: a.balance,
+                            metadata: {
+                                name: (meta === null || meta === void 0 ? void 0 : meta.name) || 'Unknown Token',
+                                symbol: (meta === null || meta === void 0 ? void 0 : meta.symbol) || 'UNKNOWN',
+                                decimals: meta === null || meta === void 0 ? void 0 : meta.decimals,
+                                fiat: meta === null || meta === void 0 ? void 0 : meta.fiat,
+                            },
+                            raw: a,
+                        };
+                    }
+                    else if (a.type === 'native') {
+                        const meta = a.metadata;
+                        asset = {
+                            type: 'native',
+                            address: 'native',
+                            balance: a.balance,
+                            metadata: (meta === null || meta === void 0 ? void 0 : meta.fiat)
+                                ? { symbol: (_a = meta.symbol) !== null && _a !== void 0 ? _a : '', decimals: meta.decimals, fiat: meta.fiat }
+                                : undefined,
+                            raw: a,
+                        };
+                    }
+                    else {
+                        throw new OpenfortError('Unsupported asset type', OpenfortReactErrorType.UNEXPECTED_ERROR, { error: a });
+                    }
+                    return asset;
+                });
+                const mergedAssets = [...defaultAssets];
+                const customAssetsForChain = customChainAssets.flatMap((asset) => {
+                    var _a, _b;
+                    if (asset.type !== 'erc20')
+                        return [];
+                    if (!((_a = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _a === void 0 ? void 0 : _a.assets))
+                        return [{ ...asset, raw: asset }];
+                    const configAsset = (_b = walletConfig.ethereum.assets[chainId]) === null || _b === void 0 ? void 0 : _b.find((a) => a.toLowerCase() === asset.address.toLowerCase());
+                    if (!configAsset)
+                        return [{ ...asset, raw: asset }];
+                    return [
+                        {
+                            type: 'erc20',
+                            address: asset.address,
+                            balance: asset.balance,
+                            metadata: asset.metadata,
+                            raw: asset,
                         },
-                        raw: a,
-                    };
-                }
-                else if (a.type === 'native') {
-                    const meta = a.metadata;
-                    asset = {
-                        type: 'native',
-                        address: 'native',
-                        balance: a.balance,
-                        metadata: (meta === null || meta === void 0 ? void 0 : meta.fiat) ? { symbol: (_a = meta.symbol) !== null && _a !== void 0 ? _a : '', decimals: meta.decimals, fiat: meta.fiat } : undefined,
-                        raw: a,
-                    };
-                }
-                else {
-                    throw new OpenfortError('Unsupported asset type', OpenfortReactErrorType.UNEXPECTED_ERROR, { error: a });
-                }
-                return asset;
-            });
-            const mergedAssets = [...defaultAssets];
-            const customAssetsForChain = customChainAssets.flatMap((asset) => {
-                var _a, _b;
-                if (asset.type !== 'erc20')
-                    return [];
-                if (!((_a = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _a === void 0 ? void 0 : _a.assets))
-                    return [{ ...asset, raw: asset }];
-                const configAsset = (_b = walletConfig.ethereum.assets[chainId]) === null || _b === void 0 ? void 0 : _b.find((a) => a.toLowerCase() === asset.address.toLowerCase());
-                if (!configAsset)
-                    return [{ ...asset, raw: asset }];
-                return [
-                    {
-                        type: 'erc20',
-                        address: asset.address,
-                        balance: asset.balance,
-                        metadata: asset.metadata,
-                        raw: asset,
-                    },
-                ];
-            });
-            customAssetsForChain.forEach((asset) => {
-                if (!mergedAssets.find((a) => a.address === asset.address)) {
-                    mergedAssets.push(asset);
+                    ];
+                });
+                customAssetsForChain.forEach((asset) => {
+                    if (!mergedAssets.find((a) => a.address === asset.address)) {
+                        mergedAssets.push(asset);
+                    }
+                });
+                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 fb = await readEvmAssetsViaRpc({
+                        address: address,
+                        chain,
+                        rpcUrl,
+                        tokens: customAssetsToFetch,
+                    });
+                    if (fb.length > 0)
+                        return fb;
                 }
-            });
-            return mergedAssets;
+                return mergedAssets;
+            }
+            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);
+                return (await readEvmAssetsViaRpc({
+                    address: address,
+                    chain,
+                    rpcUrl,
+                    tokens: customAssetsToFetch,
+                }));
+            }
         },
         enabled: multiChain ? isConnected && !!address : isConnected && !!chainId && !!chain && !!address,
         staleTime,

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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}