@openfort/react 1.2.0 → 1.4.0

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

@@ -0,0 +1,131 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { useState, useEffect } from 'react';
+import styled from '../../../styles/styled/index.js';
+import { getPublishableKeyEnvironment } from '../../../utils/validation.js';
+import { useOpenfort } from '../../Openfort/useOpenfort.js';
+
+/** Relay's own testnet guide — the authoritative explanation of the limitation. */
+const RELAY_TESTNET_DOCS = 'https://docs.relay.link/references/api/api_guides/testnet#testnet-support';
+const FlaskIcon = () => (jsxs("svg", { width: "15", height: "15", viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": "true", children: [jsx("path", { d: "M6 1.5h4M6.5 1.5v4.2L3.3 11.4A1.5 1.5 0 0 0 4.6 13.7h6.8a1.5 1.5 0 0 0 1.3-2.3L9.5 5.7V1.5", stroke: "currentColor", strokeWidth: "1.3", strokeLinecap: "round", strokeLinejoin: "round" }), jsx("path", { d: "M5.1 9h5.8", stroke: "currentColor", strokeWidth: "1.3", strokeLinecap: "round" })] }));
+const Card = styled.div `
+  text-align: left;
+  margin-bottom: 14px;
+  border-radius: 12px;
+  /* Amber "sandbox" tint that reads on both light and dark themes. */
+  background: rgba(245, 158, 11, 0.09);
+  border: 1px solid rgba(245, 158, 11, 0.28);
+  color: var(--ck-body-color);
+`;
+/** The always-visible summary row; the whole row toggles the details. */
+const Header = styled.button `
+  appearance: none;
+  width: 100%;
+  display: flex;
+  align-items: center;
+  gap: 9px;
+  padding: 10px 12px;
+  background: none;
+  border: 0;
+  cursor: pointer;
+  color: inherit;
+  font: inherit;
+  text-align: left;
+`;
+const Badge = styled.span `
+  flex-shrink: 0;
+  width: 22px;
+  height: 22px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border-radius: 7px;
+  color: #b45309;
+  background: rgba(245, 158, 11, 0.18);
+`;
+const Summary = styled.span `
+  flex: 1;
+  min-width: 0;
+  font-size: 13px;
+  font-weight: 600;
+  line-height: 1.3;
+`;
+const Chevron = styled.span `
+  flex-shrink: 0;
+  color: var(--ck-body-color-muted, #6b7280);
+  font-size: 11px;
+  transition: transform 150ms ease;
+  transform: rotate(${({ $open }) => ($open ? '90deg' : '0deg')});
+`;
+const Body = styled.div `
+  display: flex;
+  flex-direction: column;
+  gap: 7px;
+  padding: 0 12px 12px 43px;
+  font-size: 12.5px;
+  line-height: 1.45;
+`;
+const Muted = styled.p `
+  margin: 0;
+  color: var(--ck-body-color-muted, #6b7280);
+`;
+const Rules = styled.ul `
+  margin: 0;
+  padding: 0;
+  list-style: none;
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+
+  li {
+    display: flex;
+    align-items: flex-start;
+    gap: 7px;
+  }
+  li[data-ok='true']::before {
+    content: '✓';
+    color: #16a34a;
+    font-weight: 700;
+  }
+  li[data-ok='false']::before {
+    content: '✕';
+    color: #dc2626;
+    font-weight: 700;
+  }
+`;
+const DocsLink = styled.a `
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  width: fit-content;
+  font-weight: 600;
+  color: var(--ck-body-color);
+  text-decoration: underline;
+  text-underline-offset: 2px;
+
+  &:hover {
+    opacity: 0.8;
+  }
+`;
+/**
+ * A dev-facing notice shown only for test keys (`pk_test_…`) in the Deposit flow.
+ *
+ * Collapsed by default to a single summary line; expands to explain that funding
+ * routes through Relay, whose testnet rail bridges the same asset but cannot swap
+ * to a different token (testnets lack DEX liquidity, so e.g. `ETH → USDC` fails),
+ * and that card/exchange rails are mainnet-only. Links to Relay's testnet guide.
+ * Renders nothing on live keys.
+ */
+function TestnetNotice() {
+    const { publishableKey, triggerResize } = useOpenfort();
+    const [open, setOpen] = useState(false);
+    // Re-measure the modal when the details expand/collapse so it grows/shrinks to fit.
+    useEffect(() => {
+        triggerResize();
+    }, [open, triggerResize]);
+    if (getPublishableKeyEnvironment(publishableKey) !== 'test')
+        return null;
+    return (jsxs(Card, { children: [jsxs(Header, { type: "button", "aria-expanded": open, onClick: () => setOpen((v) => !v), children: [jsx(Badge, { children: jsx(FlaskIcon, {}) }), jsx(Summary, { children: "Testnet mode \u2014 funding is limited" }), jsx(Chevron, { "$open": open, children: "\u25B6" })] }), open && (jsxs(Body, { children: [jsx(Muted, { children: "Deposits route through Relay's testnet rail. It bridges the same asset but can't swap between tokens \u2014 testnets have no DEX liquidity. Card and exchange rails are mainnet-only." }), jsxs(Rules, { children: [jsx("li", { "data-ok": "true", children: "Bridging the same asset (e.g. ETH \u2192 ETH) and same-chain transfers" }), jsx("li", { "data-ok": "false", children: "Swapping to another token (e.g. \u2192 USDC) \u2014 fails with \"$0 liquidity\"" })] }), jsx(Muted, { children: "To test swaps, card or exchange deposits, use a live key on a low-cost chain like Base." }), jsx(DocsLink, { href: RELAY_TESTNET_DOCS, target: "_blank", rel: "noreferrer", children: "Why? Read Relay's testnet guide \u2197" })] }))] }));
+}
+
+export { TestnetNotice };
+//# sourceMappingURL=TestnetNotice.js.map

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

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

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

@@ -0,0 +1,12 @@
+import type { FundingChain } from '../../../hooks/openfort/useFundingChains';
+/**
+ * Shown in the deposit flow when the active funding TARGET chain (the embedded
+ * wallet's chain) isn't one the rail can deliver to — e.g. Polygon Amoy or a
+ * Solana testnet, which Relay's testnet rail doesn't route. Explains why, and
+ * (on EVM) offers a one-tap switch to the supported chains. Solana-only contexts
+ * have no in-VM switch, so they get the explanation alone.
+ */
+export declare function UnsupportedNetworkNotice({ targetChain, railChains, }: {
+    targetChain: string;
+    railChains: FundingChain[];
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,111 @@
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { chainConfigs } from '../../../constants/chainConfigs.js';
+import { useEthereumBridge } from '../../../ethereum/OpenfortEthereumBridgeContext.js';
+import styled from '../../../styles/styled/index.js';
+import { useSwitchChainFiltered } from '../../../wagmi/useSwitchChainFiltered.js';
+import Chain from '../../Common/Chain/index.js';
+import { ScrollArea } from '../../Common/ScrollArea/index.js';
+import { isSolana } from './sources.js';
+
+/** Readable name for a CAIP-2 chain the rail can't deliver to. */
+function chainName(caip) {
+    var _a, _b;
+    if (isSolana(caip))
+        return 'Solana';
+    const id = Number(caip.split(':')[1]);
+    return (_b = (_a = chainConfigs.find((c) => c.id === id)) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : 'this network';
+}
+const Card = styled.div `
+  text-align: left;
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  padding: 14px;
+  margin-top: 4px;
+  border-radius: 12px;
+  background: var(--ck-body-background-secondary, #fafafa);
+  border: 1px solid var(--ck-body-divider, #e4e4e7);
+  color: var(--ck-body-color);
+`;
+const Title = styled.div `
+  font-size: 14px;
+  font-weight: 600;
+`;
+const Body = styled.p `
+  margin: 0;
+  font-size: 13px;
+  line-height: 1.45;
+  color: var(--ck-body-color-muted, #6b7280);
+`;
+const Label = styled.div `
+  font-size: 12px;
+  font-weight: 600;
+  color: var(--ck-body-color-muted, #6b7280);
+`;
+const SwitchButtons = styled.div `
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+`;
+const SwitchButton = styled.button `
+  appearance: none;
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  width: 100%;
+  box-sizing: border-box;
+  padding: 10px 12px;
+  border-radius: 10px;
+  border: 1px solid var(--ck-body-divider, #e4e4e7);
+  background: var(--ck-body-background, #fff);
+  color: var(--ck-body-color);
+  font-size: 14px;
+  font-weight: 500;
+  cursor: pointer;
+
+  &:hover:not(:disabled) {
+    background: var(--ck-secondary-button-hover-background, #f3f3f5);
+  }
+  &:disabled {
+    opacity: 0.55;
+    cursor: default;
+  }
+
+  .name {
+    flex: 1;
+    text-align: left;
+  }
+  .chevron {
+    color: var(--ck-body-color-muted, #6b7280);
+  }
+`;
+/**
+ * Shown in the deposit flow when the active funding TARGET chain (the embedded
+ * wallet's chain) isn't one the rail can deliver to — e.g. Polygon Amoy or a
+ * Solana testnet, which Relay's testnet rail doesn't route. Explains why, and
+ * (on EVM) offers a one-tap switch to the supported chains. Solana-only contexts
+ * have no in-VM switch, so they get the explanation alone.
+ */
+function UnsupportedNetworkNotice({ targetChain, railChains, }) {
+    const bridge = useEthereumBridge();
+    return (jsxs(Card, { children: [jsxs(Title, { children: ["Funding isn't available on ", chainName(targetChain)] }), jsx(Body, { children: isSolana(targetChain)
+                    ? "Solana isn't supported by the funding rail in test mode. Switch to a supported EVM testnet to add funds."
+                    : "The funding rail can't deliver to this network. Switch to a supported one to add funds." }), bridge && jsx(SupportedChainSwitcher, { railChains: railChains })] }));
+}
+/**
+ * EVM-only: the rail-supported chains the wallet can switch to. Rendered only when
+ * an Ethereum bridge is present (wagmi), so the wagmi hook below never runs in a
+ * Solana-only provider tree.
+ */
+function SupportedChainSwitcher({ railChains }) {
+    const { chains, switchChain, isPending } = useSwitchChainFiltered();
+    const supported = chains.filter((c) => railChains.some((rc) => rc.id === `eip155:${c.id}`));
+    if (supported.length === 0)
+        return null;
+    return (jsxs(Fragment, { children: [jsx(Label, { children: "Switch to a supported network" }), jsx(ScrollArea, { height: 156, children: jsx(SwitchButtons, { children: supported.map((c) => {
+                        return (jsxs(SwitchButton, { type: "button", disabled: isPending || !switchChain, onClick: () => switchChain === null || switchChain === void 0 ? void 0 : switchChain({ chainId: c.id }), children: [jsx(Chain, { id: c.id, size: 22 }), jsx("span", { className: "name", children: c.name }), jsx("span", { className: "chevron", "aria-hidden": true, children: "\u203A" })] }, c.id));
+                    }) }) })] }));
+}
+
+export { UnsupportedNetworkNotice };
+//# sourceMappingURL=UnsupportedNetworkNotice.js.map

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

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

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

@@ -1,15 +1,25 @@
 import { jsx, jsxs } from 'react/jsx-runtime';
+import { ChainTypeEnum } from '@openfort/openfort-js';
+import { useEffect } from 'react';
 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 { getPublishableKeyEnvironment } from '../../../utils/validation.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';
+import { TestnetNotice } from './TestnetNotice.js';
+import { UnsupportedNetworkNotice } from './UnsupportedNetworkNotice.js';
+import { useFundingTarget } from './useFundingTarget.js';
 
 /** The action icon shown in each row's left badge (icons default to 20×20). */
 const METHOD_ICON = {
@@ -42,13 +52,25 @@ const hideBrokenLogo = (e) => {
  */
 const Deposit = () => {
     var _a;
-    const { setRoute, setBuyForm, uiConfig } = useOpenfort();
+    const { setRoute, setBuyForm, uiConfig, publishableKey, triggerResize } = useOpenfort();
+    const { chainType } = useOpenfortCore();
     const isMobile = useIsMobile();
     const { isAvailable } = useFunding();
-    const { chains } = useFundingChains();
+    const { chains, railChains, loading: chainsLoading } = useFundingChains();
+    const target = useFundingTarget();
+    // The rail can only deliver to chains it lists. If the embedded wallet's target
+    // chain (e.g. Polygon Amoy or a Solana testnet) isn't one of them, there's no
+    // deposit route at all — show the explanation instead of any method options.
+    const targetUnsupported = !chainsLoading && railChains.length > 0 && !railChains.some((c) => c.id === target.chain);
+    // Content swaps between the option list and the notice once chains resolve; the
+    // modal only re-measures on an explicit resize, so nudge it when that flips.
+    useEffect(() => {
+        triggerResize();
+    }, [targetUnsupported, triggerResize]);
     const options = getPaymentOptions({
         isMobile,
         fundingAvailable: isAvailable,
+        testnet: getPublishableKeyEnvironment(publishableKey) === 'test',
         methods: (_a = uiConfig.funding) === null || _a === void 0 ? void 0 : _a.methods,
     });
     // Distinct source-currency logos (USDC, USDT, ETH, …) for the "from address" row.
@@ -87,13 +109,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) => {
+    return (jsxs(PageContent, { onBack: routes.CONNECTED, children: [jsx(ModalHeading, { children: "Add funds" }), jsx(TestnetNotice, {}), targetUnsupported ? (jsx(UnsupportedNetworkNotice, { targetChain: target.chain, railChains: railChains })) : (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.d.ts

@@ -28,6 +28,12 @@ type PaymentOptionsContext = {
     isMobile: boolean;
     /** When the funding backend is unavailable, crypto/CEX rows are disabled. */
     fundingAvailable: boolean;
+    /**
+     * Test-key (`pk_test_…`) project. The fiat (card/Apple Pay) and exchange rails
+     * settle real money on mainnet only — Stripe/Coinbase can't deliver to a testnet
+     * wallet — so they're disabled here. The crypto rails (Relay testnet) stay on.
+     */
+    testnet?: boolean;
     /**
      * Integrator-selected methods, in display order. When set, only these show
      * (still subject to device/availability gating). Omit to show all.

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' },
     },
 ];
@@ -51,7 +51,13 @@ function getPaymentOptions(ctx) {
         ? [...visible].sort((a, b) => Number(b.id === FundingMethod.APPLE_PAY) - Number(a.id === FundingMethod.APPLE_PAY))
         : visible;
     return ordered.map((method) => {
-        const fundingRail = method.target.kind === 'crypto' || method.target.kind === 'wallet' || method.target.kind === 'cex';
+        const kind = method.target.kind;
+        // Fiat (card/Apple Pay) and exchange rails move real money and only settle on
+        // mainnet, so a test-key project can't use them — disable with a clear reason.
+        if (ctx.testnet && (kind === 'buy' || kind === 'cex')) {
+            return { ...method, disabled: true, disabledReason: 'Not available on testnet' };
+        }
+        const fundingRail = kind === 'crypto' || kind === 'wallet' || kind === 'cex';
         if (fundingRail && !ctx.fundingAvailable) {
             return { ...method, disabled: true, disabledReason: 'Coming soon' };
         }

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

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

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

@@ -21,11 +21,12 @@ export declare function useDepositRoute(kind: DepositRouteKind): {
     target: {
         chain: string;
         currency: string;
-        address?: string;
     };
     pm: import("../../../hooks/openfort/useFunding").PaymentMethod | null;
     receiverAddress: string | null;
     sameChain: boolean;
+    targetUnsupported: boolean;
+    railChains: FundingChain[];
     status: import("../../../hooks/openfort/useFunding").SessionStatus | "idle";
     loading: boolean;
     error: Error | 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 { chains: allChains, railChains, 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('');
@@ -50,6 +49,11 @@ function useDepositRoute(kind) {
     const activeCurrency = (_c = currencies.find((c) => c.symbol === currencySymbol)) !== null && _c !== void 0 ? _c : currencies[0];
     const chain = (_d = activeChain === null || activeChain === void 0 ? void 0 : activeChain.id) !== null && _d !== void 0 ? _d : target.chain;
     const sameChain = chain === target.chain;
+    // The rail only delivers to chains in its list; if the active funding TARGET (the
+    // embedded wallet's chain — e.g. Polygon Amoy or a Solana testnet) isn't one of
+    // them, there's no route. Don't call Relay (it would 400 with a cryptic "invalid
+    // currency"); the page prompts a switch to a supported chain instead.
+    const targetUnsupported = !chainsLoading && railChains.length > 0 && !railChains.some((c) => c.id === target.chain);
     const receiverAddress = sameChain
         ? (address !== null && address !== void 0 ? address : null)
         : ((_f = (_e = session === null || session === void 0 ? void 0 : session.paymentMethod) === null || _e === void 0 ? void 0 : _e.receiverAddress) !== null && _f !== void 0 ? _f : null);
@@ -57,6 +61,11 @@ function useDepositRoute(kind) {
     useEffect(() => {
         if (!address || !isAvailable || !activeChain || !activeCurrency)
             return;
+        if (targetUnsupported) {
+            lastKey.current = '';
+            reset();
+            return;
+        }
         if (sameChain) {
             lastKey.current = '';
             reset();
@@ -73,7 +82,19 @@ function useDepositRoute(kind) {
             destChain: target.chain,
         });
         fund({ chain: target.chain, currency: target.currency, address }, paymentMethodFor(activeChain.id, activeCurrency)).catch(() => { });
-    }, [address, activeChain, activeCurrency, isAvailable, sameChain, fund, reset, target.chain, target.currency, kind]);
+    }, [
+        address,
+        activeChain,
+        activeCurrency,
+        isAvailable,
+        sameChain,
+        targetUnsupported,
+        fund,
+        reset,
+        target.chain,
+        target.currency,
+        kind,
+    ]);
     // Surface an empty source list (e.g. no Coinbase-deliverable chains) for diagnosis.
     useEffect(() => {
         if (!isAvailable || chainsLoading || chains.length > 0)
@@ -95,6 +116,8 @@ function useDepositRoute(kind) {
         pm,
         receiverAddress,
         sameChain,
+        targetUnsupported,
+        railChains,
         status,
         loading,
         error,

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/Deposit/useSameChainArrival.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Watches a wallet's native balance and reports when it increases past the first
+ * observed value — i.e. a same-chain deposit landed. Same-chain "transfer from
+ * address" has no rail session to poll (the deposit address is the wallet
+ * itself), so arrival is read straight from the chain RPC.
+ *
+ * Self-contained single timeout chain (no shared query cache), so it can't fan
+ * out into a request storm: one read in flight at a time, with an interval that
+ * grows on each tick and resets to brisk when the user returns to the tab (the
+ * moment a deposit was likely just made). On arrival, cached balances are
+ * invalidated so the asset list refreshes, and polling stops.
+ */
+export declare function useSameChainArrival({ address, chainId, enabled, }: {
+    address: string;
+    chainId: number;
+    enabled: boolean;
+}): {
+    arrived: boolean;
+};