@openfort/react 1.1.4 → 1.3.0

package/build/components/Pages/DepositWallet/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Transfer from wallet. Pick a source chain/token and an amount, then choose the
+ * wallet to send from. On mobile that's open-dApp deeplinks into the wallet app's
+ * in-app browser (address/chain/token/amount prefilled); on desktop it's a direct
+ * send from a browser-extension wallet. The manual deposit-address / QR path stays
+ * available below.
+ */
+declare const DepositWallet: () => import("react/jsx-runtime").JSX.Element;
+export default DepositWallet;

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

@@ -0,0 +1,107 @@
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { useState, useEffect } from 'react';
+import { parseUnits } from 'viem';
+import Logos from '../../../assets/logos.js';
+import useIsMobile from '../../../hooks/useIsMobile.js';
+import { isIOS } from '../../../utils/index.js';
+import { ModalHeading, ModalBody } from '../../Common/Modal/styles.js';
+import { routes } from '../../Openfort/types.js';
+import { useOpenfort } from '../../Openfort/useOpenfort.js';
+import { PageContent } from '../../PageContent/index.js';
+import { Section, SectionLabel, AmountCard, CurrencySymbol, AmountInput, PresetList, PresetButton } from '../Buy/styles.js';
+import { AddressPageLink } from '../Deposit/AddressPageLink.js';
+import { isDepositFlowActive, DepositProgress } from '../Deposit/DepositProgress.js';
+import { walletListBtn } from '../Deposit/formStyles.js';
+import { RouteSelectors } from '../Deposit/RouteSelectors.js';
+import { isSolana } from '../Deposit/sources.js';
+import { StepDivider, Skeleton, ButtonLogo } from '../Deposit/styles.js';
+import { useDepositRoute } from '../Deposit/useDepositRoute.js';
+import { sanitizeAmountInput } from '../Send/utils.js';
+import { DepositWalletDesktop } from './DepositWalletDesktop.js';
+import { OPENFORT_DEPOSIT_PAGE_URL, caipToChainId, buildDepositPageUrl, buildOpenDappLinks } from './walletDeeplinks.js';
+
+/** Wallet-app brand logos keyed by the deeplink `app` id. */
+const WALLET_LOGO = {
+    metamask: jsx(Logos.MetaMask, { background: true }),
+    coinbase: jsx(Logos.Coinbase, { background: true }),
+    phantom: jsx(Logos.Phantom, { background: true }),
+    trust: jsx(Logos.Trust, {}),
+    rainbow: jsx(Logos.Rainbow, { round: true }),
+    rabby: jsx(Logos.Rabby, {}),
+};
+/** Preset deposit amounts, in the selected source token's units. */
+const PRESETS = [10, 25, 50];
+/**
+ * Transfer from wallet. Pick a source chain/token and an amount, then choose the
+ * wallet to send from. On mobile that's open-dApp deeplinks into the wallet app's
+ * in-app browser (address/chain/token/amount prefilled); on desktop it's a direct
+ * send from a browser-extension wallet. The manual deposit-address / QR path stays
+ * available below.
+ */
+const DepositWallet = () => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    const { triggerResize, uiConfig } = useOpenfort();
+    const isMobile = useIsMobile();
+    const route = useDepositRoute('crypto');
+    const [amount, setAmount] = useState('');
+    const [pressedPreset, setPressedPreset] = useState(null);
+    const depositPageUrl = (_b = (_a = uiConfig.funding) === null || _a === void 0 ? void 0 : _a.depositPageUrl) !== null && _b !== void 0 ? _b : OPENFORT_DEPOSIT_PAGE_URL;
+    // Solana sources have no numeric chain id and no desktop EVM-extension send, so
+    // they route through the deeplink (Phantom) on every platform instead of the
+    // wagmi-bridge desktop path.
+    const isSolanaSrc = isSolana((_d = (_c = route.activeChain) === null || _c === void 0 ? void 0 : _c.id) !== null && _d !== void 0 ? _d : '');
+    const srcChainId = caipToChainId((_e = route.activeChain) === null || _e === void 0 ? void 0 : _e.id);
+    const amountValid = Number.parseFloat(amount) > 0;
+    const handleAmountChange = (event) => {
+        const raw = sanitizeAmountInput(event.target.value);
+        if (raw === '' || /^[0-9]*\.?[0-9]*$/.test(raw)) {
+            setPressedPreset(null);
+            setAmount(raw);
+        }
+    };
+    const handlePreset = (value) => {
+        setPressedPreset(value);
+        setAmount(String(value));
+    };
+    // Open-dApp deeplinks: prefer backend-provided ones; otherwise build them from
+    // the hosted deposit page URL (if the integrator configured one) carrying the
+    // resolved transfer params. The hosted page sends via the wallet's injected
+    // provider, so no backend wiring is required for the link itself.
+    const pageUrl = depositPageUrl && route.receiverAddress && route.activeCurrency && (isSolanaSrc || srcChainId)
+        ? buildDepositPageUrl(depositPageUrl, {
+            vm: isSolanaSrc ? 'svm' : 'evm',
+            to: route.receiverAddress,
+            chainId: isSolanaSrc ? undefined : srcChainId,
+            token: route.activeCurrency.native ? undefined : route.activeCurrency.address,
+            decimals: route.activeCurrency.decimals,
+            symbol: route.activeCurrency.symbol,
+            chain: (_f = route.activeChain) === null || _f === void 0 ? void 0 : _f.name,
+            amount: amountValid ? parseUnits(amount, route.activeCurrency.decimals).toString() : undefined,
+        })
+        : null;
+    const allDeeplinks = ((_h = (_g = route.pm) === null || _g === void 0 ? void 0 : _g.deeplinks) === null || _h === void 0 ? void 0 : _h.length)
+        ? route.pm.deeplinks
+        : pageUrl
+            ? buildOpenDappLinks(pageUrl, (_k = (_j = route.activeChain) === null || _j === void 0 ? void 0 : _j.vmType) !== null && _k !== void 0 ? _k : 'evm')
+            : [];
+    // Trust's in-app dApp browser was removed on iOS (Apple, 2021) — the link
+    // dead-ends there, so hide it on iOS while keeping it on Android.
+    const deeplinks = isIOS() ? allDeeplinks.filter((d) => d.app !== 'trust') : allDeeplinks;
+    useEffect(() => {
+        triggerResize();
+    }, [route.receiverAddress, route.loading, route.status, deeplinks.length, triggerResize]);
+    if (isDepositFlowActive(route.status))
+        return jsx(DepositProgress, { status: route.status });
+    return (jsxs(PageContent, { onBack: routes.DEPOSIT, children: [jsx(ModalHeading, { children: "Transfer from wallet" }), jsx(RouteSelectors, { chains: route.chains, chain: route.chain, currency: route.currency, chainLabel: "Supported chain", onChainChange: route.setChain, onCurrencyChange: route.setCurrency }), !route.isAvailable && jsx(ModalBody, { children: "Funding isn't available right now." }), jsxs(Section, { children: [jsx(SectionLabel, { children: "Amount" }), jsxs(AmountCard, { children: [jsx(CurrencySymbol, { children: (_m = (_l = route.activeCurrency) === null || _l === void 0 ? void 0 : _l.symbol) !== null && _m !== void 0 ? _m : '' }), jsx(AmountInput, { value: amount, onChange: handleAmountChange, placeholder: "0.00", inputMode: "decimal", autoComplete: "off" })] }), jsx(PresetList, { children: PRESETS.map((preset) => (jsx(PresetButton, { type: "button", "$active": pressedPreset === preset, onClick: () => handlePreset(preset), children: preset }, preset))) })] }), jsx(StepDivider, { children: "Then select the wallet you want to use" }), isMobile || isSolanaSrc ? (jsxs(Fragment, { children: [!depositPageUrl && (jsx(ModalBody, { style: { marginTop: 12 }, children: "Use a deposit address below to fund from your wallet." })), route.loading && !route.pm && (jsxs("div", { style: { display: 'flex', flexDirection: 'column', gap: 8, marginTop: 14 }, children: [jsx(Skeleton, { "$h": "44px", "$r": "10px" }), jsx(Skeleton, { "$h": "44px", "$r": "10px" }), jsx(Skeleton, { "$h": "44px", "$r": "10px" })] })), deeplinks.length > 0 && (jsx("div", { style: { display: 'flex', flexDirection: 'column', gap: 8, marginTop: 14 }, children: deeplinks.map((d) => (jsxs("a", { href: amountValid ? d.url : undefined, "aria-disabled": !amountValid, target: "_blank", rel: "noreferrer", style: {
+                                ...walletListBtn,
+                                display: 'flex',
+                                alignItems: 'center',
+                                justifyContent: 'center',
+                                gap: 8,
+                                opacity: amountValid ? 1 : 0.55,
+                                pointerEvents: amountValid ? 'auto' : 'none',
+                            }, children: [WALLET_LOGO[d.app] && jsx(ButtonLogo, { children: WALLET_LOGO[d.app] }), d.label, " \u2197"] }, d.app))) }))] })) : (jsx(DepositWalletDesktop, { receiverAddress: route.receiverAddress, activeChain: route.activeChain, activeCurrency: route.activeCurrency, loading: route.loading, amount: amount })), jsx(AddressPageLink, { label: "Or send to a deposit address" }), route.error && jsx(ModalBody, { style: { color: '#dc2626', marginTop: 12 }, children: route.error.message })] }));
+};
+
+export { DepositWallet as default };
+//# sourceMappingURL=index.js.map

package/build/components/Pages/DepositWallet/index.js.map

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

package/build/components/Pages/DepositWallet/walletDeeplinks.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Mobile "open-dApp" wallet deeplinks (the Daimo pattern).
+ *
+ * Each wallet exposes a universal link that opens an arbitrary https URL inside
+ * its own in-app dApp browser. We point every one at the standalone deposit
+ * "send" page ({@link buildDepositPageUrl}) carrying the deposit address, chain,
+ * token and amount as query params. The user taps their wallet, the page opens
+ * with `window.ethereum` injected, and confirms the transfer there.
+ *
+ * The page URL is configured by the integrator via `uiConfig.funding.depositPageUrl`
+ * (the deployed `deposit.html`). Without it, no deeplinks are produced.
+ */
+type WalletDeeplink = {
+    app: string;
+    label: string;
+    url: string;
+};
+export type VmType = 'evm' | 'svm';
+/**
+ * Default hosted deposit "send" page (Openfort-operated). Used when the
+ * integrator doesn't set `uiConfig.funding.depositPageUrl`, so one-tap mobile
+ * wallet deeplinks work out of the box.
+ */
+export declare const OPENFORT_DEPOSIT_PAGE_URL = "https://deposit.openfort.io";
+type DepositPageParams = {
+    /** Source VM family. `evm` drives a window.ethereum send; `svm` a Solana Pay request. */
+    vm: VmType;
+    /** Relay deposit address the source funds go to (0x for EVM, base58 for Solana). */
+    to: string;
+    /** Numeric source chain id (e.g. 42161). EVM only. */
+    chainId?: number;
+    /** ERC-20 contract / SPL mint, or empty/undefined for the chain's native token. */
+    token?: string;
+    decimals: number;
+    symbol: string;
+    /** Human-readable chain name shown on the page. */
+    chain?: string;
+    /** Optional preset amount in base units (uint256 string). */
+    amount?: string;
+};
+/** Build the deposit "send" page URL with the transfer params encoded. */
+export declare function buildDepositPageUrl(baseUrl: string, p: DepositPageParams): string;
+/** "eip155:8453" -> 8453 (undefined if not a numeric CAIP-2 reference). */
+export declare function caipToChainId(caip2?: string): number | undefined;
+/**
+ * Open-dApp deeplinks for every wallet matching `vmType`, each wrapping the
+ * deposit send page so it loads in that wallet's in-app browser.
+ */
+export declare function buildOpenDappLinks(pageUrl: string, vmType: VmType): WalletDeeplink[];
+export {};

package/build/components/Pages/DepositWallet/walletDeeplinks.js

@@ -0,0 +1,109 @@
+/**
+ * Mobile "open-dApp" wallet deeplinks (the Daimo pattern).
+ *
+ * Each wallet exposes a universal link that opens an arbitrary https URL inside
+ * its own in-app dApp browser. We point every one at the standalone deposit
+ * "send" page ({@link buildDepositPageUrl}) carrying the deposit address, chain,
+ * token and amount as query params. The user taps their wallet, the page opens
+ * with `window.ethereum` injected, and confirms the transfer there.
+ *
+ * The page URL is configured by the integrator via `uiConfig.funding.depositPageUrl`
+ * (the deployed `deposit.html`). Without it, no deeplinks are produced.
+ */
+/**
+ * Default hosted deposit "send" page (Openfort-operated). Used when the
+ * integrator doesn't set `uiConfig.funding.depositPageUrl`, so one-tap mobile
+ * wallet deeplinks work out of the box.
+ */
+const OPENFORT_DEPOSIT_PAGE_URL = 'https://deposit.openfort.io';
+/** Build the deposit "send" page URL with the transfer params encoded. */
+function buildDepositPageUrl(baseUrl, p) {
+    const url = new URL(baseUrl);
+    url.searchParams.set('vm', p.vm);
+    url.searchParams.set('to', p.to);
+    if (p.vm === 'evm' && p.chainId !== undefined)
+        url.searchParams.set('chainId', String(p.chainId));
+    if (p.token)
+        url.searchParams.set('token', p.token);
+    url.searchParams.set('decimals', String(p.decimals));
+    url.searchParams.set('symbol', p.symbol);
+    if (p.chain)
+        url.searchParams.set('chain', p.chain);
+    if (p.amount)
+        url.searchParams.set('amount', p.amount);
+    return url.toString();
+}
+/** "eip155:8453" -> 8453 (undefined if not a numeric CAIP-2 reference). */
+function caipToChainId(caip2) {
+    if (!caip2)
+        return undefined;
+    const n = Number(caip2.split(':')[1]);
+    return Number.isFinite(n) ? n : undefined;
+}
+const stripScheme = (u) => u.replace(/^https?:\/\//, '');
+const enc = encodeURIComponent;
+const originOf = (u) => {
+    try {
+        return new URL(u).origin;
+    }
+    catch {
+        return '';
+    }
+};
+// Open-dApp universal links. Each format verified (2026) against the wallet's
+// docs/source plus a second independent source. `pageUrl` is the deposit send
+// page; most want it URL-encoded, MetaMask wants the https:// scheme stripped.
+const WALLETS = [
+    {
+        app: 'metamask',
+        label: 'Open MetaMask',
+        vms: ['evm'],
+        build: (u) => `https://link.metamask.io/dapp/${stripScheme(u)}`,
+    },
+    {
+        app: 'coinbase',
+        label: 'Open Coinbase Wallet',
+        vms: ['evm'],
+        build: (u) => `https://go.cb-w.com/dapp?cb_url=${enc(u)}`,
+    },
+    {
+        app: 'trust',
+        label: 'Open Trust Wallet',
+        vms: ['evm'],
+        // coin_id=60 = Ethereum (SLIP-44). In-app dApp browser is Android-only;
+        // iOS shows "Deep Link not Supported" (Apple removed it in 2021).
+        build: (u) => `https://link.trustwallet.com/open_url?coin_id=60&url=${enc(u)}`,
+    },
+    {
+        app: 'rainbow',
+        label: 'Open Rainbow',
+        vms: ['evm'],
+        build: (u) => `https://rainbow.me/dapp?url=${enc(u)}`,
+    },
+    {
+        app: 'rabby',
+        label: 'Open Rabby',
+        vms: ['evm'],
+        build: (u) => `https://go.rabby.io/mobile/?_cmd=open-dapp&dapp=${enc(u)}`,
+    },
+    {
+        app: 'phantom',
+        label: 'Open Phantom',
+        vms: ['evm', 'svm'],
+        build: (u) => `https://phantom.app/ul/browse/${enc(u)}?ref=${enc(originOf(u))}`,
+    },
+];
+/**
+ * Open-dApp deeplinks for every wallet matching `vmType`, each wrapping the
+ * deposit send page so it loads in that wallet's in-app browser.
+ */
+function buildOpenDappLinks(pageUrl, vmType) {
+    return WALLETS.filter((w) => w.vms.includes(vmType)).map((w) => ({
+        app: w.app,
+        label: w.label,
+        url: w.build(pageUrl),
+    }));
+}
+
+export { OPENFORT_DEPOSIT_PAGE_URL, buildDepositPageUrl, buildOpenDappLinks, caipToChainId };
+//# sourceMappingURL=walletDeeplinks.js.map

package/build/components/Pages/DepositWallet/walletDeeplinks.js.map

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

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

@@ -10,7 +10,15 @@ import { PageContent } from '../../PageContent/index.js';
 
 // TODO: Localize
 const ExportKey = () => {
-    const { exportPrivateKey } = useEthereumEmbeddedWallet();
+    var _a, _b;
+    const wallet = useEthereumEmbeddedWallet();
+    const { exportPrivateKey } = wallet;
+    // A smart account is a contract (no private key); the exportable key is its
+    // owner/signer EOA — a different address that won't show the account's funds
+    // when imported into another wallet.
+    const accountAddress = (_a = wallet.activeWallet) === null || _a === void 0 ? void 0 : _a.address;
+    const ownerAddress = (_b = wallet.activeWallet) === null || _b === void 0 ? void 0 : _b.ownerAddress;
+    const isSmartAccount = Boolean(ownerAddress && accountAddress && ownerAddress.toLowerCase() !== accountAddress.toLowerCase());
     const [exportedKey, setExportedKey] = useState(null);
     const [exportError, setExportError] = useState(null);
     const [showExportedKey, setShowExportedKey] = useState(false);
@@ -37,7 +45,7 @@ const ExportKey = () => {
                     logo: jsx(KeyIcon, {}),
                 }, logoBottomLeft: {
                     logo: jsx(KeyIcon, {}),
-                } }), jsxs(ModalContent, { children: [jsxs(ModalBody, { children: [jsx("p", { style: { marginBottom: 6 }, children: "With your private key, you can access your account outside this application." }), jsx("p", { children: "Keep it safe and never share it with anyone you don't trust." })] }), !showExportedKey ? (jsx(Button, { onClick: () => setShowExportedKey(true), style: { marginTop: 12 }, children: "Export key" })) : exportError ? (jsx(ModalBody, { style: { marginTop: 12 }, "$error": true, children: exportError })) : exportedKey ? (jsx("div", { style: { marginTop: 12 }, children: jsxs(CopyText, { value: exportedKey, children: [exportedKey.slice(0, 10), "...", exportedKey.slice(-10)] }) })) : (jsx(Fragment, { children: "Loading..." }))] })] }));
+                } }), jsxs(ModalContent, { children: [jsxs(ModalBody, { children: [isSmartAccount ? (jsxs("p", { style: { marginBottom: 6 }, children: ["This is your account's ", jsx("strong", { children: "owner (signer) key" }), " \u2014 not the account itself. Your smart account", accountAddress ? ` (${accountAddress.slice(0, 6)}…${accountAddress.slice(-4)})` : '', " is a contract with no private key, so importing this key into another wallet shows the owner address,", ' ', jsx("strong", { children: "not your funds" }), ". To move funds, use Send to withdraw to another wallet."] })) : (jsx("p", { style: { marginBottom: 6 }, children: "With your private key, you can access your account outside this application." })), jsx("p", { children: "Keep it safe and never share it with anyone you don't trust." })] }), !showExportedKey ? (jsx(Button, { onClick: () => setShowExportedKey(true), style: { marginTop: 12 }, children: "Export key" })) : exportError ? (jsx(ModalBody, { style: { marginTop: 12 }, "$error": true, children: exportError })) : exportedKey ? (jsx("div", { style: { marginTop: 12 }, children: jsxs(CopyText, { value: exportedKey, children: [exportedKey.slice(0, 10), "...", exportedKey.slice(-10)] }) })) : (jsx(Fragment, { children: "Loading..." }))] })] }));
 };
 
 export { ExportKey as default };

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

@@ -1,9 +1,5 @@
 import { jsxs, jsx } from 'react/jsx-runtime';
-import { ChainTypeEnum } from '@openfort/openfort-js';
-import { BuyIcon, DollarIcon, ReceiveIcon } from '../../../assets/icons.js';
-import { useEthereumEmbeddedWallet } from '../../../ethereum/hooks/useEthereumEmbeddedWallet.js';
-import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
-import { useSolanaEmbeddedWallet } from '../../../solana/hooks/useSolanaEmbeddedWallet.js';
+import { BuyIcon, DollarIcon } from '../../../assets/icons.js';
 import Button from '../../Common/Button/index.js';
 import { ModalContent, ModalH1, ModalBody } from '../../Common/Modal/styles.js';
 import { FloatingGraphic } from '../../FloatingGraphic/index.js';
@@ -13,17 +9,7 @@ import { PageContent } from '../../PageContent/index.js';
 import { ButtonsContainer } from './styles.js';
 
 const NoAssetsAvailable = () => {
-    const { setRoute, chains } = useOpenfort();
-    const { chainType } = useOpenfortCore();
-    // Use chain-specific hooks
-    const ethereumWallet = useEthereumEmbeddedWallet();
-    const solanaWallet = useSolanaEmbeddedWallet();
-    const wallet = chainType === ChainTypeEnum.EVM ? ethereumWallet : solanaWallet;
-    const chainId = wallet.status === 'connected' && chainType === ChainTypeEnum.EVM
-        ? wallet.chainId
-        : undefined;
-    const chain = chains.find((c) => c.id === chainId);
-    const showBuyOption = chain && !chain.testnet;
+    const { setRoute } = useOpenfort();
     return (jsxs(PageContent, { children: [jsx(FloatingGraphic, { height: "190px", logoCenter: {
                     logo: jsx(BuyIcon, {}),
                 }, logoTopLeft: {
@@ -34,11 +20,9 @@ const NoAssetsAvailable = () => {
                     logo: jsx(DollarIcon, {}),
                 }, logoBottomLeft: {
                     logo: jsx(DollarIcon, {}),
-                } }), jsxs(ModalContent, { style: { paddingBottom: 0 }, children: [jsx(ModalH1, { "$small": true, children: "No assets available" }), jsxs(ModalBody, { children: [jsx("div", { style: { paddingRight: 12, paddingLeft: 12 }, children: "You currently have no assets available in your wallet." }), jsxs(ButtonsContainer, { children: [jsx(Button, { onClick: () => {
-                                            setRoute(routes.RECEIVE);
-                                        }, icon: jsx(ReceiveIcon, {}), children: "Get assets" }), showBuyOption && (jsx(Button, { onClick: () => {
-                                            setRoute(routes.BUY);
-                                        }, icon: jsx(BuyIcon, {}), children: "Buy assets" }))] })] })] })] }));
+                } }), jsxs(ModalContent, { style: { paddingBottom: 0 }, children: [jsx(ModalH1, { "$small": true, children: "No assets available" }), jsxs(ModalBody, { children: [jsx("div", { style: { paddingRight: 12, paddingLeft: 12 }, children: "You currently have no assets available in your wallet." }), jsx(ButtonsContainer, { children: jsx(Button, { onClick: () => {
+                                        setRoute(routes.DEPOSIT);
+                                    }, icon: jsx(DollarIcon, {}), children: "Add funds" }) })] })] })] }));
 };
 
 export { NoAssetsAvailable };

package/build/components/Pages/NoAssetsAvailable/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/SelectToken/SolanaSelectToken.d.ts

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

package/build/components/Pages/SelectToken/SolanaSelectToken.js

@@ -0,0 +1,50 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { useEffect, useState } from 'react';
+import { formatUnits } from 'viem';
+import { TOKEN_LOGO, symbolToColor } from '../../../constants/logos.js';
+import { useSolanaWalletAssets } from '../../../solana/hooks/useSolanaWalletAssets.js';
+import { ModalHeading } from '../../Common/Modal/styles.js';
+import { routes } from '../../Openfort/types.js';
+import { useOpenfort } from '../../Openfort/useOpenfort.js';
+import { SelectTokenContent, EmptyState, TokenList, TokenButton, TokenLeftGroup, TokenInfo, TokenSymbol, TokenName, TokenBalance, TokenLogoArea, TokenLogoImg, TokenLogoFallback } from './styles.js';
+
+const ZERO = BigInt(0);
+function SolanaTokenLogo({ symbol }) {
+    var _a;
+    const [imgError, setImgError] = useState(false);
+    const url = (_a = TOKEN_LOGO[symbol.toUpperCase()]) !== null && _a !== void 0 ? _a : null;
+    return (jsx(TokenLogoArea, { children: url && !imgError ? (jsx(TokenLogoImg, { src: url, alt: symbol, onError: () => setImgError(true) })) : (jsx(TokenLogoFallback, { "$bg": symbolToColor(symbol), children: symbol.charAt(0).toUpperCase() })) }));
+}
+const SolanaSelectToken = () => {
+    const { setSendForm, setRoute, triggerResize } = useOpenfort();
+    const { data, isLoading } = useSolanaWalletAssets();
+    const tokens = (data !== null && data !== void 0 ? data : []).filter((t) => t.amount > ZERO);
+    useEffect(() => {
+        if (!isLoading)
+            triggerResize();
+    }, [isLoading, triggerResize]);
+    const handleSelect = (token) => {
+        const asset = token.isNative
+            ? {
+                type: 'native',
+                balance: token.amount,
+                metadata: { symbol: 'SOL', decimals: token.decimals, fiat: { value: 0, currency: 'USD' } },
+            }
+            : {
+                type: 'spl',
+                address: token.mint,
+                balance: token.amount,
+                metadata: { symbol: token.symbol, name: token.name, decimals: token.decimals },
+            };
+        setSendForm((prev) => ({ ...prev, asset, amount: '' }));
+        setRoute(routes.SOL_SEND);
+    };
+    return (jsxs(SelectTokenContent, { onBack: routes.SOL_SEND, children: [jsx(ModalHeading, { children: "Select asset" }), tokens.length === 0 ? (jsx(EmptyState, { children: isLoading ? 'Loading balances…' : 'No assets found' })) : (jsx(TokenList, { children: tokens.map((token) => {
+                    const amount = Number(formatUnits(token.amount, token.decimals));
+                    const balanceStr = `${amount.toLocaleString('en-US', { maximumFractionDigits: 4 })} ${token.symbol}`;
+                    return (jsxs(TokenButton, { type: "button", onClick: () => handleSelect(token), children: [jsxs(TokenLeftGroup, { children: [jsx(SolanaTokenLogo, { symbol: token.symbol }), jsxs(TokenInfo, { style: { textAlign: 'left' }, children: [jsx(TokenSymbol, { children: token.name }), jsx(TokenName, { children: token.symbol })] })] }), jsx(TokenBalance, { children: balanceStr })] }, token.mint));
+                }) }))] }));
+};
+
+export { SolanaSelectToken };
+//# sourceMappingURL=SolanaSelectToken.js.map

package/build/components/Pages/SelectToken/SolanaSelectToken.js.map

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

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

@@ -1,11 +1,15 @@
 import { jsxs, jsx } from 'react/jsx-runtime';
+import { ChainTypeEnum } from '@openfort/openfort-js';
 import { useState, useEffect } from 'react';
 import { formatUnits } from 'viem';
 import { useEthereumWalletAssets } from '../../../ethereum/hooks/useEthereumWalletAssets.js';
+import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
 import { Arrow, ArrowChevron, TextLinkButton } from '../../Common/Button/styles.js';
 import { ModalHeading } from '../../Common/Modal/styles.js';
 import { routes } from '../../Openfort/types.js';
 import { useOpenfort } from '../../Openfort/useOpenfort.js';
+import { EVM_BUY_CURRENCIES } from '../Buy/evmCurrencies.js';
+import { SOLANA_BUY_CURRENCIES } from '../Buy/solanaCurrencies.js';
 import { getAssetSymbol, getAssetDecimals, formatBalanceWithSymbol } from '../Send/utils.js';
 import { SelectTokenContent, EmptyState, TokenList, TokenButton, TokenInfo, TokenSymbol, TokenName, TokenBalance } from './styles.js';
 
@@ -22,9 +26,16 @@ const SelectToken = ({ isBuyFlow }) => {
     useEffect(() => {
         triggerResize();
     }, [viewAllAssets]);
+    const { chainType } = useOpenfortCore();
     const { data: walletAssets, isLoading: isBalancesLoading } = useEthereumWalletAssets();
-    // Show all tokens for both buy and send flows
-    const selectableTokens = walletAssets || [];
+    // Buys pick from a fixed buyable-currency list (USDC first, then native) per
+    // chain family, so the picker always has options even for a fresh wallet with no
+    // indexed balances. The send flow reads the EVM wallet's actual assets.
+    const selectableTokens = isBuyFlow
+        ? chainType === ChainTypeEnum.SVM
+            ? SOLANA_BUY_CURRENCIES
+            : EVM_BUY_CURRENCIES
+        : walletAssets || [];
     const handleSelect = (asset) => {
         var _a;
         // In send flow, don't allow selecting tokens with 0 balance

package/build/components/Pages/SelectToken/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/SelectToken/styles.js

@@ -2,7 +2,7 @@ import styled from '../../../styles/styled/index.js';
 import { PageContent } from '../../PageContent/index.js';
 
 const SelectTokenContent = styled(PageContent) `
-  min-height: 320px;
+  min-height: 400px;
   display: flex;
   flex-direction: column;
   padding-bottom: 16px;

package/build/components/Pages/Send/SolanaSend.d.ts

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

package/build/components/Pages/Send/SolanaSend.js

@@ -0,0 +1,89 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { useMemo } from 'react';
+import { parseUnits, formatUnits } from 'viem';
+import { useSolanaWalletAssets } from '../../../solana/hooks/useSolanaWalletAssets.js';
+import Button from '../../Common/Button/index.js';
+import { Arrow, ArrowChevron } from '../../Common/Button/styles.js';
+import Input from '../../Common/Input/index.js';
+import { ModalHeading } from '../../Common/Modal/styles.js';
+import { routes } from '../../Openfort/types.js';
+import { useOpenfort } from '../../Openfort/useOpenfort.js';
+import { PageContent } from '../../PageContent/index.js';
+import { Form, Field, FieldLabel, TokenSelectorButton, TokenSelectorContent, TokenSelectorValue, TokenSelectorRight, AmountInputWrapper, MaxButton, HelperText, ErrorText } from './styles.js';
+import { sanitizeForParsing, formatBalance, sanitizeAmountInput } from './utils.js';
+
+const SOL_DECIMALS = 9;
+/** Cheap base58 shape check for the form; the RPC validates the real address on send. */
+function isLikelySolanaAddress(value) {
+    return /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(value);
+}
+/** A native SOL asset with the canonical metadata (the default form asset has none). */
+function solAsset(balance) {
+    return {
+        type: 'native',
+        balance,
+        metadata: { symbol: 'SOL', decimals: SOL_DECIMALS, fiat: { value: 0, currency: 'USD' } },
+    };
+}
+const SolanaSend = () => {
+    const { sendForm, setSendForm, setRoute } = useOpenfort();
+    const { data: assets } = useSolanaWalletAssets();
+    const asset = sendForm.asset;
+    const selected = asset.type === 'spl'
+        ? { isSpl: true, mint: asset.address, decimals: asset.metadata.decimals, symbol: asset.metadata.symbol }
+        : { isSpl: false, mint: 'native', decimals: SOL_DECIMALS, symbol: 'SOL' };
+    // Live balance (base units) for the selected token, matched by mint.
+    const liveToken = assets === null || assets === void 0 ? void 0 : assets.find((t) => (selected.isSpl ? t.mint === selected.mint : t.isNative));
+    const balanceBase = liveToken === null || liveToken === void 0 ? void 0 : liveToken.amount;
+    const parsedAmount = useMemo(() => {
+        const raw = sanitizeForParsing(sendForm.amount);
+        if (!raw)
+            return null;
+        try {
+            return parseUnits(raw, selected.decimals);
+        }
+        catch {
+            return null;
+        }
+    }, [sendForm.amount, selected.decimals]);
+    const recipientValid = isLikelySolanaAddress(sendForm.recipient.trim());
+    const insufficientBalance = parsedAmount !== null && balanceBase !== undefined ? parsedAmount > balanceBase : false;
+    const amountValid = parsedAmount !== null && parsedAmount > BigInt(0) && !insufficientBalance;
+    const canProceed = recipientValid && amountValid;
+    const availableLabel = formatBalance(balanceBase, selected.decimals);
+    const handleSubmit = (event) => {
+        event.preventDefault();
+        if (!canProceed)
+            return;
+        const normalized = sanitizeForParsing(sendForm.amount);
+        if (!normalized)
+            return;
+        // Persist the selected token with its live balance so the confirmation reads it.
+        const nextAsset = asset.type === 'spl'
+            ? { type: 'spl', address: asset.address, balance: balanceBase !== null && balanceBase !== void 0 ? balanceBase : asset.balance, metadata: asset.metadata }
+            : solAsset(balanceBase !== null && balanceBase !== void 0 ? balanceBase : BigInt(0));
+        setSendForm((prev) => ({
+            ...prev,
+            recipient: prev.recipient.trim(),
+            amount: normalized,
+            asset: nextAsset,
+        }));
+        setRoute(routes.SOL_SEND_CONFIRMATION);
+    };
+    const handleAmountChange = (event) => {
+        const raw = sanitizeAmountInput(event.target.value);
+        if (raw === '' || /^[0-9]*\.?[0-9]*$/.test(raw)) {
+            setSendForm((prev) => ({ ...prev, amount: raw }));
+        }
+    };
+    const handleMax = () => {
+        if (balanceBase === undefined)
+            return;
+        setSendForm((prev) => ({ ...prev, amount: formatUnits(balanceBase, selected.decimals) }));
+    };
+    const handleOpenTokenSelector = () => setRoute(routes.SOL_SEND_TOKEN_SELECT);
+    return (jsxs(PageContent, { onBack: routes.SOL_CONNECTED, children: [jsx(ModalHeading, { children: "Send assets" }), jsxs(Form, { onSubmit: handleSubmit, children: [jsxs(Field, { children: [jsx(FieldLabel, { children: "Asset" }), jsxs(TokenSelectorButton, { type: "button", onClick: handleOpenTokenSelector, children: [jsx(TokenSelectorContent, { children: jsx(TokenSelectorValue, { "$primary": true, children: selected.symbol }) }), jsxs(TokenSelectorRight, { children: [jsx(TokenSelectorValue, { children: availableLabel === '--' ? '--' : `${availableLabel} ${selected.symbol}` }), 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" }) })] })] })] }), jsxs(Field, { children: [jsx(FieldLabel, { children: "Amount" }), jsxs(AmountInputWrapper, { children: [jsx(Input, { placeholder: "0.00", value: sendForm.amount, onChange: handleAmountChange, inputMode: "decimal", autoComplete: "off", style: { paddingRight: '86px' } }), jsx(MaxButton, { type: "button", onClick: handleMax, disabled: balanceBase === undefined, children: "Max" })] }), jsxs(HelperText, { children: ["Available: ", availableLabel, " ", selected.symbol] }), sendForm.amount && parsedAmount === null && jsx(ErrorText, { children: "Enter a valid amount." }), insufficientBalance && jsxs(ErrorText, { children: ["Insufficient ", selected.symbol, " balance for this transfer."] })] }), jsxs(Field, { children: [jsx(FieldLabel, { children: "Recipient address" }), jsx(Input, { placeholder: "Solana address", value: sendForm.recipient, onChange: (e) => setSendForm((prev) => ({ ...prev, recipient: e.target.value })), autoComplete: "off" }), sendForm.recipient && !recipientValid && jsx(ErrorText, { children: "Enter a valid Solana address." })] }), jsx(Button, { variant: "primary", disabled: !canProceed, children: "Review transfer" })] })] }));
+};
+
+export { SolanaSend };
+//# sourceMappingURL=SolanaSend.js.map

package/build/components/Pages/Send/SolanaSend.js.map

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

package/build/components/Pages/Send/index.d.ts

@@ -1,7 +1,8 @@
 /**
  * Send page router
  *
- * Picks EthereumSend or SolanaSend based on chainType.
+ * Renders the EVM send form. Solana is reached via the dedicated `sol:send`
+ * route (registered in ConnectModal), so it isn't in this shared registry.
  */
 import type React from 'react';
 declare const Send: React.FC;

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

@@ -5,7 +5,6 @@ import { EthereumSend } from './EthereumSend.js';
 
 const SEND_REGISTRY = {
     [ChainTypeEnum.EVM]: EthereumSend,
-    // [ChainTypeEnum.SVM]: SolanaSend,
 };
 const Send = () => {
     const { chainType } = useOpenfortCore();

package/build/components/Pages/Send/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/Send/utils.js

@@ -44,10 +44,13 @@ const isSameToken = (a, b) => {
         return false;
     if (a.type === 'native')
         return true;
-    // At this point, a.type === 'erc20' and b.type === 'erc20'
     if (a.type === 'erc20' && b.type === 'erc20') {
         return a.address.toLowerCase() === b.address.toLowerCase();
     }
+    // SPL mints are base58 and case-sensitive — compare verbatim.
+    if (a.type === 'spl' && b.type === 'spl') {
+        return a.address === b.address;
+    }
     return false;
 };
 const getAssetSymbol = (asset) => {

package/build/components/Pages/Send/utils.js.map

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