@openfort/react 1.2.0 → 1.4.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/Modal/styles.js

@@ -237,6 +237,9 @@ const BoxContainer = styled(motion.div) `
     left: 50%;
     width: var(--width);
     height: var(--height);
+    /* Match InnerContainer's viewport cap so a tall page's card background
+       doesn't run off-screen while the content scrolls inside. */
+    max-height: 88vh;
     transform: translateX(-50%);
     backface-visibility: hidden;
     transition: all 200ms ease;

package/build/components/Common/Modal/styles.js.map

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

package/build/components/Common/ScrollArea/index.d.ts

@@ -1,7 +1,11 @@
 import type React from 'react';
-export declare const ScrollArea: ({ children, height, backgroundColor, mobileDirection, }: {
+export declare const ScrollArea: ({ children, height, backgroundColor, mobileDirection, fill, }: {
     children: React.ReactNode;
     height?: number;
     backgroundColor?: string;
     mobileDirection?: "horizontal" | "vertical";
+    /** Grow to fill a flex parent and scroll internally, instead of capping at a
+     * fixed pixel height. Use inside a bounded flex column to keep siblings (e.g.
+     * a footer) pinned while only this region scrolls. */
+    fill?: boolean;
 }) => import("react/jsx-runtime").JSX.Element;

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

@@ -4,7 +4,7 @@ import useIsMobile from '../../../hooks/useIsMobile.js';
 import { ScrollContainer, ScrollAreaContainer, MoreIndicator } from './styles.js';
 
 const ArrowDown = () => (jsxs("svg", { width: "11", height: "12", viewBox: "0 0 11 12", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: [jsx("title", { children: "Scroll down arrow" }), jsx("path", { d: "M5.49438 1L5.49438 11M5.49438 11L9.5 7M5.49438 11L1.5 7", stroke: "currentColor", strokeWidth: "1.75", strokeLinecap: "round", strokeLinejoin: "round" })] }));
-const ScrollArea = ({ children, height, backgroundColor, mobileDirection, }) => {
+const ScrollArea = ({ children, height, backgroundColor, mobileDirection, fill, }) => {
     const ref = useRef(null);
     const moreRef = useRef(null);
     const isMobile = useIsMobile();
@@ -44,7 +44,7 @@ const ScrollArea = ({ children, height, backgroundColor, mobileDirection, }) =>
             el.removeEventListener('scroll', handleScroll);
         };
     }, [ref.current]);
-    return (jsxs(ScrollContainer, { children: [jsx(ScrollAreaContainer, { ref: ref, "$mobile": isMobile, "$height": height, "$backgroundColor": backgroundColor, "$mobileDirection": mobileDirection, children: children }), jsx(MoreIndicator, { ref: moreRef, className: "hide", onClick: () => {
+    return (jsxs(ScrollContainer, { "$fill": fill, children: [jsx(ScrollAreaContainer, { ref: ref, "$mobile": isMobile, "$height": height, "$backgroundColor": backgroundColor, "$mobileDirection": mobileDirection, "$fill": fill, children: children }), jsx(MoreIndicator, { ref: moreRef, className: "hide", onClick: () => {
                     if (ref.current) {
                         ref.current.scrollTo({
                             top: ref.current.scrollHeight,

package/build/components/Common/ScrollArea/styles.d.ts

@@ -1,8 +1,11 @@
-export declare const ScrollContainer: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const ScrollContainer: import("styled-components").StyledComponent<"div", any, {
+    $fill?: boolean;
+}, never>;
 export declare const MoreIndicator: import("styled-components").StyledComponent<"div", any, {}, never>;
 export declare const ScrollAreaContainer: import("styled-components").StyledComponent<"div", any, {
     $mobile?: boolean;
     $height?: number;
     $backgroundColor?: string;
     $mobileDirection?: "horizontal" | "vertical";
+    $fill?: boolean;
 }, never>;

package/build/components/Common/ScrollArea/styles.js

@@ -1,8 +1,15 @@
-import { keyframes, css } from 'styled-components';
+import { css, keyframes } from 'styled-components';
 import styled from '../../../styles/styled/index.js';
 
 const ScrollContainer = styled.div `
   position: relative;
+  ${({ $fill }) => $fill &&
+    css `
+      display: flex;
+      flex-direction: column;
+      flex: 1 1 auto;
+      min-height: 0;
+    `}
 `;
 const fadeIn = keyframes `
 0%{ opacity:0; }
@@ -60,7 +67,7 @@ const ScrollAreaContainer = styled.div `
   position: relative;
   z-index: 1;
 
-  ${({ $mobile, $height, $mobileDirection }) => $mobile && $mobileDirection === 'horizontal'
+  ${({ $mobile, $height, $mobileDirection, $fill }) => $mobile && $mobileDirection === 'horizontal'
     ? css `
           overflow-x: scroll;
           margin: 0 -24px;
@@ -103,8 +110,16 @@ const ScrollAreaContainer = styled.div `
           }
         `
     : css `
-          max-height: ${$height ? `${$height}px` : '310px'};
-          overflow-y: scroll;
+          ${$fill
+        ? css `
+                flex: 1 1 auto;
+                min-height: 0;
+                overflow-y: scroll;
+              `
+        : css `
+                max-height: ${$height ? `${$height}px` : '310px'};
+                overflow-y: scroll;
+              `}
           padding: 0 10px;
           margin: calc(var(--fade-height) * -1) -16px 0 -10px;
 

package/build/components/Common/ScrollArea/styles.js.map

@@ -1 +1 @@
-{"version":3,"file":"styles.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"styles.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, {}),
@@ -147,17 +149,27 @@ const ConnectModal = ({ mode = 'auto', theme = 'auto', customTheme = customTheme
     const isConnected = (_a = strategy === null || strategy === void 0 ? void 0 : strategy.isConnected(state)) !== null && _a !== void 0 ? _a : false;
     const chainId = strategy === null || strategy === void 0 ? void 0 : strategy.getChainId();
     const chainIsSupported = chainId != null && context.chains.some((c) => c.id === chainId);
-    // Auto-close when the user goes from not-connected → connected while the modal is open.
-    // Using a ref to track the previous value so we only react to the false → true transition,
-    // not when the modal is opened while already connected (e.g. user opens profile).
+    // Auto-close only when the connect/auth flow completes: the modal was opened while
+    // disconnected and then became connected. We latch the "opened-while-connected" state
+    // on each open transition, so a chain switch — which briefly drops and restores the
+    // connection while the modal is already open and connected — never triggers a close.
+    const prevOpenRef = useRef(context.open);
+    const openedConnectedRef = useRef(isConnected);
     const prevIsConnectedRef = useRef(isConnected);
     useEffect(() => {
+        const justOpened = context.open && !prevOpenRef.current;
+        prevOpenRef.current = context.open;
+        if (justOpened) {
+            openedConnectedRef.current = isConnected;
+            prevIsConnectedRef.current = isConnected;
+            return;
+        }
         const wasConnected = prevIsConnectedRef.current;
         prevIsConnectedRef.current = isConnected;
-        if (!wasConnected && isConnected && context.open) {
+        if (!openedConnectedRef.current && !wasConnected && isConnected && context.open) {
             context.setOpen(false);
         }
-    }, [isConnected]);
+    }, [isConnected, context.open]);
     //if chain is unsupported we enforce a "switch chain" prompt
     const closeable = !(context.uiConfig.enforceSupportedChains && isConnected && !chainIsSupported);
     const route = context.route.route;

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/PageContent/index.d.ts

@@ -6,6 +6,7 @@ type PageContentProps = {
     onBack?: SetOnBackFunction;
     logoutOnBack?: boolean;
     header?: string;
+    className?: string;
 };
-export declare const PageContent: ({ children, width, onBack, logoutOnBack, header }: PageContentProps) => import("react/jsx-runtime").JSX.Element;
+export declare const PageContent: ({ children, width, onBack, logoutOnBack, header, className, }: PageContentProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/build/components/PageContent/index.js

@@ -5,7 +5,7 @@ import { ModalHeading } from '../Common/Modal/styles.js';
 import { useOpenfort } from '../Openfort/useOpenfort.js';
 import { PageContentStyle } from './styles.js';
 
-const PageContent = ({ children, width, onBack = 'back', logoutOnBack, header }) => {
+const PageContent = ({ children, width, onBack = 'back', logoutOnBack, header, className, }) => {
     const { setOnBack, setRoute, setPreviousRoute, setRouteHistory } = useOpenfort();
     const { signOut } = useSignOut();
     useEffect(() => {
@@ -48,7 +48,7 @@ const PageContent = ({ children, width, onBack = 'back', logoutOnBack, header })
         else
             setOnBack(null);
     }, [!!onBack, !!logoutOnBack]);
-    return (jsxs(PageContentStyle, { style: { width }, children: [header && jsx(ModalHeading, { children: header }), children] }));
+    return (jsxs(PageContentStyle, { className: className, style: { width }, children: [header && jsx(ModalHeading, { children: header }), children] }));
 };
 
 export { PageContent };

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