@openfort/react 1.2.0 → 1.3.0

package/build/assets/logos.d.ts

@@ -82,6 +82,9 @@ declare const _default: {
         [x: string]: any;
         background?: boolean | undefined;
     }) => import("react/jsx-runtime").JSX.Element;
+    Solana: ({ ...props }: {
+        [x: string]: any;
+    }) => import("react/jsx-runtime").JSX.Element;
     PlaceHolder: () => import("react/jsx-runtime").JSX.Element;
     Frame: ({ ...props }: {
         [x: string]: any;

package/build/assets/logos.js

@@ -57,6 +57,7 @@ const Zerion = ({ ...props }) => (jsxs("svg", { ...props, width: "88", height: "
         background: 'linear-gradient(120.22deg, #2962EF 0%, #255CE5 100%)',
     }, children: [jsx("path", { d: "M19.0864 22C17.5783 22 16.9973 23.8648 18.2628 24.6438L49.9199 43.732C50.709 44.2178 51.7614 44.0258 52.3048 43.2969L66.2236 25.024C67.17 23.7545 66.2138 22 64.5757 22H19.0864Z", fill: "white" }), jsx("path", { d: "M68.8425 66C70.3503 66 70.9466 64.1252 69.6814 63.3464L38.015 44.2605C37.2259 43.7748 36.1989 43.991 35.6558 44.7198L21.7099 62.9891C20.7639 64.2582 21.7499 66 23.3877 66H68.8425Z", fill: "white" })] }));
 const Phantom = ({ background = false, ...props }) => (jsx("svg", { ...props, width: "88", height: "88", viewBox: "0 0 88 88", fill: "none", xmlns: "http://www.w3.org/2000/svg", style: background ? { background: '#AB9FF2' } : undefined, children: jsx("path", { fillRule: "evenodd", clipRule: "evenodd", d: "M37.7425 57.0705C34.1942 62.3362 28.2483 69 20.3366 69C16.5965 69 13.0001 67.5093 13 61.0322C12.9997 44.5362 36.2555 19.0003 57.8334 19C70.1084 18.9998 75 27.2474 75 36.6136C75 48.6357 66.9442 62.3824 58.9368 62.3824C56.3955 62.3824 55.1487 61.031 55.1487 58.888C55.1487 58.3288 55.2442 57.7228 55.4365 57.0705C52.7029 61.5902 47.4285 65.7849 42.4896 65.7849C38.8933 65.7849 37.0713 63.5944 37.0713 60.5187C37.0713 59.4003 37.311 58.2357 37.7425 57.0705ZM53.7586 31.6834C51.8054 31.6868 50.4738 33.2938 50.478 35.5864C50.4822 37.879 51.8198 39.5273 53.7729 39.5241C55.6789 39.5208 57.0099 37.8679 57.0058 35.5752C57.0016 33.2827 55.6646 31.6802 53.7586 31.6834ZM64.1193 31.6725C62.1661 31.6759 60.8345 33.2829 60.8387 35.5755C60.8429 37.868 62.1798 39.5164 64.1336 39.5131C66.0396 39.5099 67.3706 37.8569 67.3664 35.5643C67.3622 33.2718 66.0253 31.6693 64.1193 31.6725Z", fill: background ? '#ffffff' : 'currentColor' }) }));
+const Solana = ({ ...props }) => (jsxs("svg", { ...props, viewBox: "0 0 398 312", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: [jsx("title", { children: "Solana" }), jsx("defs", { children: jsxs("linearGradient", { id: "openfort-solana-gradient", x1: "360.879", y1: "-37.455", x2: "141.213", y2: "383.294", gradientUnits: "userSpaceOnUse", children: [jsx("stop", { stopColor: "#00FFA3" }), jsx("stop", { offset: "1", stopColor: "#DC1FFF" })] }) }), jsx("path", { fill: "url(#openfort-solana-gradient)", d: "M64.6 237.9c2.4-2.4 5.7-3.8 9.2-3.8h317.4c5.8 0 8.7 7 4.6 11.1l-62.7 62.7c-2.4 2.4-5.7 3.8-9.2 3.8H15.5c-5.8 0-8.7-7-4.6-11.1L64.6 237.9z" }), jsx("path", { fill: "url(#openfort-solana-gradient)", d: "M64.6 3.8C67.1 1.4 70.4 0 73.8 0h317.4c5.8 0 8.7 7 4.6 11.1l-62.7 62.7c-2.4 2.4-5.7 3.8-9.2 3.8H15.5c-5.8 0-8.7-7-4.6-11.1L64.6 3.8z" }), jsx("path", { fill: "url(#openfort-solana-gradient)", d: "M333.1 120.1c-2.4-2.4-5.7-3.8-9.2-3.8H6.5c-5.8 0-8.7 7-4.6 11.1l62.7 62.7c2.4 2.4 5.7 3.8 9.2 3.8h317.4c5.8 0 8.7-7 4.6-11.1L333.1 120.1z" })] }));
 const PlaceHolder = () => {
     return jsx("div", { style: { width: 80, height: 80, background: '#555' } });
 };
@@ -155,6 +156,7 @@ var Logos = {
     Frontier,
     Zerion,
     Phantom,
+    Solana,
     PlaceHolder,
     Frame,
     Dawn,

package/build/assets/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/components/Common/SolanaChain/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Read-only Solana network indicator for the Connected modal — the Solana logo,
+ * with the active cluster shown on hover. There is no switch: the cluster is
+ * fixed by `walletConfig.solana`, and switching between Solana and EVM is
+ * intentionally unsupported.
+ */
+declare const SolanaChain: () => import("react/jsx-runtime").JSX.Element;
+export default SolanaChain;

package/build/components/Common/SolanaChain/index.js

@@ -0,0 +1,40 @@
+import { jsx } from 'react/jsx-runtime';
+import Logos from '../../../assets/logos.js';
+import { useSolanaContext } from '../../../solana/SolanaContext.js';
+import styled from '../../../styles/styled/index.js';
+import Tooltip from '../Tooltip/index.js';
+
+/** `mainnet-beta` → "Mainnet"; otherwise capitalize the cluster name. */
+function formatCluster(cluster) {
+    if (!cluster)
+        return '';
+    if (cluster === 'mainnet-beta')
+        return 'Mainnet';
+    return cluster.charAt(0).toUpperCase() + cluster.slice(1);
+}
+const Badge = styled.div `
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 24px;
+  height: 24px;
+  border-radius: 50%;
+  background: #131313;
+  border: 2px solid var(--ck-body-background, #fff);
+  box-sizing: border-box;
+`;
+/**
+ * Read-only Solana network indicator for the Connected modal — the Solana logo,
+ * with the active cluster shown on hover. There is no switch: the cluster is
+ * fixed by `walletConfig.solana`, and switching between Solana and EVM is
+ * intentionally unsupported.
+ */
+const SolanaChain = () => {
+    var _a;
+    const cluster = (_a = useSolanaContext()) === null || _a === void 0 ? void 0 : _a.cluster;
+    const label = cluster ? `Solana · ${formatCluster(cluster)}` : 'Solana';
+    return (jsx(Tooltip, { message: label, children: jsx(Badge, { "aria-label": label, children: jsx(Logos.Solana, { style: { width: '62%', height: 'auto' } }) }) }));
+};
+
+export { SolanaChain as default };
+//# sourceMappingURL=index.js.map

package/build/components/Common/SolanaChain/index.js.map

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

package/build/components/ConnectModal/index.js

@@ -46,6 +46,7 @@ import Receive from '../Pages/Receive/index.js';
 import RecoverPage from '../Pages/Recover/index.js';
 import RemoveLinkedProvider from '../Pages/RemoveLinkedProvider/index.js';
 import SelectToken from '../Pages/SelectToken/index.js';
+import { SolanaSelectToken } from '../Pages/SelectToken/SolanaSelectToken.js';
 import SelectWalletToRecover from '../Pages/SelectWalletToRecover/index.js';
 import Send from '../Pages/Send/index.js';
 import { SolanaSend } from '../Pages/Send/SolanaSend.js';
@@ -121,6 +122,7 @@ const CHAIN_PREFIXED_PAGES = {
         'sol:createWallet': jsx(CreateWallet, {}),
         'sol:recoverWallet': jsx(RecoverPage, {}),
         'sol:send': jsx(SolanaSend, {}),
+        'sol:sendTokenSelect': jsx(SolanaSelectToken, {}),
         'sol:sendConfirmation': jsx(SolanaSendConfirmation, {}),
         'sol:receive': jsx(Receive, {}),
         'sol:assetInventory': jsx(SolanaAssetInventory, {}),

package/build/components/ConnectModal/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/Openfort/types.d.ts

@@ -66,6 +66,7 @@ export declare const routes: {
     readonly SOL_CREATE_WALLET: "sol:createWallet";
     readonly SOL_RECOVER_WALLET: "sol:recoverWallet";
     readonly SOL_SEND: "sol:send";
+    readonly SOL_SEND_TOKEN_SELECT: "sol:sendTokenSelect";
     readonly SOL_SEND_CONFIRMATION: "sol:sendConfirmation";
     readonly SOL_RECEIVE: "sol:receive";
     readonly SOL_ASSET_INVENTORY: "sol:assetInventory";
@@ -299,12 +300,9 @@ export type ConnectUIOptions = {
     buyFromExchangeUrl?: string;
     buyTroubleshootingUrl?: string;
     /**
-     * Base URL of the openfort-funding backend (e.g. `https://funding.openfort.io`).
-     * Powers the Deposit hub's crypto/CEX rails (session API). When omitted, those
-     * rails are unavailable and the network layer is a no-op.
-     *
-     * TODO(openfort-funding-backend): default this from the platform config once the
-     * backend ships, so integrators don't have to set it manually.
+     * Base URL of the funding JSON API serving `/v2/funding/*` (chains + sessions).
+     * Defaults to the SDK's backend URL (`https://api.openfort.io`); set this only to
+     * point the Deposit hub's crypto rails at a custom funding service.
      */
     fundingBaseUrl?: string;
     /** Deposit-hub funding options (destination chain/token for incoming deposits). */
@@ -346,11 +344,6 @@ export type FundingUIOptions = {
      * @default USDC on Base
      */
     targetCurrency?: string;
-    /**
-     * Destination wallet that receives the deposit. Optional integrator override;
-     * when unset, deposits land on the active embedded wallet for the target chain.
-     */
-    targetAddress?: string;
     /**
      * Which funding methods the Deposit hub shows, and in what order. Omit to show
      * all available methods (Apple Pay first on mobile). Mirrors `authProviders`.
@@ -457,6 +450,19 @@ export type Asset = {
         };
     };
     raw?: getAssets.Erc20Asset;
+} | {
+    type: 'spl';
+    address: string;
+    balance: bigint;
+    metadata: {
+        decimals: number;
+        symbol: string;
+        name: string;
+        fiat?: {
+            value: number;
+            currency: string;
+        };
+    };
 };
 export type MultiChainAsset = Asset & {
     chainId: number;

package/build/components/Openfort/types.js

@@ -56,6 +56,7 @@ const routes = {
     SOL_CREATE_WALLET: 'sol:createWallet',
     SOL_RECOVER_WALLET: 'sol:recoverWallet',
     SOL_SEND: 'sol:send',
+    SOL_SEND_TOKEN_SELECT: 'sol:sendTokenSelect',
     SOL_SEND_CONFIRMATION: 'sol:sendConfirmation',
     SOL_RECEIVE: 'sol:receive',
     SOL_ASSET_INVENTORY: 'sol:assetInventory',

package/build/components/Openfort/types.js.map

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

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

@@ -25,7 +25,7 @@ export declare const isCoinbaseSupported: (token: Asset) => boolean;
  */
 export declare const createCoinbaseSession: (params: Omit<CreateCoinbaseSessionParams, "destinationCurrency" | "destinationNetwork"> & {
     token: Asset;
-    chainId: number;
+    network: string;
     publishableKey: string;
 }) => Promise<CoinbaseOnrampResponse>;
 export {};

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));

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