@openfort/react 1.1.4 → 1.3.0

package/build/components/Pages/Buy/coinbaseApi.js

@@ -5,17 +5,6 @@ const getBackendUrl = () => {
     const sdkConfig = SDKConfiguration.getInstance();
     return (sdkConfig === null || sdkConfig === void 0 ? void 0 : sdkConfig.backendUrl) || 'https://api.openfort.io';
 };
-// Map chain IDs to Coinbase network names
-const getNetworkName = (chainId) => {
-    const networkMap = {
-        1: 'ethereum',
-        8453: 'base',
-        137: 'polygon',
-        42161: 'arbitrum',
-        10: 'optimism',
-    };
-    return networkMap[chainId] || 'base';
-};
 // Coinbase supported currencies (more extensive than Stripe)
 const COINBASE_SUPPORTED_CURRENCIES = [
     'btc',
@@ -61,7 +50,7 @@ const getCurrencyCode = (token) => {
  * 3. One-click with quote: One-click + paymentMethod + country (+ subdivision for US)
  */
 const createCoinbaseSession = async (params) => {
-    const { token, chainId, publishableKey, ...rest } = params;
+    const { token, network, publishableKey, ...rest } = params;
     if (!publishableKey) {
         throw new Error('Publishable key is required for authentication');
     }
@@ -69,7 +58,7 @@ const createCoinbaseSession = async (params) => {
     const requestBody = {
         provider: 'coinbase',
         destinationCurrency: getCurrencyCode(token),
-        destinationNetwork: getNetworkName(chainId),
+        destinationNetwork: network,
         destinationAddress: rest.destinationAddress,
     };
     // Add optional parameters only if provided

package/build/components/Pages/Buy/coinbaseApi.js.map

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

package/build/components/Pages/Buy/evmCurrencies.d.ts

@@ -0,0 +1,11 @@
+import type { Asset } from '../../Openfort/types';
+/**
+ * Buyable EVM destination currencies for the fiat onramp. USDC is first so it is
+ * the default; both are supported by Coinbase and Stripe. Balances aren't needed
+ * (you're buying), so these carry zero balance — only the symbol feeds the onramp
+ * `destinationCurrency`. The USDC `address` is Base USDC cast to `Hex` to fit the
+ * shared `Asset` type; it's only read by `getAssetSymbol`. Mirrors
+ * {@link SOLANA_BUY_CURRENCIES} so the card/Apple Pay picker always has options,
+ * even for a freshly created wallet with no indexed token balances.
+ */
+export declare const EVM_BUY_CURRENCIES: Asset[];

package/build/components/Pages/Buy/evmCurrencies.js

@@ -0,0 +1,27 @@
+import { DEST_USDC } from '../Deposit/sources.js';
+
+/**
+ * Buyable EVM destination currencies for the fiat onramp. USDC is first so it is
+ * the default; both are supported by Coinbase and Stripe. Balances aren't needed
+ * (you're buying), so these carry zero balance — only the symbol feeds the onramp
+ * `destinationCurrency`. The USDC `address` is Base USDC cast to `Hex` to fit the
+ * shared `Asset` type; it's only read by `getAssetSymbol`. Mirrors
+ * {@link SOLANA_BUY_CURRENCIES} so the card/Apple Pay picker always has options,
+ * even for a freshly created wallet with no indexed token balances.
+ */
+const EVM_BUY_CURRENCIES = [
+    {
+        type: 'erc20',
+        address: DEST_USDC,
+        balance: BigInt(0),
+        metadata: { symbol: 'USDC', name: 'USD Coin', decimals: 6 },
+    },
+    {
+        type: 'native',
+        balance: BigInt(0),
+        metadata: { symbol: 'ETH', decimals: 18, fiat: { value: 0, currency: 'USD' } },
+    },
+];
+
+export { EVM_BUY_CURRENCIES };
+//# sourceMappingURL=evmCurrencies.js.map

package/build/components/Pages/Buy/evmCurrencies.js.map

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

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

@@ -1,7 +1,9 @@
 import { jsxs, jsx } from 'react/jsx-runtime';
+import { ChainTypeEnum } from '@openfort/openfort-js';
 import { useState, useMemo, useEffect } from 'react';
 import { useEthereumWalletAssets } from '../../../ethereum/hooks/useEthereumWalletAssets.js';
 import useLocales from '../../../hooks/useLocales.js';
+import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
 import Button from '../../Common/Button/index.js';
 import { Arrow, ArrowChevron } from '../../Common/Button/styles.js';
 import { ModalHeading, ModalBody } from '../../Common/Modal/styles.js';
@@ -9,6 +11,7 @@ import { routes } from '../../Openfort/types.js';
 import { useOpenfort } from '../../Openfort/useOpenfort.js';
 import { PageContent } from '../../PageContent/index.js';
 import { sanitizeForParsing, sanitizeAmountInput, isSameToken, getAssetSymbol } from '../Send/utils.js';
+import { SOLANA_BUY_CURRENCIES } from './solanaCurrencies.js';
 import { Section, SectionLabel, AmountCard, CurrencySymbol, AmountInput, PresetList, PresetButton, SelectorButton, SelectorContent, SelectorTitle, SelectorSubtitle, SelectorRight, ContinueButtonWrapper } from './styles.js';
 import { createCurrencyFormatter, getCurrencySymbol } from './utils.js';
 
@@ -17,7 +20,11 @@ const Buy = () => {
     var _a;
     const { buyForm, setBuyForm, setRoute, triggerResize } = useOpenfort();
     const locales = useLocales();
-    const { data: assets } = useEthereumWalletAssets();
+    const { chainType } = useOpenfortCore();
+    const { data: ethAssets } = useEthereumWalletAssets();
+    // Solana wallets buy Solana currencies (USDC default, then SOL); EVM reads its
+    // own assets. Both hooks run unconditionally; the active chain picks the list.
+    const assets = chainType === ChainTypeEnum.SVM ? SOLANA_BUY_CURRENCIES : ethAssets;
     const [pressedPreset, setPressedPreset] = useState(null);
     const fiatAmount = useMemo(() => {
         const normalizedAmount = sanitizeForParsing(sanitizeAmountInput(buyForm.amount));
@@ -77,11 +84,12 @@ const Buy = () => {
         setRoute(routes.BUY_SELECT_PROVIDER);
     };
     const handleBack = () => {
-        setRoute(routes.CONNECTED);
+        // Card/Apple Pay is reached via the Add funds hub — back returns there.
+        setRoute(routes.DEPOSIT);
     };
     const isPresetSelected = (value) => pressedPreset === value;
     const step1Disabled = fiatAmount === null || fiatAmount <= 0;
-    return (jsxs(PageContent, { onBack: handleBack, children: [jsx(ModalHeading, { children: locales.buyScreen_heading }), jsx(ModalBody, { children: locales.buyScreen_subheading }), jsxs(Section, { children: [jsx(SectionLabel, { children: "Amount" }), jsxs(AmountCard, { children: [jsx(CurrencySymbol, { children: currencySymbol }), jsx(AmountInput, { value: buyForm.amount, onChange: handleAmountChange, onBlur: handleAmountBlur, placeholder: "0.00", inputMode: "decimal", autoComplete: "off" })] }), jsx(PresetList, { children: amountPresets.map((preset) => (jsx(PresetButton, { type: "button", onClick: () => handlePresetClick(preset), "$active": isPresetSelected(preset), children: currencyFormatter.format(preset) }, preset))) })] }), jsxs(Section, { children: [jsx(SectionLabel, { children: "Asset" }), jsxs(SelectorButton, { type: "button", onClick: handleOpenTokenSelector, children: [jsxs(SelectorContent, { children: [jsx(SelectorTitle, { children: tokenSymbol || 'Select asset' }), jsx(SelectorSubtitle, { children: tokenName })] }), jsx(SelectorRight, { children: jsx(Arrow, { width: "13", height: "12", viewBox: "0 0 13 12", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: jsx(ArrowChevron, { stroke: "currentColor", d: "M7.51431 1.5L11.757 5.74264M7.5 10.4858L11.7426 6.24314", strokeWidth: "2", strokeLinecap: "round" }) }) })] })] }), jsx(ContinueButtonWrapper, { children: jsx(Button, { variant: "primary", onClick: handleContinue, disabled: step1Disabled, children: "Continue" }) })] }));
+    return (jsxs(PageContent, { onBack: handleBack, children: [jsx(ModalHeading, { children: locales.buyScreen_heading }), jsx(ModalBody, { children: locales.buyScreen_subheading }), jsxs(Section, { children: [jsx(SectionLabel, { children: "Amount" }), jsxs(AmountCard, { children: [jsx(CurrencySymbol, { children: currencySymbol }), jsx(AmountInput, { value: buyForm.amount, onChange: handleAmountChange, onBlur: handleAmountBlur, placeholder: "0.00", inputMode: "decimal", autoComplete: "off" })] }), jsx(PresetList, { children: amountPresets.map((preset) => (jsx(PresetButton, { type: "button", onClick: () => handlePresetClick(preset), "$active": isPresetSelected(preset), children: currencyFormatter.format(preset) }, preset))) })] }), jsxs(Section, { children: [jsx(SectionLabel, { children: "Currency" }), jsxs(SelectorButton, { type: "button", onClick: handleOpenTokenSelector, children: [jsxs(SelectorContent, { children: [jsx(SelectorTitle, { children: tokenSymbol || 'Select currency' }), jsx(SelectorSubtitle, { children: tokenName })] }), jsx(SelectorRight, { children: jsx(Arrow, { width: "13", height: "12", viewBox: "0 0 13 12", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: jsx(ArrowChevron, { stroke: "currentColor", d: "M7.51431 1.5L11.757 5.74264M7.5 10.4858L11.7426 6.24314", strokeWidth: "2", strokeLinecap: "round" }) }) })] })] }), jsx(ContinueButtonWrapper, { children: jsx(Button, { variant: "primary", onClick: handleContinue, disabled: step1Disabled, children: "Continue" }) })] }));
 };
 
 export { Buy as default };

package/build/components/Pages/Buy/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/components/Pages/Buy/onrampApi.d.ts

@@ -1,3 +1,4 @@
+import { ChainTypeEnum } from '@openfort/openfort-js';
 import type { Asset } from '../../Openfort/types';
 export type OnrampQuote = {
     provider: string;
@@ -13,9 +14,15 @@ export type OnrampQuote = {
     }>;
     exchangeRate: string;
 };
+/**
+ * Resolve the onramp destination network for the active chain. Solana always
+ * resolves to `solana`; an EVM wallet whose `chainId` hasn't loaded yet returns
+ * `undefined`, so callers stay gated until the chain is ready.
+ */
+export declare function resolveOnrampNetwork(chainType: ChainTypeEnum, chainId?: number): string | undefined;
 type GetAllQuotesParams = {
     token: Asset;
-    chainId: number;
+    network: string;
     publishableKey: string;
     sourceCurrency: string;
     sourceAmount: string;

package/build/components/Pages/Buy/onrampApi.js

@@ -1,21 +1,31 @@
-import { SDKConfiguration } from '@openfort/openfort-js';
+import { ChainTypeEnum, SDKConfiguration } from '@openfort/openfort-js';
 import { getAssetSymbol } from '../Send/utils.js';
 
 const getBackendUrl = () => {
     const sdkConfig = SDKConfiguration.getInstance();
     return (sdkConfig === null || sdkConfig === void 0 ? void 0 : sdkConfig.backendUrl) || 'https://api.openfort.io';
 };
-// Map chain IDs to network names
-const getNetworkName = (chainId) => {
-    const networkMap = {
-        1: 'ethereum',
-        8453: 'base',
-        137: 'polygon',
-        42161: 'arbitrum',
-        10: 'optimism',
-    };
-    return networkMap[chainId] || 'base';
+/** EVM chain id → onramp network name. */
+const EVM_NETWORK_MAP = {
+    1: 'ethereum',
+    8453: 'base',
+    137: 'polygon',
+    42161: 'arbitrum',
+    10: 'optimism',
 };
+/**
+ * Resolve the onramp destination network for the active chain. Solana always
+ * resolves to `solana`; an EVM wallet whose `chainId` hasn't loaded yet returns
+ * `undefined`, so callers stay gated until the chain is ready.
+ */
+function resolveOnrampNetwork(chainType, chainId) {
+    var _a;
+    if (chainType === ChainTypeEnum.SVM)
+        return 'solana';
+    if (chainId == null)
+        return undefined;
+    return (_a = EVM_NETWORK_MAP[chainId]) !== null && _a !== void 0 ? _a : 'base';
+}
 // Map token symbol to currency code
 const getCurrencyCode = (token) => {
     return getAssetSymbol(token).toLowerCase();
@@ -25,14 +35,14 @@ const getCurrencyCode = (token) => {
  * Calls the backend without specifying a provider to get quotes from all providers
  */
 const getAllQuotes = async (params) => {
-    const { token, chainId, publishableKey, sourceCurrency, sourceAmount } = params;
+    const { token, network, publishableKey, sourceCurrency, sourceAmount } = params;
     if (!publishableKey) {
         throw new Error('Publishable key is required for authentication');
     }
     // Build request body WITHOUT provider to get all quotes
     const requestBody = {
         destinationCurrency: getCurrencyCode(token),
-        destinationNetwork: getNetworkName(chainId),
+        destinationNetwork: network,
         sourceCurrency: sourceCurrency.toLowerCase(),
         sourceAmount,
     };
@@ -53,5 +63,5 @@ const getAllQuotes = async (params) => {
     return Array.isArray(data) ? data : [data];
 };
 
-export { getAllQuotes };
+export { getAllQuotes, resolveOnrampNetwork };
 //# sourceMappingURL=onrampApi.js.map

package/build/components/Pages/Buy/onrampApi.js.map

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

package/build/components/Pages/Buy/solanaCurrencies.d.ts

@@ -0,0 +1,9 @@
+import type { Asset } from '../../Openfort/types';
+/**
+ * Buyable Solana destination currencies for the fiat onramp. USDC is first so it
+ * is the default; both are supported by Coinbase and Stripe on Solana. Balances
+ * aren't needed (you're buying), so these carry zero balance — only the symbol
+ * feeds the onramp `destinationCurrency`. The USDC `address` is the SPL mint cast
+ * to `Hex` to fit the shared `Asset` type; it's only read by `getAssetSymbol`.
+ */
+export declare const SOLANA_BUY_CURRENCIES: Asset[];

package/build/components/Pages/Buy/solanaCurrencies.js

@@ -0,0 +1,25 @@
+import { DEST_USDC_SOL } from '../Deposit/sources.js';
+
+/**
+ * Buyable Solana destination currencies for the fiat onramp. USDC is first so it
+ * is the default; both are supported by Coinbase and Stripe on Solana. Balances
+ * aren't needed (you're buying), so these carry zero balance — only the symbol
+ * feeds the onramp `destinationCurrency`. The USDC `address` is the SPL mint cast
+ * to `Hex` to fit the shared `Asset` type; it's only read by `getAssetSymbol`.
+ */
+const SOLANA_BUY_CURRENCIES = [
+    {
+        type: 'erc20',
+        address: DEST_USDC_SOL,
+        balance: BigInt(0),
+        metadata: { symbol: 'USDC', name: 'USD Coin', decimals: 6 },
+    },
+    {
+        type: 'native',
+        balance: BigInt(0),
+        metadata: { symbol: 'SOL', decimals: 9, fiat: { value: 0, currency: 'USD' } },
+    },
+];
+
+export { SOLANA_BUY_CURRENCIES };
+//# sourceMappingURL=solanaCurrencies.js.map

package/build/components/Pages/Buy/solanaCurrencies.js.map

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

package/build/components/Pages/Buy/stripeApi.d.ts

@@ -21,7 +21,7 @@ export declare const isStripeSupported: (token: Asset) => boolean;
  */
 export declare const createStripeSession: (params: Omit<CreateStripeSessionParams, "destinationCurrency" | "destinationNetwork"> & {
     token: Asset;
-    chainId: number;
+    network: string;
     publishableKey: string;
 }) => Promise<StripeOnrampResponse>;
 export {};

package/build/components/Pages/Buy/stripeApi.js

@@ -5,17 +5,6 @@ const getBackendUrl = () => {
     const sdkConfig = SDKConfiguration.getInstance();
     return (sdkConfig === null || sdkConfig === void 0 ? void 0 : sdkConfig.backendUrl) || 'https://api.openfort.io';
 };
-// Map chain IDs to Stripe network names
-const getNetworkName = (chainId) => {
-    const networkMap = {
-        1: 'ethereum',
-        8453: 'base',
-        137: 'polygon',
-        42161: 'arbitrum',
-        10: 'optimism',
-    };
-    return networkMap[chainId] || 'base';
-};
 // Stripe supported currencies
 const STRIPE_SUPPORTED_CURRENCIES = ['btc', 'eth', 'xlm', 'matic', 'pol', 'sol', 'usdc', 'avax', 'wld'];
 // Check if a token is supported by Stripe
@@ -38,12 +27,12 @@ const getCurrencyCode = (token) => {
  * Calls backend API to create a prefilled session with wallet addresses and amounts
  */
 const createStripeSession = async (params) => {
-    const { token, chainId, publishableKey, destinationAddress, sourceAmount, sourceCurrency, redirectUrl } = params;
+    const { token, network, publishableKey, destinationAddress, sourceAmount, sourceCurrency, redirectUrl } = params;
     if (!publishableKey) {
         throw new Error('Publishable key is required for authentication');
     }
     const destinationCurrency = getCurrencyCode(token);
-    const destinationNetwork = getNetworkName(chainId);
+    const destinationNetwork = network;
     // Build request body for backend API
     const requestBody = {
         provider: 'stripe',

package/build/components/Pages/Buy/stripeApi.js.map

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

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

@@ -39,7 +39,13 @@ const BuyComplete = () => {
     const handleBack = () => {
         setRoute(routes.CONNECTED);
     };
-    const blockExplorerUrl = address && chainId ? getExplorerUrl(ChainTypeEnum.EVM, { chainId, address }) : '';
+    const blockExplorerUrl = !address
+        ? ''
+        : chainType === ChainTypeEnum.SVM
+            ? getExplorerUrl(ChainTypeEnum.SVM, { address, cluster: solanaWallet.cluster })
+            : chainId
+                ? getExplorerUrl(ChainTypeEnum.EVM, { chainId, address })
+                : '';
     return (jsx(PageContent, { onBack: handleBack, children: jsxs(ModalContent, { style: { paddingBottom: 18, textAlign: 'center' }, children: [jsx(ModalH1, { children: "Provider Finished" }), jsx(ModalBody, { style: { marginTop: 24 }, children: "The provider flow has been completed. You can view your wallet on the block explorer to check your transactions." }), jsxs(Section, { style: { marginTop: 24 }, children: [blockExplorerUrl && (jsx(ContinueButtonWrapper, { style: { marginTop: 0 }, children: jsx(Button, { variant: "secondary", onClick: () => window.open(blockExplorerUrl, '_blank', 'noopener,noreferrer'), children: jsxs("div", { style: { display: 'flex', alignItems: 'center', gap: '8px' }, children: [jsx("span", { children: "View Wallet Transactions" }), jsx(ExternalLinkIcon, {})] }) }) })), jsx(ContinueButtonWrapper, { style: { marginTop: blockExplorerUrl ? 4 : 0 }, children: jsx(Button, { variant: "primary", onClick: handleDone, children: "Done" }) })] })] }) }));
 };
 

package/build/components/Pages/BuyComplete/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/components/Pages/BuyProcessing/index.js

@@ -13,6 +13,8 @@ import { routes } from '../../Openfort/types.js';
 import { useOpenfort } from '../../Openfort/useOpenfort.js';
 import { PageContent } from '../../PageContent/index.js';
 import { createCoinbaseSession } from '../Buy/coinbaseApi.js';
+import { resolveOnrampNetwork } from '../Buy/onrampApi.js';
+import { SOLANA_BUY_CURRENCIES } from '../Buy/solanaCurrencies.js';
 import { createStripeSession } from '../Buy/stripeApi.js';
 import { ContinueButtonWrapper, PendingContainer, StackedButtonWrapper } from '../Buy/styles.js';
 import { isSameToken } from '../Send/utils.js';
@@ -27,11 +29,13 @@ const BuyProcessing = () => {
     const isConnected = wallet.status === 'connected';
     const address = isConnected ? wallet.address : undefined;
     const chainId = isConnected && chainType === ChainTypeEnum.EVM ? wallet.chainId : undefined;
+    const network = resolveOnrampNetwork(chainType, chainId);
     const [popupWindow, setPopupWindow] = useState(null);
     const [showContinueButton, setShowContinueButton] = useState(false);
     const [isCreatingSession, setIsCreatingSession] = useState(true);
     const [sessionError, setSessionError] = useState(false);
-    const { data: assets } = useEthereumWalletAssets();
+    const { data: ethAssets } = useEthereumWalletAssets();
+    const assets = chainType === ChainTypeEnum.SVM ? SOLANA_BUY_CURRENCIES : ethAssets;
     const matchedToken = useMemo(() => assets === null || assets === void 0 ? void 0 : assets.find((asset) => isSameToken(asset, buyForm.asset)), [assets, buyForm.asset]);
     const selectedTokenOption = matchedToken !== null && matchedToken !== void 0 ? matchedToken : assets === null || assets === void 0 ? void 0 : assets[0];
     const selectedToken = selectedTokenOption !== null && selectedTokenOption !== void 0 ? selectedTokenOption : buyForm.asset;
@@ -47,7 +51,7 @@ const BuyProcessing = () => {
     // Create session and open popup once wallet is ready
     const sessionStartedRef = useRef(false);
     useEffect(() => {
-        if (!address || !chainId)
+        if (!address || !network)
             return;
         if (sessionStartedRef.current)
             return;
@@ -65,7 +69,7 @@ const BuyProcessing = () => {
                 if (buyForm.providerId === 'coinbase') {
                     const session = await createCoinbaseSession({
                         token: selectedToken,
-                        chainId,
+                        network,
                         publishableKey,
                         destinationAddress: address,
                         sourceAmount: fiatAmount.toFixed(2),
@@ -77,7 +81,7 @@ const BuyProcessing = () => {
                 else if (buyForm.providerId === 'stripe') {
                     const session = await createStripeSession({
                         token: selectedToken,
-                        chainId,
+                        network,
                         publishableKey,
                         destinationAddress: address,
                         sourceAmount: fiatAmount.toFixed(2),
@@ -129,7 +133,7 @@ const BuyProcessing = () => {
             }
         };
         createSessionAndOpenPopup();
-    }, [address, chainId]); // Run when wallet becomes ready
+    }, [address, network]); // Run when wallet becomes ready
     // Trigger resize on mount and when state changes
     useEffect(() => {
         triggerResize();

package/build/components/Pages/BuyProcessing/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/components/Pages/BuySelectProvider/index.js

@@ -11,8 +11,9 @@ import { routes } from '../../Openfort/types.js';
 import { useOpenfort } from '../../Openfort/useOpenfort.js';
 import { PageContent } from '../../PageContent/index.js';
 import { isCoinbaseSupported } from '../Buy/coinbaseApi.js';
-import { getAllQuotes } from '../Buy/onrampApi.js';
+import { resolveOnrampNetwork, getAllQuotes } from '../Buy/onrampApi.js';
 import { getProviders } from '../Buy/providers.js';
+import { SOLANA_BUY_CURRENCIES } from '../Buy/solanaCurrencies.js';
 import { isStripeSupported } from '../Buy/stripeApi.js';
 import { ProviderList, ProviderButton, ProviderInfo, ProviderNameRow, ProviderName, ProviderBadge, ProviderMeta, ProviderRight, ProviderQuote, ProviderFiat, ContinueButtonWrapper } from '../Buy/styles.js';
 import { createCurrencyFormatter, formatTokenAmount } from '../Buy/utils.js';
@@ -28,6 +29,9 @@ const BuySelectProvider = () => {
     const isConnected = wallet.status === 'connected';
     const address = isConnected ? wallet.address : undefined;
     const chainId = isConnected && chainType === ChainTypeEnum.EVM ? wallet.chainId : undefined;
+    // The onramp destination network: 'solana' for SVM, else the EVM network (undefined
+    // until the EVM chainId resolves, which keeps quote fetching gated as before).
+    const network = resolveOnrampNetwork(chainType, chainId);
     const [quotes, setQuotes] = useState({});
     const [isLoadingQuote, setIsLoadingQuote] = useState(false);
     const [coinbaseError, setCoinbaseError] = useState(false);
@@ -43,7 +47,8 @@ const BuySelectProvider = () => {
             return null;
         return numeric;
     }, [buyForm.amount]);
-    const { data: assets } = useEthereumWalletAssets();
+    const { data: ethAssets } = useEthereumWalletAssets();
+    const assets = chainType === ChainTypeEnum.SVM ? SOLANA_BUY_CURRENCIES : ethAssets;
     const matchedToken = useMemo(() => assets === null || assets === void 0 ? void 0 : assets.find((asset) => isSameToken(asset, buyForm.asset)), [assets, buyForm.asset]);
     const selectedTokenOption = matchedToken !== null && matchedToken !== void 0 ? matchedToken : assets === null || assets === void 0 ? void 0 : assets[0];
     const selectedToken = selectedTokenOption !== null && selectedTokenOption !== void 0 ? selectedTokenOption : buyForm.asset;
@@ -77,7 +82,7 @@ const BuySelectProvider = () => {
     // Fetch quotes from all providers
     useEffect(() => {
         const fetchQuotes = async () => {
-            if (!address || !chainId || !fiatAmount || fiatAmount <= 0) {
+            if (!address || !network || !fiatAmount || fiatAmount <= 0) {
                 setQuotes({});
                 setCoinbaseError(false);
                 setStripeError(false);
@@ -89,7 +94,7 @@ const BuySelectProvider = () => {
             try {
                 const allQuotes = await getAllQuotes({
                     token: selectedToken,
-                    chainId,
+                    network,
                     publishableKey,
                     sourceAmount: fiatAmount.toFixed(2),
                     sourceCurrency: buyForm.currency,
@@ -120,7 +125,7 @@ const BuySelectProvider = () => {
         selectedToken.metadata,
         selectedToken.type,
         buyForm.currency,
-        chainId,
+        network,
         address,
         publishableKey,
         refetchTrigger,
@@ -147,7 +152,7 @@ const BuySelectProvider = () => {
             .filter((n) => Number.isFinite(n));
         return amounts.length > 0 ? Math.max(...amounts) : null;
     }, [quotes]);
-    return (jsxs(PageContent, { onBack: handleBack, children: [jsx(ModalHeading, { children: "Select Provider" }), jsx(ModalBody, { children: formattedFiat && `Buying ${formattedFiat} of ${tokenSymbol}` }), jsx(ModalBody, { style: { marginTop: 4, fontSize: '12px', opacity: 0.7 }, children: isLoadingQuote ? 'Loading quotes...' : `Quotes refresh in ${quoteRefreshTimer}s` }), jsx(ProviderList, { children: providers.map((provider) => {
+    return (jsxs(PageContent, { onBack: handleBack, children: [jsx(ModalHeading, { children: "Select Provider" }), jsxs("div", { style: { textAlign: 'center', margin: '6px 0 16px' }, children: [jsx("div", { style: { fontSize: 13, color: 'var(--ck-body-color-muted)' }, children: "You pay" }), jsx("div", { style: { fontSize: 30, fontWeight: 700, lineHeight: 1.1, color: 'var(--ck-body-color)' }, children: formattedFiat || '—' }), targetDestinationAmount !== null && (jsxs("div", { style: { fontSize: 14, fontWeight: 500, color: 'var(--ck-body-color-muted)', marginTop: 4 }, children: ["\u2248 ", targetDestinationAmount.toFixed(2), " ", tokenSymbol] }))] }), jsx(ModalBody, { style: { marginTop: 0, fontSize: '12px', opacity: 0.7 }, children: isLoadingQuote ? 'Loading quotes…' : `Quotes refresh in ${quoteRefreshTimer}s` }), jsx(ProviderList, { children: providers.map((provider) => {
                     var _a, _b, _c, _d, _e, _f;
                     // Get provider-specific quote data
                     const providerQuote = quotes[provider.id];

package/build/components/Pages/BuySelectProvider/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/components/Pages/Connected/EthereumConnected.js

@@ -1,9 +1,8 @@
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import { ChainTypeEnum } from '@openfort/openfort-js';
-import { AnimatePresence, motion } from 'framer-motion';
-import { lazy, useEffect, useMemo, useState, Suspense } from 'react';
+import { lazy, useEffect, useMemo, Suspense } from 'react';
 import { formatUnits } from 'viem';
-import { UserRoundIcon, SendIcon, ReceiveIcon, BuyIcon } from '../../../assets/icons.js';
+import { UserRoundIcon, SendIcon, ReceiveIcon } from '../../../assets/icons.js';
 import { useEthereumEmbeddedWallet } from '../../../ethereum/hooks/useEthereumEmbeddedWallet.js';
 import { useEthereumWalletAssets } from '../../../ethereum/hooks/useEthereumWalletAssets.js';
 import { useEthereumBridge } from '../../../ethereum/OpenfortEthereumBridgeContext.js';
@@ -17,7 +16,6 @@ import Button from '../../Common/Button/index.js';
 import { TextLinkButton } from '../../Common/Button/styles.js';
 import Chain from '../../Common/Chain/index.js';
 import { CopyText } from '../../Common/CopyToClipboard/CopyText.js';
-import { ModalBody } from '../../Common/Modal/styles.js';
 import { useThemeContext } from '../../ConnectKitThemeProvider/ConnectKitThemeProvider.js';
 import { routes, defaultSendFormState } from '../../Openfort/types.js';
 import { useOpenfort } from '../../Openfort/useOpenfort.js';
@@ -32,7 +30,7 @@ function getFirstBalanceAsset(assets) {
     return assets === null || assets === void 0 ? void 0 : assets.find((a) => a.balance && a.balance > BigInt(0));
 }
 const EthereumConnected = () => {
-    var _a, _b, _c, _d;
+    var _a, _b, _c;
     const context = useOpenfort();
     const { setHeaderLeftSlot, setRoute, chains } = context;
     const themeContext = useThemeContext();
@@ -64,7 +62,7 @@ const EthereumConnected = () => {
         enabled: isConnected && !!address,
     });
     const ensName = identity.status === 'success' ? identity.name : undefined;
-    const { data: assets, isLoading, refetch } = useEthereumWalletAssets();
+    const { data: assets, isLoading } = useEthereumWalletAssets();
     const totalBalanceUsd = useMemo(() => {
         if (!assets)
             return 0;
@@ -79,31 +77,9 @@ const EthereumConnected = () => {
             return acc + price * balance;
         }, 0);
     }, [assets]);
-    useEffect(() => {
-        if (isConnected) {
-            refetch();
-        }
-    }, [isConnected, refetch]);
-    const isTestnet = (_b = chain === null || chain === void 0 ? void 0 : chain.testnet) !== null && _b !== void 0 ? _b : false;
-    const [showTestnetMessage, setShowTestnetMessage] = useState(false);
     useEffect(() => {
         context.triggerResize();
-        if (showTestnetMessage) {
-            const timer = setTimeout(() => {
-                setShowTestnetMessage(false);
-            }, 2000);
-            return () => clearTimeout(timer);
-        }
-    }, [showTestnetMessage, context.triggerResize]);
-    const handleBuyClick = (e) => {
-        if (!chain || isTestnet) {
-            e.preventDefault();
-            setShowTestnetMessage(true);
-        }
-        else {
-            context.setRoute(routes.BUY);
-        }
-    };
+    }, [context.triggerResize]);
     useEffect(() => {
         if (!address) {
             setHeaderLeftSlot(null);
@@ -115,11 +91,11 @@ const EthereumConnected = () => {
         };
     }, [address, setHeaderLeftSlot, setRoute]);
     const { setSendForm } = context;
-    const separator = ['web95', 'rounded', 'minimal'].includes((_d = (_c = themeContext.theme) !== null && _c !== void 0 ? _c : context.uiConfig.theme) !== null && _d !== void 0 ? _d : '')
+    const separator = ['web95', 'rounded', 'minimal'].includes((_c = (_b = themeContext.theme) !== null && _b !== void 0 ? _b : context.uiConfig.theme) !== null && _c !== void 0 ? _c : '')
         ? '....'
         : undefined;
     const locales = useLocales();
-    const balanceNode = !!assets && !isLoading ? (jsx(TextLinkButton, { type: "button", onClick: () => {
+    const balanceNode = assets && !isLoading ? (jsx(TextLinkButton, { type: "button", onClick: () => {
             const firstBalanceAsset = getFirstBalanceAsset(assets);
             if (!firstBalanceAsset) {
                 setRoute(routes.NO_ASSETS_AVAILABLE);
@@ -136,7 +112,7 @@ const EthereumConnected = () => {
                             }
                             setSendForm({ ...defaultSendFormState, asset: firstBalanceAsset });
                             context.setRoute(routes.SEND);
-                        }, children: "Send" }), jsx(ActionButton, { icon: jsx(ReceiveIcon, {}), onClick: () => context.setRoute(routes.RECEIVE), children: "Get" }), jsx(ActionButton, { icon: jsx(BuyIcon, {}), onClick: handleBuyClick, style: isTestnet ? { cursor: 'not-allowed', opacity: 0.4, pointerEvents: 'auto' } : undefined, children: "Buy" })] }), hideBalance: context === null || context === void 0 ? void 0 : context.uiConfig.hideBalance, isBalanceLoading: isLoading, noWalletFallback: noWalletFallback, afterActions: jsx(AnimatePresence, { onExitComplete: () => context.triggerResize(), children: showTestnetMessage && (jsx(ModalBody, { as: motion.div, initial: { opacity: 0, y: -10 }, animate: { opacity: 0.7, y: 0 }, exit: { opacity: 0, y: -10 }, transition: { duration: 0.2 }, style: { marginTop: 12, fontSize: 14, textAlign: 'center' }, children: "Buy is only available on mainnet chains" })) }) }) }));
+                        }, children: "Send" }), jsx(ActionButton, { icon: jsx(ReceiveIcon, {}), onClick: () => context.setRoute(routes.DEPOSIT), children: "Deposit" })] }), hideBalance: context === null || context === void 0 ? void 0 : context.uiConfig.hideBalance, isBalanceLoading: isLoading, noWalletFallback: noWalletFallback }) }));
 };
 
 export { EthereumConnected as default };

package/build/components/Pages/Connected/EthereumConnected.js.map

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