@openfort/react 1.1.3 → 1.2.0

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

@@ -0,0 +1,17 @@
+import type { FundingChain, FundingCurrency } from '../../../hooks/openfort/useFundingChains';
+type Props = {
+    /** Relay deposit address the source funds are sent to. */
+    receiverAddress: string | null;
+    activeChain: FundingChain | undefined;
+    activeCurrency: FundingCurrency | undefined;
+    loading: boolean;
+};
+/**
+ * Desktop "transfer from wallet": send the source token to the Relay deposit
+ * address straight from the user's EXTERNAL browser-extension wallet
+ * (MetaMask/Rabby/…), via that connector's own provider — never the active
+ * Openfort embedded account (that one is the destination, not the source).
+ * Once the deposit lands, the funding session's status polling drives progress.
+ */
+export declare function DepositWalletDesktop({ receiverAddress, activeChain, activeCurrency, loading }: Props): import("react/jsx-runtime").JSX.Element | null;
+export {};

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

@@ -0,0 +1,148 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { useState } from 'react';
+import { parseUnits, formatUnits, encodeFunctionData, erc20Abi } from 'viem';
+import { WalletIcon } from '../../../assets/icons.js';
+import Logos from '../../../assets/logos.js';
+import { useEthereumBridge } from '../../../ethereum/OpenfortEthereumBridgeContext.js';
+import { ModalBody } from '../../Common/Modal/styles.js';
+import { DepositStatus } from '../Deposit/DepositStatus.js';
+import { walletListBtn } from '../Deposit/formStyles.js';
+import { ButtonLogo } from '../Deposit/styles.js';
+import { caipToChainId } from './walletDeeplinks.js';
+
+/** Hardcoded brand logo for a connector, matched by id/name; falls back to its own icon, then a generic. */
+function brandLogo(connector) {
+    const k = `${connector.id} ${connector.name}`.toLowerCase();
+    if (k.includes('metamask'))
+        return jsx(Logos.MetaMask, { background: true });
+    if (k.includes('rabby'))
+        return jsx(Logos.Rabby, {});
+    if (k.includes('coinbase'))
+        return jsx(Logos.Coinbase, { background: true });
+    if (k.includes('phantom'))
+        return jsx(Logos.Phantom, { background: true });
+    if (k.includes('trust'))
+        return jsx(Logos.Trust, {});
+    if (k.includes('rainbow'))
+        return jsx(Logos.Rainbow, { round: true });
+    if (connector.icon)
+        return jsx("img", { src: connector.icon, alt: "", width: 20, height: 20, style: { borderRadius: 6 } });
+    return jsx(WalletIcon, {});
+}
+/** Readable message from a wallet/provider error; null for a user rejection (4001). */
+function walletErrorMessage(e) {
+    if (e && typeof e === 'object') {
+        const o = e;
+        if (o.code === 4001)
+            return null; // user rejected — nothing to flag
+        return o.shortMessage || o.message || o.details || 'Transaction failed';
+    }
+    return typeof e === 'string' ? e : 'Transaction failed';
+}
+/** Keep only digits and a single decimal point. */
+function sanitizeAmount(v) {
+    const cleaned = v.replace(/[^0-9.]/g, '');
+    const [whole, ...rest] = cleaned.split('.');
+    return rest.length ? `${whole}.${rest.join('')}` : cleaned;
+}
+const inputStyle = {
+    width: '100%',
+    padding: '12px 14px',
+    borderRadius: 12,
+    border: '1px solid var(--ck-body-divider, #e4e4e7)',
+    background: 'var(--ck-body-background-secondary, #fafafa)',
+    color: 'var(--ck-body-color, #111)',
+    fontSize: 16,
+    outline: 'none',
+};
+/**
+ * Desktop "transfer from wallet": send the source token to the Relay deposit
+ * address straight from the user's EXTERNAL browser-extension wallet
+ * (MetaMask/Rabby/…), via that connector's own provider — never the active
+ * Openfort embedded account (that one is the destination, not the source).
+ * Once the deposit lands, the funding session's status polling drives progress.
+ */
+function DepositWalletDesktop({ receiverAddress, activeChain, activeCurrency, loading }) {
+    const bridge = useEthereumBridge();
+    const [amount, setAmount] = useState('');
+    const [busyId, setBusyId] = useState(null);
+    const [error, setError] = useState(null);
+    const [sent, setSent] = useState(false);
+    if (!bridge)
+        return null; // EVM-only (no wagmi) — nothing to send through
+    // bridge.connectors already excludes the Openfort embedded connector, so these
+    // are the user's external wallets. Drop WalletConnect: its provider needs a
+    // connect()/session flow our direct request() path doesn't support.
+    const connectors = bridge.connectors.filter((c) => !c.id.toLowerCase().includes('walletconnect'));
+    const srcChainId = caipToChainId(activeChain === null || activeChain === void 0 ? void 0 : activeChain.id);
+    const amountValid = Number.parseFloat(amount) > 0;
+    const sendVia = async (c) => {
+        var _a, _b;
+        if (!receiverAddress || !activeCurrency || !srcChainId || !amountValid)
+            return;
+        setBusyId(c.id);
+        setError(null);
+        setSent(false);
+        try {
+            const provider = (await ((_a = c.getProvider) === null || _a === void 0 ? void 0 : _a.call(c)));
+            if (!provider)
+                throw new Error('Wallet provider unavailable');
+            const accounts = (await provider.request({ method: 'eth_requestAccounts' }));
+            const from = accounts === null || accounts === void 0 ? void 0 : accounts[0];
+            if (!from)
+                throw new Error('No account in wallet');
+            // Ask the wallet to switch to the source chain (ignored if already there).
+            await provider
+                .request({ method: 'wallet_switchEthereumChain', params: [{ chainId: `0x${srcChainId.toString(16)}` }] })
+                .catch(() => { });
+            const value = parseUnits(amount, activeCurrency.decimals);
+            const to = receiverAddress;
+            // Guard: confirm the wallet holds enough on this chain. Otherwise the transfer
+            // just reverts (wasted gas) and the deposit never arrives — the bug we hit.
+            const balance = activeCurrency.native
+                ? BigInt((await provider.request({ method: 'eth_getBalance', params: [from, 'latest'] })))
+                : BigInt((await provider.request({
+                    method: 'eth_call',
+                    params: [
+                        { to: activeCurrency.address, data: `0x70a08231${from.slice(2).padStart(64, '0')}` },
+                        'latest',
+                    ],
+                })) || '0x0');
+            if (balance < value) {
+                setError(`Not enough ${activeCurrency.symbol} on ${(_b = activeChain === null || activeChain === void 0 ? void 0 : activeChain.name) !== null && _b !== void 0 ? _b : 'this chain'} — you have ${formatUnits(balance, activeCurrency.decimals)}.`);
+                return;
+            }
+            if (activeCurrency.native) {
+                await provider.request({
+                    method: 'eth_sendTransaction',
+                    params: [{ from, to, value: `0x${value.toString(16)}` }],
+                });
+            }
+            else {
+                const data = encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] });
+                await provider.request({
+                    method: 'eth_sendTransaction',
+                    params: [{ from, to: activeCurrency.address, data }],
+                });
+            }
+            setSent(true);
+        }
+        catch (e) {
+            setError(walletErrorMessage(e));
+        }
+        finally {
+            setBusyId(null);
+        }
+    };
+    return (jsxs("div", { style: { display: 'flex', flexDirection: 'column', gap: 10, marginTop: 14 }, children: [jsx("input", { value: amount, onChange: (e) => setAmount(sanitizeAmount(e.target.value)), placeholder: `Amount${activeCurrency ? ` in ${activeCurrency.symbol}` : ''}`, inputMode: "decimal", style: inputStyle }), connectors.length === 0 && jsx(ModalBody, { children: "No browser wallet detected. Install MetaMask or Rabby." }), connectors.map((c) => (jsxs("button", { type: "button", disabled: !amountValid || busyId !== null || loading, style: {
+                    ...walletListBtn,
+                    display: 'flex',
+                    alignItems: 'center',
+                    justifyContent: 'flex-start',
+                    gap: 10,
+                    opacity: !amountValid || busyId !== null ? 0.55 : 1,
+                }, onClick: () => sendVia(c), children: [jsx(ButtonLogo, { children: brandLogo(c) }), jsx("span", { children: busyId === c.id ? 'Confirm in your wallet…' : `Send via ${c.name}` })] }, c.id))), sent && jsx(DepositStatus, { status: "waiting_payment" }), error && jsx(ModalBody, { style: { color: '#dc2626' }, children: error })] }));
+}
+
+export { DepositWalletDesktop };
+//# sourceMappingURL=DepositWalletDesktop.js.map

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

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

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

@@ -0,0 +1,9 @@
+/**
+ * Transfer from wallet. On mobile, leads with open-dApp deeplinks that send the
+ * user into their wallet app's in-app browser pointed at the hosted deposit page
+ * (with the address/chain/token/amount prefilled). On desktop, sends straight
+ * from the browser-extension wallet. Either way 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,102 @@
+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 { 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 { StepDivider, Skeleton, ButtonLogo } from '../Deposit/styles.js';
+import { useDepositRoute } from '../Deposit/useDepositRoute.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, {}),
+};
+const amountInputStyle = {
+    width: '100%',
+    padding: '12px 14px',
+    borderRadius: 12,
+    border: '1px solid var(--ck-body-divider, #e4e4e7)',
+    background: 'var(--ck-body-background-secondary, #fafafa)',
+    color: 'var(--ck-body-color, #111)',
+    fontSize: 16,
+    outline: 'none',
+    marginTop: 14,
+};
+/** Keep only digits and a single decimal point. */
+function sanitizeAmount(v) {
+    const cleaned = v.replace(/[^0-9.]/g, '');
+    const [whole, ...rest] = cleaned.split('.');
+    return rest.length ? `${whole}.${rest.join('')}` : cleaned;
+}
+/**
+ * Transfer from wallet. On mobile, leads with open-dApp deeplinks that send the
+ * user into their wallet app's in-app browser pointed at the hosted deposit page
+ * (with the address/chain/token/amount prefilled). On desktop, sends straight
+ * from the browser-extension wallet. Either way the manual deposit-address / QR
+ * path stays available below.
+ */
+const DepositWallet = () => {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const { triggerResize, uiConfig } = useOpenfort();
+    const isMobile = useIsMobile();
+    const route = useDepositRoute('crypto');
+    const [amount, setAmount] = useState('');
+    const depositPageUrl = (_b = (_a = uiConfig.funding) === null || _a === void 0 ? void 0 : _a.depositPageUrl) !== null && _b !== void 0 ? _b : OPENFORT_DEPOSIT_PAGE_URL;
+    const srcChainId = caipToChainId((_c = route.activeChain) === null || _c === void 0 ? void 0 : _c.id);
+    const amountValid = Number.parseFloat(amount) > 0;
+    // 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 && srcChainId
+        ? buildDepositPageUrl(depositPageUrl, {
+            to: route.receiverAddress,
+            chainId: srcChainId,
+            token: route.activeCurrency.native ? undefined : route.activeCurrency.address,
+            decimals: route.activeCurrency.decimals,
+            symbol: route.activeCurrency.symbol,
+            chain: (_d = route.activeChain) === null || _d === void 0 ? void 0 : _d.name,
+            amount: amountValid ? parseUnits(amount, route.activeCurrency.decimals).toString() : undefined,
+        })
+        : null;
+    const allDeeplinks = ((_f = (_e = route.pm) === null || _e === void 0 ? void 0 : _e.deeplinks) === null || _f === void 0 ? void 0 : _f.length)
+        ? route.pm.deeplinks
+        : pageUrl
+            ? buildOpenDappLinks(pageUrl, (_h = (_g = route.activeChain) === null || _g === void 0 ? void 0 : _g.vmType) !== null && _h !== void 0 ? _h : '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." }), jsx(StepDivider, { children: isMobile ? 'Then open your wallet' : 'Then send from your wallet' }), isMobile ? (jsxs(Fragment, { children: [jsx("input", { value: amount, onChange: (e) => setAmount(sanitizeAmount(e.target.value)), placeholder: `Amount${route.activeCurrency ? ` in ${route.activeCurrency.symbol}` : ''}`, inputMode: "decimal", style: amountInputStyle }), !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 })), 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,48 @@
+/**
+ * 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 = {
+    /** Relay deposit address the source funds go to. */
+    to: string;
+    /** Numeric source chain id (e.g. 42161). */
+    chainId: number;
+    /** ERC-20 contract, 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,107 @@
+/**
+ * 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('to', p.to);
+    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/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,88 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { useMemo } from 'react';
+import { parseUnits, formatUnits } from 'viem';
+import { fetchSolanaBalance } from '../../../hooks/useBalance.js';
+import { useAsyncData } from '../../../shared/hooks/useAsyncData.js';
+import { useSolanaEmbeddedWallet } from '../../../solana/hooks/useSolanaEmbeddedWallet.js';
+import Button from '../../Common/Button/index.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, 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);
+}
+const SolanaSend = () => {
+    var _a;
+    const { sendForm, setSendForm, setRoute } = useOpenfort();
+    const wallet = useSolanaEmbeddedWallet();
+    const address = wallet.status === 'connected' ? wallet.address : undefined;
+    const rpcUrl = wallet.rpcUrl;
+    const balanceResult = useAsyncData({
+        queryKey: ['solana-balance', address, rpcUrl],
+        queryFn: async () => {
+            if (!address || !rpcUrl)
+                return null;
+            const { value } = await fetchSolanaBalance(address, rpcUrl, 'confirmed');
+            return value;
+        },
+        enabled: Boolean(address && rpcUrl),
+    });
+    const balanceLamports = (_a = balanceResult.data) !== null && _a !== void 0 ? _a : undefined;
+    const parsedAmount = useMemo(() => {
+        const raw = sanitizeForParsing(sendForm.amount);
+        if (!raw)
+            return null;
+        try {
+            return parseUnits(raw, SOL_DECIMALS);
+        }
+        catch {
+            return null;
+        }
+    }, [sendForm.amount]);
+    const recipientValid = isLikelySolanaAddress(sendForm.recipient.trim());
+    const insufficientBalance = parsedAmount !== null && balanceLamports !== undefined ? parsedAmount > balanceLamports : false;
+    const amountValid = parsedAmount !== null && parsedAmount > BigInt(0) && !insufficientBalance;
+    const canProceed = recipientValid && amountValid;
+    const availableLabel = formatBalance(balanceLamports, SOL_DECIMALS);
+    const handleSubmit = (event) => {
+        event.preventDefault();
+        if (!canProceed)
+            return;
+        const normalized = sanitizeForParsing(sendForm.amount);
+        if (!normalized)
+            return;
+        setSendForm((prev) => ({
+            ...prev,
+            recipient: prev.recipient.trim(),
+            amount: normalized,
+            asset: {
+                type: 'native',
+                balance: balanceLamports !== null && balanceLamports !== void 0 ? balanceLamports : BigInt(0),
+                metadata: { symbol: 'SOL', decimals: SOL_DECIMALS, fiat: { value: 0, currency: 'USD' } },
+            },
+        }));
+        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 (balanceLamports === undefined)
+            return;
+        setSendForm((prev) => ({ ...prev, amount: formatUnits(balanceLamports, SOL_DECIMALS) }));
+    };
+    return (jsxs(PageContent, { onBack: routes.SOL_CONNECTED, children: [jsx(ModalHeading, { children: "Send SOL" }), jsxs(Form, { onSubmit: handleSubmit, children: [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: balanceLamports === undefined, children: "Max" })] }), jsxs(HelperText, { children: ["Available: ", availableLabel, " SOL"] }), sendForm.amount && parsedAmount === null && jsx(ErrorText, { children: "Enter a valid amount." }), insufficientBalance && jsx(ErrorText, { children: "Insufficient SOL 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}