@openfort/react 1.2.0 → 1.3.0

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

@@ -11,8 +11,9 @@ import { routes } from '../../Openfort/types.js';
 import { useOpenfort } from '../../Openfort/useOpenfort.js';
 import { PageContent } from '../../PageContent/index.js';
 import { isCoinbaseSupported } from '../Buy/coinbaseApi.js';
-import { getAllQuotes } from '../Buy/onrampApi.js';
+import { resolveOnrampNetwork, getAllQuotes } from '../Buy/onrampApi.js';
 import { getProviders } from '../Buy/providers.js';
+import { SOLANA_BUY_CURRENCIES } from '../Buy/solanaCurrencies.js';
 import { isStripeSupported } from '../Buy/stripeApi.js';
 import { ProviderList, ProviderButton, ProviderInfo, ProviderNameRow, ProviderName, ProviderBadge, ProviderMeta, ProviderRight, ProviderQuote, ProviderFiat, ContinueButtonWrapper } from '../Buy/styles.js';
 import { createCurrencyFormatter, formatTokenAmount } from '../Buy/utils.js';
@@ -28,6 +29,9 @@ const BuySelectProvider = () => {
     const isConnected = wallet.status === 'connected';
     const address = isConnected ? wallet.address : undefined;
     const chainId = isConnected && chainType === ChainTypeEnum.EVM ? wallet.chainId : undefined;
+    // The onramp destination network: 'solana' for SVM, else the EVM network (undefined
+    // until the EVM chainId resolves, which keeps quote fetching gated as before).
+    const network = resolveOnrampNetwork(chainType, chainId);
     const [quotes, setQuotes] = useState({});
     const [isLoadingQuote, setIsLoadingQuote] = useState(false);
     const [coinbaseError, setCoinbaseError] = useState(false);
@@ -43,7 +47,8 @@ const BuySelectProvider = () => {
             return null;
         return numeric;
     }, [buyForm.amount]);
-    const { data: assets } = useEthereumWalletAssets();
+    const { data: ethAssets } = useEthereumWalletAssets();
+    const assets = chainType === ChainTypeEnum.SVM ? SOLANA_BUY_CURRENCIES : ethAssets;
     const matchedToken = useMemo(() => assets === null || assets === void 0 ? void 0 : assets.find((asset) => isSameToken(asset, buyForm.asset)), [assets, buyForm.asset]);
     const selectedTokenOption = matchedToken !== null && matchedToken !== void 0 ? matchedToken : assets === null || assets === void 0 ? void 0 : assets[0];
     const selectedToken = selectedTokenOption !== null && selectedTokenOption !== void 0 ? selectedTokenOption : buyForm.asset;
@@ -77,7 +82,7 @@ const BuySelectProvider = () => {
     // Fetch quotes from all providers
     useEffect(() => {
         const fetchQuotes = async () => {
-            if (!address || !chainId || !fiatAmount || fiatAmount <= 0) {
+            if (!address || !network || !fiatAmount || fiatAmount <= 0) {
                 setQuotes({});
                 setCoinbaseError(false);
                 setStripeError(false);
@@ -89,7 +94,7 @@ const BuySelectProvider = () => {
             try {
                 const allQuotes = await getAllQuotes({
                     token: selectedToken,
-                    chainId,
+                    network,
                     publishableKey,
                     sourceAmount: fiatAmount.toFixed(2),
                     sourceCurrency: buyForm.currency,
@@ -120,7 +125,7 @@ const BuySelectProvider = () => {
         selectedToken.metadata,
         selectedToken.type,
         buyForm.currency,
-        chainId,
+        network,
         address,
         publishableKey,
         refetchTrigger,

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

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

package/build/components/Pages/Connected/SolanaConnected.js

@@ -15,12 +15,13 @@ import Avatar from '../../Common/Avatar/index.js';
 import Button from '../../Common/Button/index.js';
 import { TextLinkButton } from '../../Common/Button/styles.js';
 import { CopyText } from '../../Common/CopyToClipboard/CopyText.js';
+import SolanaChain from '../../Common/SolanaChain/index.js';
 import { useThemeContext } from '../../ConnectKitThemeProvider/ConnectKitThemeProvider.js';
 import { routes } from '../../Openfort/types.js';
 import { useOpenfort } from '../../Openfort/useOpenfort.js';
 import { PageContent } from '../../PageContent/index.js';
 import { ConnectedPageLayout } from './ConnectedPageLayout.js';
-import { LinkedProvidersToggle, Balance, ActionButton } from './styles.js';
+import { LinkedProvidersToggle, Balance, ChainSelectorContainer, ActionButton } from './styles.js';
 import { truncateSolanaAddress } from '../../../utils/format.js';
 
 const SolanaConnected = () => {
@@ -90,7 +91,7 @@ const SolanaConnected = () => {
         : undefined;
     const avatar = address ? CustomAvatar ? jsx(CustomAvatar, { address: address }) : jsx(Avatar, { address: address }) : jsx("span", {});
     const balanceNode = balanceSol != null && !isBalanceLoading ? (jsx(TextLinkButton, { type: "button", onClick: () => setRoute(routes.SOL_ASSET_INVENTORY), children: jsxs(Balance, { initial: { opacity: 0 }, animate: { opacity: 1 }, exit: { opacity: 0 }, transition: { duration: 0.2 }, children: [nFormatter(Number(balanceSol)), " SOL"] }, "solana-balance") })) : null;
-    return (jsx(PageContent, { onBack: null, header: locales.profileScreen_heading, children: jsx(ConnectedPageLayout, { address: address !== null && address !== void 0 ? address : '', displayName: jsx(CopyText, { value: address !== null && address !== void 0 ? address : '', children: truncateSolanaAddress(address !== null && address !== void 0 ? address : '', separator) }), avatar: avatar, balance: balanceNode, actions: jsxs(Fragment, { children: [jsx(ActionButton, { icon: jsx(SendIcon, {}), onClick: () => {
+    return (jsx(PageContent, { onBack: null, header: locales.profileScreen_heading, children: jsx(ConnectedPageLayout, { address: address !== null && address !== void 0 ? address : '', displayName: jsx(CopyText, { value: address !== null && address !== void 0 ? address : '', children: truncateSolanaAddress(address !== null && address !== void 0 ? address : '', separator) }), avatar: avatar, beforeAvatar: jsx(ChainSelectorContainer, { initial: { opacity: 0 }, animate: { opacity: 1 }, transition: { duration: 0.2 }, children: jsx(SolanaChain, {}) }), balance: balanceNode, actions: jsxs(Fragment, { children: [jsx(ActionButton, { icon: jsx(SendIcon, {}), onClick: () => {
                             // Nothing to send on an empty wallet — prompt to add funds first (mirrors EVM).
                             const hasBalance = lamports != null && BigInt(lamports) > BigInt(0);
                             context.setRoute(hasBalance ? routes.SOL_SEND : routes.NO_ASSETS_AVAILABLE);

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

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

package/build/components/Pages/Deposit/DepositProgress.js

@@ -4,6 +4,7 @@ import styled from '../../../styles/styled/index.js';
 import { logger } from '../../../utils/logger.js';
 import Button from '../../Common/Button/index.js';
 import { ModalHeading, ModalBody } from '../../Common/Modal/styles.js';
+import PoweredByFooter from '../../Common/PoweredByFooter/index.js';
 import { Spinner } from '../../Common/Spinner/index.js';
 import { routes } from '../../Openfort/types.js';
 import { useOpenfort } from '../../Openfort/useOpenfort.js';
@@ -96,14 +97,14 @@ function DepositProgress({ status }) {
         return jsx(DepositSuccess, {});
     if (status === 'bounced' || status === 'expired') {
         const ui = OUTCOME[status];
-        return (jsxs(PageContent, { children: [jsx(ModalHeading, { children: ui === null || ui === void 0 ? void 0 : ui.heading }), jsx(ModalBody, { children: ui === null || ui === void 0 ? void 0 : ui.body }), jsx(Button, { variant: "primary", onClick: () => setRoute(status === 'expired' ? routes.DEPOSIT : routes.CONNECTED), children: status === 'expired' ? 'Start over' : 'See balance' })] }));
+        return (jsxs(PageContent, { children: [jsx(ModalHeading, { children: ui === null || ui === void 0 ? void 0 : ui.heading }), jsx(ModalBody, { children: ui === null || ui === void 0 ? void 0 : ui.body }), jsx(Button, { variant: "primary", onClick: () => setRoute(status === 'expired' ? routes.DEPOSIT : routes.CONNECTED), children: status === 'expired' ? 'Start over' : 'See balance' }), jsx(PoweredByFooter, {})] }));
     }
     // processing → bridging active (step 1); succeeded (pre-confirmed) → delivering active (step 2).
     const activeStep = status === 'succeeded' ? 2 : 1;
     return (jsxs(PageContent, { children: [jsx(ModalHeading, { children: "Completing your deposit" }), jsx(ModalBody, { children: "Keep this open \u2014 your funds are on the way." }), jsx(StepList, { children: STEPS.map((step, i) => {
                     const state = stepStateFor(i, activeStep);
                     return (jsxs(StepRow, { "$state": state, children: [state === 'active' ? jsx(Spinner, {}) : jsx(StepMark, { "$state": state, children: state === 'done' ? '✓' : '' }), jsx("span", { children: step.label })] }, step.key));
-                }) })] }));
+                }) }), jsx(PoweredByFooter, {})] }));
 }
 
 export { DepositProgress, isDepositFlowActive };

package/build/components/Pages/Deposit/DepositProgress.js.map

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

package/build/components/Pages/Deposit/DepositSuccess.js

@@ -2,6 +2,7 @@ import { jsxs, jsx } from 'react/jsx-runtime';
 import { useEffect } from 'react';
 import Button from '../../Common/Button/index.js';
 import Loader from '../../Common/Loading/index.js';
+import PoweredByFooter from '../../Common/PoweredByFooter/index.js';
 import { routes } from '../../Openfort/types.js';
 import { useOpenfort } from '../../Openfort/useOpenfort.js';
 import { PageContent } from '../../PageContent/index.js';
@@ -17,7 +18,7 @@ function DepositSuccess() {
     useEffect(() => {
         triggerResize();
     }, [triggerResize]);
-    return (jsxs(PageContent, { children: [jsx(Loader, { isSuccess: true, header: "Deposit received", description: "Funds delivered to your wallet" }), jsx(Button, { variant: "primary", onClick: () => setRoute(routes.ASSET_INVENTORY), children: "See balance" })] }));
+    return (jsxs(PageContent, { children: [jsx(Loader, { isSuccess: true, header: "Deposit received", description: "Funds delivered to your wallet" }), jsx(Button, { variant: "primary", onClick: () => setRoute(routes.ASSET_INVENTORY), children: "See balance" }), jsx(PoweredByFooter, {})] }));
 }
 
 export { DepositSuccess };

package/build/components/Pages/Deposit/DepositSuccess.js.map

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

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

@@ -1,13 +1,18 @@
 import { jsx, jsxs } from 'react/jsx-runtime';
+import { ChainTypeEnum } from '@openfort/openfort-js';
 import { DollarIcon, BuyIcon, WalletIcon, ReceiveIcon, ExternalLinkIcon } from '../../../assets/icons.js';
 import Logos from '../../../assets/logos.js';
 import { useFunding } from '../../../hooks/openfort/useFunding.js';
 import { useFundingChains } from '../../../hooks/openfort/useFundingChains.js';
 import useIsMobile from '../../../hooks/useIsMobile.js';
+import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
 import { ModalHeading } from '../../Common/Modal/styles.js';
+import PoweredByFooter from '../../Common/PoweredByFooter/index.js';
 import { FundingMethod, routes } from '../../Openfort/types.js';
 import { useOpenfort } from '../../Openfort/useOpenfort.js';
 import { PageContent } from '../../PageContent/index.js';
+import { EVM_BUY_CURRENCIES } from '../Buy/evmCurrencies.js';
+import { SOLANA_BUY_CURRENCIES } from '../Buy/solanaCurrencies.js';
 import { getPaymentOptions } from './paymentOptions.js';
 import { DepositContent, OptionList, OptionButton, OptionLeft, OptionIconBadge, OptionInfo, OptionTitle, OptionSubtitle, LogoCluster } from './styles.js';
 
@@ -43,6 +48,7 @@ const hideBrokenLogo = (e) => {
 const Deposit = () => {
     var _a;
     const { setRoute, setBuyForm, uiConfig } = useOpenfort();
+    const { chainType } = useOpenfortCore();
     const isMobile = useIsMobile();
     const { isAvailable } = useFunding();
     const { chains } = useFundingChains();
@@ -87,13 +93,21 @@ const Deposit = () => {
         }
         // Fiat rails reuse the existing Buy flow; preselect the chosen provider so
         // Apple Pay / Card land on the right rail.
-        setBuyForm((prev) => ({ ...prev, providerId: target.providerId }));
+        setBuyForm((prev) => ({
+            ...prev,
+            providerId: target.providerId,
+            // Default the card-buy to USDC per chain family. Without this the EVM default
+            // resolves to the wallet's (often empty) asset list — "no supported tokens" —
+            // and the Solana native default would resolve to SOL (isSameToken treats any
+            // two natives as equal).
+            asset: chainType === ChainTypeEnum.SVM ? SOLANA_BUY_CURRENCIES[0] : EVM_BUY_CURRENCIES[0],
+        }));
         setRoute(routes.BUY);
     };
     return (jsxs(PageContent, { onBack: routes.CONNECTED, children: [jsx(ModalHeading, { children: "Add funds" }), jsx(DepositContent, { children: jsx(OptionList, { children: options.map((option) => {
                         var _a;
                         return (jsxs(OptionButton, { type: "button", disabled: option.disabled, onClick: () => go(option.target), children: [jsxs(OptionLeft, { children: [jsx(OptionIconBadge, { children: METHOD_ICON[option.id] }), jsxs(OptionInfo, { children: [jsx(OptionTitle, { children: option.title }), jsx(OptionSubtitle, { children: (_a = option.disabledReason) !== null && _a !== void 0 ? _a : option.subtitle })] })] }), jsx(LogoCluster, { children: clusterFor(option.id) })] }, option.id));
-                    }) }) })] }));
+                    }) }) }), jsx(PoweredByFooter, {})] }));
 };
 
 export { Deposit as default };

package/build/components/Pages/Deposit/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/Deposit/paymentOptions.js

@@ -17,19 +17,19 @@ const ALL_METHODS = [
     {
         id: FundingMethod.WALLET,
         title: 'Transfer from wallet',
-        subtitle: 'Min $1 · No fee · 10 sec',
+        subtitle: 'Min $1 · Bridge fee · 10 sec',
         target: { kind: 'wallet' },
     },
     {
         id: FundingMethod.ADDRESS,
         title: 'Transfer from address',
-        subtitle: 'Min $1 · No fee · 10 sec',
+        subtitle: 'Min $1 · Bridge fee · 10 sec',
         target: { kind: 'crypto' },
     },
     {
         id: FundingMethod.EXCHANGE,
         title: 'Transfer from Exchange',
-        subtitle: 'Min $1 · Network fee · 2 min',
+        subtitle: 'Min $5 · Network fee · 2 min',
         target: { kind: 'cex' },
     },
 ];

package/build/components/Pages/Deposit/useDepositRoute.d.ts

@@ -21,7 +21,6 @@ export declare function useDepositRoute(kind: DepositRouteKind): {
     target: {
         chain: string;
         currency: string;
-        address?: string;
     };
     pm: import("../../../hooks/openfort/useFunding").PaymentMethod | null;
     receiverAddress: string | null;

package/build/components/Pages/Deposit/useDepositRoute.js

@@ -1,9 +1,7 @@
-import { ChainTypeEnum } from '@openfort/openfort-js';
 import { useState, useRef, useEffect } from 'react';
 import { useEthereumEmbeddedWallet } from '../../../ethereum/hooks/useEthereumEmbeddedWallet.js';
 import { useFunding } from '../../../hooks/openfort/useFunding.js';
 import { useFundingChains, nominalUnits } from '../../../hooks/openfort/useFundingChains.js';
-import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
 import { useSolanaEmbeddedWallet } from '../../../solana/hooks/useSolanaEmbeddedWallet.js';
 import { logger } from '../../../utils/logger.js';
 import { isCexDeliverable } from './cexChains.js';
@@ -24,20 +22,21 @@ function paymentMethodFor(chain, currency) {
  */
 function useDepositRoute(kind) {
     var _a, _b, _c, _d, _e, _f, _g, _h;
-    const { chainType } = useOpenfortCore();
     const ethWallet = useEthereumEmbeddedWallet();
     const solWallet = useSolanaEmbeddedWallet();
-    // Funds land in the active chain's embedded wallet (EVM or Solana).
-    const wallet = chainType === ChainTypeEnum.SVM ? solWallet : ethWallet;
     const { session, status, error, loading, isAvailable, fund, payLink, reset } = useFunding();
     const { chains: allChains, loading: chainsLoading } = useFundingChains();
     const target = useFundingTarget();
-    // Drop the destination chain — funding is cross-chain; same-chain is a plain
-    // transfer with no Relay route, so it shouldn't appear as a source option.
-    const sourceChains = allChains.filter((c) => c.id !== target.chain);
-    // The CEX rail rides Coinbase Onramp, which only delivers to a fixed set of EVM
-    // chains — offer those as the pay-with sources.
-    const chains = kind === 'cex' ? sourceChains.filter((c) => isCexDeliverable(c.id)) : sourceChains;
+    // The deposit recipient must live on the TARGET chain, so resolve the wallet by
+    // the target's family — not the active chainType, which can disagree with the
+    // target (e.g. an EVM session whose funding target is still Solana) and would
+    // send an EVM address as the recipient for a Solana destination.
+    const wallet = isSolana(target.chain) ? solWallet : ethWallet;
+    // Sources are the full Relay list, including the destination chain itself so
+    // same-chain deposits (e.g. Solana → Solana) are offered as a plain transfer to
+    // the wallet address, alongside the cross-chain bridge routes. The CEX rail rides
+    // Coinbase Onramp, which only delivers to a fixed set of EVM chains.
+    const chains = kind === 'cex' ? allChains.filter((c) => isCexDeliverable(c.id)) : allChains;
     // Where funds land: the active embedded wallet (the Relay deposit recipient).
     const address = wallet.status === 'connected' ? wallet.address : undefined;
     const [chainId, setChainId] = useState('');

package/build/components/Pages/Deposit/useDepositRoute.js.map

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

package/build/components/Pages/Deposit/useFundingTarget.d.ts

@@ -2,12 +2,10 @@
  * The destination route Deposit-hub funding settles into. Integrators override the
  * chain and currency via `uiConfig.funding.{targetChain,targetCurrency}`; both
  * default to USDC on the active chain type (Base for EVM, Solana mainnet for SVM)
- * so the flow works with zero configuration. `address` is the optional integrator
- * override (`uiConfig.funding.targetAddress`); when unset, callers fall back to the
- * active embedded wallet for the destination chain family.
+ * so the flow works with zero configuration. The deposit recipient is always the
+ * active embedded wallet for the destination chain family — callers resolve it.
  */
 export declare function useFundingTarget(): {
     chain: string;
     currency: string;
-    address?: string;
 };

package/build/components/Pages/Deposit/useFundingTarget.js

@@ -7,19 +7,17 @@ import { DEST_CHAIN_SOL, DEST_CHAIN, DEST_USDC_SOL, DEST_USDC } from './sources.
  * The destination route Deposit-hub funding settles into. Integrators override the
  * chain and currency via `uiConfig.funding.{targetChain,targetCurrency}`; both
  * default to USDC on the active chain type (Base for EVM, Solana mainnet for SVM)
- * so the flow works with zero configuration. `address` is the optional integrator
- * override (`uiConfig.funding.targetAddress`); when unset, callers fall back to the
- * active embedded wallet for the destination chain family.
+ * so the flow works with zero configuration. The deposit recipient is always the
+ * active embedded wallet for the destination chain family — callers resolve it.
  */
 function useFundingTarget() {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d;
     const { uiConfig } = useOpenfort();
     const { chainType } = useOpenfortCore();
     const isSolana = chainType === ChainTypeEnum.SVM;
     return {
         chain: (_b = (_a = uiConfig.funding) === null || _a === void 0 ? void 0 : _a.targetChain) !== null && _b !== void 0 ? _b : (isSolana ? DEST_CHAIN_SOL : DEST_CHAIN),
         currency: (_d = (_c = uiConfig.funding) === null || _c === void 0 ? void 0 : _c.targetCurrency) !== null && _d !== void 0 ? _d : (isSolana ? DEST_USDC_SOL : DEST_USDC),
-        address: (_e = uiConfig.funding) === null || _e === void 0 ? void 0 : _e.targetAddress,
     };
 }
 

package/build/components/Pages/Deposit/useFundingTarget.js.map

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

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

@@ -17,7 +17,7 @@ import { isCexDeliverable, CEX_CHAIN_NAMES } from '../Deposit/cexChains.js';
 import { isDepositFlowActive, DepositProgress } from '../Deposit/DepositProgress.js';
 import { DepositStatus } from '../Deposit/DepositStatus.js';
 import { walletListBtn } from '../Deposit/formStyles.js';
-import { DEST_USDC } from '../Deposit/sources.js';
+import { isSolana, DEST_USDC } from '../Deposit/sources.js';
 import { StepDivider, ButtonLogo } from '../Deposit/styles.js';
 import { useFundingTarget } from '../Deposit/useFundingTarget.js';
 import { sanitizeForParsing, sanitizeAmountInput } from '../Send/utils.js';
@@ -55,7 +55,7 @@ const hideBrokenLogo = (e) => {
  * success / failed screen. No Relay routing; Binance is gated until its rail lands.
  */
 const DepositCex = () => {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f;
     const { triggerResize } = useOpenfort();
     const target = useFundingTarget();
     // CEX (Coinbase pay-link + session) is served by the Openfort API, not the
@@ -73,20 +73,19 @@ const DepositCex = () => {
     // wallet, Solana targets the Solana (SVM) embedded account — never cross families
     // (an EVM address on a Solana target would be rejected / mis-delivered). Accounts
     // come from the core store so EVM-only apps don't need the Solana React context.
-    const isEvmTarget = target.chain.startsWith('eip155:');
     const solanaAddress = (_a = embeddedAccounts === null || embeddedAccounts === void 0 ? void 0 : embeddedAccounts.find((acc) => acc.chainType === ChainTypeEnum.SVM)) === null || _a === void 0 ? void 0 : _a.address;
-    const address = (_b = target.address) !== null && _b !== void 0 ? _b : (isEvmTarget ? wallet.address : solanaAddress);
+    const address = isSolana(target.chain) ? solanaAddress : wallet.address;
     const chainSupported = isCexDeliverable(target.chain);
     // Resolve the destination asset + chain for the "Arrives as …" line. The live
     // chain list is curated for source selection, so the destination may be absent;
     // only claim a symbol we resolved, or USDC for the zero-config default.
     const destChain = chains.find((c) => c.id === target.chain);
-    const destChainName = (_d = (_c = destChain === null || destChain === void 0 ? void 0 : destChain.name) !== null && _c !== void 0 ? _c : CEX_CHAIN_NAMES[target.chain]) !== null && _d !== void 0 ? _d : target.chain;
+    const destChainName = (_c = (_b = destChain === null || destChain === void 0 ? void 0 : destChain.name) !== null && _b !== void 0 ? _b : CEX_CHAIN_NAMES[target.chain]) !== null && _c !== void 0 ? _c : target.chain;
     const destAsset = destChain === null || destChain === void 0 ? void 0 : destChain.currencies.find((c) => c.address.toLowerCase() === target.currency.toLowerCase());
     const isDefaultUsdc = target.currency.toLowerCase() === DEST_USDC.toLowerCase();
-    const destAssetLabel = (_e = destAsset === null || destAsset === void 0 ? void 0 : destAsset.symbol) !== null && _e !== void 0 ? _e : (isDefaultUsdc ? 'USDC' : null);
-    const destAssetLogo = (_f = destAsset === null || destAsset === void 0 ? void 0 : destAsset.logo) !== null && _f !== void 0 ? _f : null;
-    const destChainLogo = (_g = destChain === null || destChain === void 0 ? void 0 : destChain.logo) !== null && _g !== void 0 ? _g : null;
+    const destAssetLabel = (_d = destAsset === null || destAsset === void 0 ? void 0 : destAsset.symbol) !== null && _d !== void 0 ? _d : (isDefaultUsdc ? 'USDC' : null);
+    const destAssetLogo = (_e = destAsset === null || destAsset === void 0 ? void 0 : destAsset.logo) !== null && _e !== void 0 ? _e : null;
+    const destChainLogo = (_f = destChain === null || destChain === void 0 ? void 0 : destChain.logo) !== null && _f !== void 0 ? _f : null;
     // Mint the destination-bound session up-front (per target wallet), so the click
     // that opens Coinbase is a single fast pay-link call and stays popup-safe.
     //

package/build/components/Pages/DepositCex/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/DepositWallet/DepositWalletDesktop.d.ts

@@ -5,6 +5,9 @@ type Props = {
     activeChain: FundingChain | undefined;
     activeCurrency: FundingCurrency | undefined;
     loading: boolean;
+    /** Amount to send, in the source token's units. Owned by the parent so the
+     * amount input + presets are shared with the mobile (deeplink) path. */
+    amount: string;
 };
 /**
  * Desktop "transfer from wallet": send the source token to the Relay deposit
@@ -13,5 +16,5 @@ type Props = {
  * 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 declare function DepositWalletDesktop({ receiverAddress, activeChain, activeCurrency, loading, amount }: Props): import("react/jsx-runtime").JSX.Element | null;
 export {};

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

@@ -1,10 +1,11 @@
 import { jsxs, jsx } from 'react/jsx-runtime';
-import { useState } from 'react';
+import { useState, useEffect } 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 { useOpenfort } from '../../Openfort/useOpenfort.js';
 import { DepositStatus } from '../Deposit/DepositStatus.js';
 import { walletListBtn } from '../Deposit/formStyles.js';
 import { ButtonLogo } from '../Deposit/styles.js';
@@ -39,22 +40,6 @@ function walletErrorMessage(e) {
     }
     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
@@ -62,12 +47,18 @@ const inputStyle = {
  * 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 }) {
+function DepositWalletDesktop({ receiverAddress, activeChain, activeCurrency, loading, amount }) {
     const bridge = useEthereumBridge();
-    const [amount, setAmount] = useState('');
+    const { triggerResize } = useOpenfort();
     const [busyId, setBusyId] = useState(null);
     const [error, setError] = useState(null);
     const [sent, setSent] = useState(false);
+    // Grow the modal when the busy / error / sent feedback toggles, so the "Confirm
+    // in your wallet…" and insufficient-balance messages are revealed instead of
+    // clipped below the fold (which reads as "nothing happened" after a click).
+    useEffect(() => {
+        triggerResize();
+    }, [busyId, error, sent, triggerResize]);
     if (!bridge)
         return null; // EVM-only (no wagmi) — nothing to send through
     // bridge.connectors already excludes the Openfort embedded connector, so these
@@ -134,7 +125,7 @@ function DepositWalletDesktop({ receiverAddress, activeChain, activeCurrency, lo
             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: {
+    return (jsxs("div", { style: { display: 'flex', flexDirection: 'column', gap: 10, marginTop: 14 }, children: [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',

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

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

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

@@ -1,9 +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.
+ * 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;