From e1ec82493d3e7bf52c74a4a1b9fa7363ccafc548 Mon Sep 17 00:00:00 2001
From: Vasanth T <vasanth.dev2004@gmail.com>
Date: Tue, 10 Nov 2026 20:39:47 +0530
Subject: [PATCH] feat(bridge): guide funds in from an exchange

The bridge panel gains a "Funds on an exchange?" link that swaps the form
for a four-step guide: the wallet's address with a copy button, the four
networks to withdraw to (Base, Ethereum, Arbitrum, Optimism), a read-only
watch for the funds to land, and a button that opens the bridge on that
route with the token amount filled in. A token that lands with no ETH
beside it gets a gas warning. Funds that land on the destination itself
are reported as ready.

The watch reads ETH and Circle's USDC on those networks every 15 seconds,
paused while the tab is hidden, and measures arrivals from the lowest
balance seen since it began, so funds already there never count. The
watch and the open guide are kept in session storage for two hours, so
closing the panel or connecting a wallet resumes it without taking focus.

Relay deposit addresses were evaluated for this and stay off: production
addresses are Lit-derived accounts whose derivation inputs are not
returned, so an address cannot be tied to its order. docs/bridge.md
records the findings and the on-chain evidence.
---
 app/src/app/bridge/page.tsx                   |   1 +
 app/src/app/ui-review-bridge/BridgeReview.tsx |  27 ++-
 .../components/bridge/BridgeDialog.module.css |  26 ++-
 app/src/components/bridge/BridgeDialog.tsx    | 157 +++++++++++++++++-
 app/src/components/bridge/bridge-ui.test.ts   |  27 +++
 app/src/components/bridge/useExchangeWatch.ts |  73 ++++++++
 app/src/lib/bridge/exchange.test.ts           | 101 +++++++++++
 app/src/lib/bridge/exchange.ts                | 124 ++++++++++++++
 app/src/lib/bridge/fund.ts                    |  10 +-
 docs/bridge.md                                |  23 ++-
 10 files changed, 557 insertions(+), 12 deletions(-)
 create mode 100644 app/src/components/bridge/useExchangeWatch.ts
 create mode 100644 app/src/lib/bridge/exchange.test.ts
 create mode 100644 app/src/lib/bridge/exchange.ts

diff --git a/app/src/app/bridge/page.tsx b/app/src/app/bridge/page.tsx
index a5940dc7..cf55e98c 100644
--- a/app/src/app/bridge/page.tsx
+++ b/app/src/app/bridge/page.tsx
@@ -79,6 +79,7 @@ export default async function BridgePage({ searchParams }: { searchParams: Promi
             <h2 id="bridge-know">Good to know</h2>
             <ul className={styles.points}>
               <li>Elysium sends USDC only. Its gas token, HYPE, can be received there but not sent, so receive a little HYPE first if you have none to pay gas on Elysium.</li>
+              <li>Funds on an exchange? The panel&apos;s exchange guide shows where to withdraw them (Base, Ethereum, Arbitrum or Optimism), watches for them to land, then opens the bridge on that route.</li>
               <li>Funds go from your wallet to Relay&apos;s deposit contract, or to Circle&apos;s transfer contract on a Circle route. They never pass through an openlaunch wallet or contract.</li>
               <li>Relay and Circle are third parties. openlaunch operates neither and cannot reverse a transfer.</li>
               <li>A transfer is saved in this browser while it is in progress. Reopen the bridge with the same wallet to pick it up.</li>
diff --git a/app/src/app/ui-review-bridge/BridgeReview.tsx b/app/src/app/ui-review-bridge/BridgeReview.tsx
index ab15375c..f8730231 100644
--- a/app/src/app/ui-review-bridge/BridgeReview.tsx
+++ b/app/src/app/ui-review-bridge/BridgeReview.tsx
@@ -3,7 +3,9 @@
 import { useEffect, useState } from "react";
 import { Dialog } from "@base-ui/react/dialog";
 import { X } from "lucide-react";
-import { BridgeForm, Transfer } from "@/components/bridge/BridgeDialog";
+import { BridgeForm, ExchangeGuide, Transfer } from "@/components/bridge/BridgeDialog";
+import { EXCHANGE_IDLE, type ExchangeView } from "@/components/bridge/useExchangeWatch";
+import signal from "@/components/bridge/Signal.module.css";
 import type useBridge from "@/components/bridge/useBridge";
 import { formatUnits, parseEther, parseUnits, zeroAddress } from "viem";
 import { canReverseBridgeRoute, changeBridgeRoute, parseBridgeAmount, type BridgeRouteChange, type BridgeRouteInputs } from "@/lib/bridge/client";
@@ -16,7 +18,7 @@ import { HistoryBoard } from "@/components/bridge/BridgeHistory";
 import type { BridgeHistoryEntry } from "@/lib/bridge/history";
 import { FundCard } from "@/components/bridge/BridgeToBuy";
 import type { BridgeHolding, FundStep } from "@/lib/bridge/fund";
-import type { BridgeAsset, BridgeDestinationId } from "@/lib/bridge/types";
+import type { BridgeAsset, BridgeChainId, BridgeDestinationId } from "@/lib/bridge/types";
 import { CCTP_TOKEN_MESSENGER, cctpRoute } from "@/lib/bridge/cctp";
 
 const wallet = "0x03508bB71268BBA25ECaCC8F620e01866650532c" as const;
@@ -58,6 +60,20 @@ const FUND_SCENES: FundScene[] = [
   { name: "Elysium HYPE, arrived", step: "arrived", destination: 99901, asset: "HYPE", symbol: "KINO", row: HISTORY_ROWS[6], shortBy: null, suggestion: null, searching: false },
 ];
 
+// "From an exchange", one guide per state it can show. Arrivals are synthetic, in real units.
+type ExchangeScene = { name: string; address: typeof wallet | undefined; destinationChainId: BridgeChainId; view: ExchangeView };
+const watching: ExchangeView = { checking: false, unreadable: false, arrivals: [] };
+const EXCHANGE_SCENES: ExchangeScene[] = [
+  { name: "no wallet", address: undefined, destinationChainId: 4663, view: EXCHANGE_IDLE },
+  { name: "watching", address: wallet, destinationChainId: 4663, view: watching },
+  { name: "balances unreadable", address: wallet, destinationChainId: 4663, view: { ...watching, unreadable: true } },
+  { name: "USDC landed, no gas", address: wallet, destinationChainId: 5042, view: { ...watching, arrivals: [{ chainId: 42161, asset: "USDC", amount: 250_000_000n, decimals: 6, gas: 0n }] } },
+  { name: "USDC and ETH landed", address: wallet, destinationChainId: 99901, view: { ...watching, arrivals: [{ chainId: 42161, asset: "USDC", amount: 250_000_000n, decimals: 6, gas: 4_000_000_000_000_000n }, { chainId: 42161, asset: "ETH", amount: 4_000_000_000_000_000n, decimals: 18, gas: null }] } },
+  { name: "landed on Base, wanted on Base", address: wallet, destinationChainId: 8453, view: { ...watching, arrivals: [{ chainId: 8453, asset: "USDC", amount: 100_000_000n, decimals: 6, gas: 2_000_000_000_000_000n }] } },
+];
+// the dialog's guide: 25 USDC on Arbitrum with no ETH beside it, so its button opens the bridge on that route
+const DIALOG_EXCHANGE: ExchangeView = { ...watching, arrivals: [{ chainId: 42161, asset: "USDC", amount: 25_000_000n, decimals: 6, gas: 0n }] };
+
 export default function BridgeReview() {
   const [historyScene, setHistoryScene] = useState<HistoryScene>("rows");
   const [open, setOpen] = useState(false);
@@ -134,7 +150,7 @@ export default function BridgeReview() {
         <Dialog.Portal><Dialog.Backdrop className={styles.backdrop} /><Dialog.Popup className={styles.panel} initialFocus={false}>
           <div className={styles.heading}><Dialog.Title className={styles.title}>Bridge</Dialog.Title><Dialog.Close className={styles.close} aria-label="Close preview"><X size={19} /></Dialog.Close></div>
           <Dialog.Description className={styles.description}>Preview only · {scene} · no funds move</Dialog.Description>
-          {tracking ? <Transfer bridge={bridge} /> : <BridgeForm bridge={bridge} connect={() => setScene("quote")} />}
+          {tracking ? <Transfer bridge={bridge} /> : <BridgeForm bridge={bridge} connect={() => setScene("quote")} exchangeView={DIALOG_EXCHANGE} />}
           <div className={styles.footer}><span>{viaCircle ? "Powered by Circle CCTP" : "Powered by Relay"}</span><span>0 Openlaunch fee</span></div>
         </Dialog.Popup></Dialog.Portal>
       </Dialog.Root>
@@ -147,6 +163,11 @@ export default function BridgeReview() {
       <div className="mt-6 grid gap-6 [grid-template-columns:repeat(auto-fill,minmax(min(100%,340px),1fr))]">
         {FUND_SCENES.map(({ name, ...scene }) => <figure key={name} className="m-0 grid min-w-0 content-start gap-2"><figcaption className="text-xs text-muted">{name}</figcaption><FundCard {...scene} onBridge={() => {}} onOpen={() => {}} onDismiss={() => {}} /></figure>)}
       </div>
+      <h2 className="mt-16 text-lg font-semibold">From an exchange</h2>
+      <p className="mt-2 text-sm text-body">The bridge panel&apos;s guide, at panel width. No balances are read here and buttons do nothing.</p>
+      <div className="mt-6 grid gap-6 [grid-template-columns:repeat(auto-fill,minmax(min(100%,400px),1fr))]">
+        {EXCHANGE_SCENES.map(({ name, ...scene }) => <figure key={name} className="m-0 grid min-w-0 content-start gap-2"><figcaption className="text-xs text-muted">{name}</figcaption><div className={signal.pagePanel}><ExchangeGuide {...scene} onBridge={() => {}} onBack={() => {}} onConnect={() => {}} /></div></figure>)}
+      </div>
     </div>
     </>
   );
diff --git a/app/src/components/bridge/BridgeDialog.module.css b/app/src/components/bridge/BridgeDialog.module.css
index 929cd503..e416b18d 100644
--- a/app/src/components/bridge/BridgeDialog.module.css
+++ b/app/src/components/bridge/BridgeDialog.module.css
@@ -35,6 +35,29 @@
 .walletHint { display: block; width: 100%; margin-top: 12px; padding: 9px 12px; border: 1px dashed var(--color-line-strong); border-radius: 10px; color: var(--color-body); font-size: 12px; text-align: left; cursor: pointer; transition: color 160ms, background 160ms; }
 .walletHint:not(:disabled):hover { color: var(--color-ink); background: var(--color-paper); }
 .walletHint:disabled { cursor: default; opacity: .6; }
+.exchangeLink { display: block; margin-top: 10px; padding: 2px 0; color: var(--color-brand); font-size: 12px; text-align: left; cursor: pointer; }
+.exchangeLink:disabled { color: var(--color-muted); cursor: default; }
+.guide { display: grid; min-width: 0; }
+.guideBack { display: inline-flex; align-items: center; gap: 6px; justify-self: start; min-height: 32px; margin: -4px 0 10px; padding: 0 2px; border-radius: 6px; color: var(--color-body); font-size: 12px; cursor: pointer; }
+.guideTitle { margin: 0; font-size: 18px; line-height: 1.3; letter-spacing: -.02em; font-weight: 600; text-wrap: balance; }
+.guideTitle:focus { outline: none; }
+.guideLead { margin: 6px 0 0; color: var(--color-body); font-size: 13px; line-height: 1.6; }
+.guide .steps { margin: 22px 0 6px; }
+.guide .steps li > div { flex: 1; min-width: 0; }
+.guideAddress { display: block; margin-top: 8px; padding: 10px 12px; border: 1px solid var(--color-line); border-radius: 10px; background: var(--color-paper); color: var(--color-ink); font-family: var(--font-mono); font-size: 11px; line-height: 1.6; overflow-wrap: anywhere; user-select: all; }
+.guideButton { display: inline-flex; align-items: center; gap: 6px; min-height: 36px; margin-top: 8px; padding: 0 12px; border: 1px solid var(--color-line-strong); border-radius: 999px; color: var(--color-ink); font-size: 12px; font-weight: 500; cursor: pointer; transition: background 160ms; }
+.guideNetworks { display: grid; margin-top: 6px; }
+.guideNetworks > div { display: grid; grid-template-columns: 30px minmax(0, 1fr) auto; align-items: center; gap: 10px; min-height: 46px; border-bottom: 1px solid var(--color-line); }
+.guideNetworks > div:last-child { border-bottom: 0; }
+.guideTag { color: var(--color-muted); font-size: 11px; font-style: normal; white-space: nowrap; }
+.guideTag[data-ready] { color: var(--color-up); }
+.guideStatus { display: flex; align-items: flex-start; gap: 6px; margin: 4px 0 0; color: var(--color-body); font-size: 12px; line-height: 1.55; }
+.guideStatus svg { flex-shrink: 0; margin-top: 3px; color: var(--color-brand); }
+.guideArrival { display: grid; gap: 8px; margin-top: 10px; }
+.guideArrival > p { margin: 0; color: var(--color-body); font-size: 12px; line-height: 1.6; }
+.guideArrival :is(.primary, .secondary) { margin: 0; font-size: 13px; }
+.guideGas { display: flex; align-items: flex-start; gap: 8px; margin: 0; padding: 10px 12px; border-radius: 8px; background: var(--color-warm-soft); color: var(--color-warm-ink); font-size: 12px; line-height: 1.6; }
+.guideGas svg { flex-shrink: 0; margin-top: 2px; }
 .networkOption { display: grid; grid-template-columns: 30px minmax(0, 1fr) 20px; align-items: center; gap: 12px; min-height: 64px; padding: 10px; border-radius: 10px; cursor: pointer; outline: none; user-select: none; }
 .networkOption[data-highlighted] { background: var(--color-paper); box-shadow: inset 0 0 0 1px var(--color-line-strong); }
 .networkOption[data-selected] { background: var(--color-brand-soft); }
@@ -155,7 +178,8 @@
 @media (hover: hover) and (pointer: fine) {
   .networkTrigger:not(:disabled):hover { background: var(--color-paper); border-color: var(--color-line); }
   .assetTrigger:not(:disabled):hover { border-color: var(--color-brand); }
-  .close:hover, .reverse:hover, .externalAction:hover { color: var(--color-ink); background: var(--color-paper); }
+  .close:hover, .reverse:hover, .externalAction:hover, .guideButton:hover { color: var(--color-ink); background: var(--color-paper); }
+  .guideBack:hover, .exchangeLink:not(:disabled):hover { color: var(--color-ink); text-decoration: underline; }
   .trigger:hover { color: var(--color-ink); background: var(--color-line); }
   .primary:not(:disabled):hover { background: var(--color-brand-strong); }
   .footer a:hover, .explorerLinks a:hover { text-decoration: underline; }
diff --git a/app/src/components/bridge/BridgeDialog.tsx b/app/src/components/bridge/BridgeDialog.tsx
index e582cd48..1ec725f1 100644
--- a/app/src/components/bridge/BridgeDialog.tsx
+++ b/app/src/components/bridge/BridgeDialog.tsx
@@ -6,20 +6,23 @@ import Image from "next/image";
 import Link from "next/link";
 import { Dialog } from "@base-ui/react/dialog";
 import { Select } from "@base-ui/react/select";
-import { ArrowLeftRight, Coins, ArrowRight, ArrowUpRight, Check, ChevronDown, ChevronRight, CircleAlert, CircleDollarSign, Clock3, LoaderCircle, Wallet, X } from "lucide-react";
-import { formatEther, formatUnits, zeroAddress } from "viem";
-import { BRIDGE_ASSET_NAMES, BRIDGE_CHAINS, BRIDGE_CHAIN_IDS, BRIDGE_DESTINATION_IDS, bridgeCurrency, bridgeAssets, bridgeProviderName, bridgeTokenAsset, bridgeTransferInputCurrency, isBridgeAssetSupported, isBridgeChainId, isBridgeFundingChain, type BridgeAsset, type BridgeChainId, type BridgeQuoteRejection } from "@/lib/bridge/types";
+import { ArrowLeft, ArrowLeftRight, Coins, ArrowRight, ArrowUpRight, Check, ChevronDown, ChevronRight, CircleAlert, CircleDollarSign, Clock3, Copy, LoaderCircle, Wallet, X } from "lucide-react";
+import { formatEther, formatUnits, zeroAddress, type Address } from "viem";
+import { BRIDGE_ASSET_NAMES, BRIDGE_CHAINS, BRIDGE_SEND_ASSETS, BRIDGE_CHAIN_IDS, BRIDGE_DESTINATION_IDS, bridgeCurrency, bridgeAssets, bridgeProviderName, bridgeTokenAsset, bridgeTransferInputCurrency, isBridgeAssetSupported, isBridgeChainId, isBridgeFundingChain, type BridgeAsset, type BridgeChainId, type BridgeQuoteRejection } from "@/lib/bridge/types";
 import { DISCARD_AFTER_MS } from "@/lib/bridge/client";
 import { CCTP_APPROVAL_SPENDER } from "@/lib/bridge/approval";
 import { bridgeLinkKey, type BridgeLink } from "@/lib/bridge/link";
 import { signalCaption, signalMode } from "@/lib/bridge/signal";
 import { formatFeeWarningPercent } from "@/lib/bridge/fee-display";
+import { EXCHANGE_NETWORKS, EXCHANGE_OPEN_KEY, EXCHANGE_POLL_MS, exchangeGuideOpen, exchangeNeedsGas, exchangeNext, type ExchangeArrival } from "@/lib/bridge/exchange";
+import { formatFundAmount } from "@/lib/bridge/fund";
 import { shortAddr } from "@/lib/chainPublic";
 import WalletPicker from "../WalletPicker";
 import WalletAvatar from "../WalletAvatar";
 import useBridge from "./useBridge";
 import SignalBoard from "./SignalBoard";
 import SlideConfirm from "./SlideConfirm";
+import useExchangeWatch, { clearExchangeWatch, type ExchangeView } from "./useExchangeWatch";
 import { dotFont } from "./dot-font";
 import styles from "./BridgeDialog.module.css";
 import signal from "./Signal.module.css";
@@ -244,8 +247,41 @@ export default function BridgeDialog({ open, onOpenChange, restoreFocus, slot =
   );
 }
 
-export function BridgeForm({ bridge: b, connect }: { bridge: Bridge; connect: () => void }) {
+/**
+ * `exchangeView` stands in for the live balance watch in the development fixture, so its guide never reads a network.
+ */
+export function BridgeForm({ bridge: b, connect, exchangeView }: { bridge: Bridge; connect: () => void; exchangeView?: ExchangeView }) {
+  // "opened" from the form's link takes focus; "resumed" (left open in this tab: the panel closed while waiting, or a
+  // wallet connected from it) does not, so reopening the panel or loading /bridge never jumps to it
+  const [guide, setGuide] = useState<false | "opened" | "resumed">(false);
+  useEffect(() => {
+    const resume = () => { try { if (exchangeGuideOpen(window.sessionStorage.getItem(EXCHANGE_OPEN_KEY), Date.now())) setGuide((open) => open || "resumed"); } catch { /* not kept */ } };
+    resume();
+  }, []);
   if (b.approval && (b.approval.status === "pending" || b.approval.status === "uncertain")) return <ApprovalProgress bridge={b} />;
+  const openGuide = () => {
+    try { window.sessionStorage.setItem(EXCHANGE_OPEN_KEY, String(Date.now())); } catch { /* open for this view only */ }
+    setGuide("opened");
+  };
+  // back in the form, focus lands where the guide left off: its link, or the amount it filled in
+  const closeGuide = (focus: "bridge-exchange-link" | "bridge-amount") => {
+    clearExchangeWatch();
+    setGuide(false);
+    window.requestAnimationFrame(() => document.getElementById(focus)?.focus());
+  };
+  if (guide) {
+    const bridgeFrom = (arrival: ExchangeArrival) => {
+      const next = exchangeNext(arrival, b.destinationChainId);
+      if (next.kind === "bridge") {
+        b.setOriginChainId(next.originChainId);
+        b.setOriginAsset(next.originAsset);
+        if (next.amount) b.setAmount(next.amount);
+      }
+      closeGuide(next.kind === "bridge" ? "bridge-amount" : "bridge-exchange-link");
+    };
+    const props = { address: b.address, destinationChainId: b.destinationChainId, focusOnMount: guide === "opened", onBridge: bridgeFrom, onBack: () => closeGuide("bridge-exchange-link"), onConnect: connect };
+    return exchangeView ? <ExchangeGuide {...props} view={exchangeView} /> : <LiveExchangeGuide {...props} />;
+  }
   const locked = b.busy || b.approvalBusy;
   const loading = locked || b.quoteLoading;
   const reviewing = !!b.quote && !b.quoteExpired;
@@ -306,6 +342,7 @@ export function BridgeForm({ bridge: b, connect }: { bridge: Bridge; connect: ()
         </div>
         <p id="bridge-balance" className={styles.balance}>{!b.address ? `${inputCurrency.symbol} on ${origin.name}` : b.balanceLoading ? "Checking your balance…" : b.balance !== undefined ? `Available: ${nativeAmount(formatUnits(b.balance, inputCurrency.decimals))} ${inputCurrency.symbol}` : b.balanceError ?? "Balance unavailable"}</p>
         {b.address && erc20Input && b.originChainId !== 5042 && b.nativeBalance !== undefined ? <p className={styles.balance}>For gas: {nativeAmount(b.nativeBalance)} {origin.symbol}</p> : null}
+        {!reviewing ? <button type="button" id="bridge-exchange-link" className={styles.exchangeLink} disabled={locked} onClick={openGuide}>Funds on an exchange? Withdraw them to this wallet first</button> : null}
       </div>
 
       <div className={styles.destinationAsset}><span className={styles.smallLabel}>Receive on {destination.name}</span><AssetSelect label="Receive" chain={b.destinationChainId} asset={b.destinationAsset} disabled={locked} onChange={b.setDestinationAsset} /></div>
@@ -349,6 +386,118 @@ export function BridgeForm({ bridge: b, connect }: { bridge: Bridge; connect: ()
   );
 }
 
+type ExchangeGuideProps = { address: Address | undefined; destinationChainId: BridgeChainId; focusOnMount?: boolean; onBridge: (arrival: ExchangeArrival) => void; onBack: () => void; onConnect: () => void };
+
+function LiveExchangeGuide(props: ExchangeGuideProps) {
+  const view = useExchangeWatch(props.address);
+  return <ExchangeGuide {...props} view={view} />;
+}
+
+/**
+ * From an exchange (lib/bridge/exchange.ts): where to withdraw, a read-only watch for the funds to land, then the bridge
+ * on that route. Plain props, so the development fixture can show every state without a wallet or a network.
+ */
+export function ExchangeGuide({ address, destinationChainId, focusOnMount = false, view, onBridge, onBack, onConnect }: ExchangeGuideProps & { view: ExchangeView }) {
+  const [copied, setCopied] = useState(false);
+  const addressRef = useRef<HTMLElement>(null);
+  const backRef = useRef<HTMLButtonElement>(null);
+  const titleRef = useRef<HTMLHeadingElement>(null);
+  // the guide replaces the form in place: bring its top into view and move focus to its title
+  useEffect(() => {
+    if (!focusOnMount) return;
+    backRef.current?.scrollIntoView({ block: "nearest" });
+    titleRef.current?.focus({ preventScroll: true });
+  }, [focusOnMount]);
+  const destination = BRIDGE_CHAINS[destinationChainId].name;
+  // nothing is watched without a wallet, whatever the view says
+  const arrivals = address ? view.arrivals : [];
+  const landed = arrivals.length > 0;
+  const firstBridge = arrivals.find((arrival) => exchangeNext(arrival, destinationChainId).kind === "bridge");
+  const names = EXCHANGE_NETWORKS.map((id) => BRIDGE_CHAINS[id].name);
+  const watched = `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}`;
+  const seconds = EXCHANGE_POLL_MS / 1000;
+  const amountOf = (arrival: ExchangeArrival) => `${formatFundAmount(arrival.amount, arrival.decimals)} ${arrival.asset}`;
+
+  async function copy() {
+    if (!address) return;
+    try {
+      await navigator.clipboard.writeText(address);
+      setCopied(true);
+      window.setTimeout(() => setCopied(false), 2000);
+    } catch {
+      // no clipboard here: select the address so it can be copied by hand
+      const node = addressRef.current;
+      const selection = window.getSelection();
+      if (!node || !selection) return;
+      const range = document.createRange();
+      range.selectNodeContents(node);
+      selection.removeAllRanges();
+      selection.addRange(range);
+    }
+  }
+
+  return (
+    <div className={styles.guide}>
+      <button ref={backRef} type="button" className={styles.guideBack} onClick={onBack}><ArrowLeft size={14} aria-hidden />Back to the bridge</button>
+      <h3 ref={titleRef} tabIndex={-1} className={styles.guideTitle}>From an exchange</h3>
+      <p className={styles.guideLead}>{destinationChainId === 8453
+        ? "Withdraw ETH or USDC from your exchange to this wallet on Base and it is ready to use. Withdrawn to one of the other networks below, it can be bridged to Base after."
+        : `Withdraw ETH or USDC from your exchange to this wallet on one of the networks below, then bridge it to ${destination}.`}</p>
+      <ol className={styles.steps}>
+        <li><span>1</span><div>
+          <strong>Use this wallet&apos;s address</strong>
+          {address ? <>
+            <code ref={addressRef} className={styles.guideAddress}>{address}</code>
+            <button type="button" className={styles.guideButton} onClick={() => void copy()}>{copied ? <Check size={14} aria-hidden /> : <Copy size={14} aria-hidden />}{copied ? "Copied" : "Copy address"}</button>
+            <span className="sr-only" role="status">{copied ? "Address copied" : ""}</span>
+            <small>Paste it as the withdrawal address on the exchange. Some smart wallets work only on some networks, so pick one your wallet supports.</small>
+          </> : <>
+            <small>Connect a wallet to see the address to withdraw to.</small>
+            <button type="button" className={styles.guideButton} onClick={onConnect}><Wallet size={14} aria-hidden />Connect wallet</button>
+          </>}
+        </div></li>
+        <li><span>2</span><div>
+          <strong>Withdraw on one of these networks</strong>
+          <div className={styles.guideNetworks}>
+            {EXCHANGE_NETWORKS.map((id) => <div key={id}>
+              <NetworkMark chain={id} />
+              <span className={styles.networkCopy}><span className={styles.networkName}>{BRIDGE_CHAINS[id].name}</span><span className={styles.gasCurrency}>{BRIDGE_SEND_ASSETS[id].join(" or ")}</span></span>
+              <em className={styles.guideTag} data-ready={id === destinationChainId || undefined}>{id === destinationChainId ? "No bridge needed" : "Then bridge"}</em>
+            </div>)}
+          </div>
+          <small>Pick one your exchange lists for that token. For USDC, choose USDC itself, not USDC.e or another bridged version: the bridge sends only Circle&apos;s USDC. Bridging USDC from there takes a little ETH on that network for gas, so withdraw some ETH there too.</small>
+        </div></li>
+        <li data-complete={landed}><span>{landed ? <Check size={13} aria-hidden /> : "3"}</span><div>
+          <strong>{landed ? "Landed in your wallet" : "Wait for it to land"}</strong>
+          <p className={styles.guideStatus} role="status">
+            {address && !landed && !view.unreadable ? <LoaderCircle size={13} className={styles.spinner} aria-hidden /> : null}
+            <span>{!address ? "Starts once a wallet is connected."
+              : view.checking ? "Checking your balances…"
+              : view.unreadable ? `Could not read your balances. Trying again every ${seconds} seconds.`
+              : landed ? `${arrivals.map((arrival) => `${amountOf(arrival)} on ${BRIDGE_CHAINS[arrival.chainId].name}`).join(", ")}.`
+              : `Watching ${watched} every ${seconds} seconds. You can close the panel and reopen it in this tab to keep watching.`}</span>
+          </p>
+        </div></li>
+        <li><span>4</span><div>
+          <strong>{destinationChainId === 8453 ? "Bridge it to Base if it landed elsewhere" : `Bridge it to ${destination}`}</strong>
+          {!landed ? <small>Once it lands, the bridge opens on that route.</small> : arrivals.map((arrival) => {
+            const from = BRIDGE_CHAINS[arrival.chainId].name;
+            return <div key={`${arrival.chainId}:${arrival.asset}`} className={styles.guideArrival}>
+              {exchangeNext(arrival, destinationChainId).kind === "ready"
+                ? <p>{amountOf(arrival)} is on {from}, ready to use. No bridge needed.</p>
+                : <>
+                  <button type="button" className={arrival === firstBridge ? styles.primary : styles.secondary} onClick={() => onBridge(arrival)}>Bridge {amountOf(arrival)} from {from}<ArrowRight size={17} aria-hidden /></button>
+                  {exchangeNeedsGas(arrival) ? <p className={styles.guideGas} role="status"><CircleAlert size={15} aria-hidden /><span>There is no ETH on {from} to pay gas for sending {arrival.asset}. Withdraw a little ETH to {from} as well. This updates when it lands.</span></p> : null}
+                </>}
+            </div>;
+          })}
+        </div></li>
+      </ol>
+      <p className={styles.disclaimer}>The exchange sends to your wallet and sets its own withdrawal fees, limits and timing. This guide only reads your balances. It never asks your wallet for anything, and openlaunch never holds your funds.</p>
+    </div>
+  );
+}
+
 function ApprovalProgress({ bridge: b }: { bridge: Bridge }) {
   const approval = b.approval!;
   const approvalChain = BRIDGE_CHAINS[approval.chainId];
diff --git a/app/src/components/bridge/bridge-ui.test.ts b/app/src/components/bridge/bridge-ui.test.ts
index 5f22c7e5..7916a5ac 100644
--- a/app/src/components/bridge/bridge-ui.test.ts
+++ b/app/src/components/bridge/bridge-ui.test.ts
@@ -315,3 +315,30 @@ test("a Circle transfer is named as Circle's, reads allowance for Circle's spend
   assert.match(board, /entry\.provider === "cctp" \? <span className=\{styles\.via\}>Circle<\/span> : <a href=\{\x60https:\/\/relay\.link\/transaction\//);
   assert.doesNotMatch(panel, /—/);
 });
+
+test("from an exchange: the guide only reads balances, opens the bridge on a checked route, and never offers a deposit address", () => {
+  const watch = read("./useExchangeWatch.ts");
+  const lib = read("../../lib/bridge/exchange.ts");
+  const review = read("../../app/ui-review-bridge/BridgeReview.tsx");
+  const guide = panel.slice(panel.indexOf("export function ExchangeGuide"), panel.indexOf("function ApprovalProgress"));
+  // read-only: balances through the public clients, nothing that signs, sends or switches
+  for (const source of [watch, lib, guide]) assert.doesNotMatch(source, /sendTransaction|writeContract|useWriteContract|getWalletClient|switchChain|signMessage|signTypedData|fetch\(/);
+  assert.ok(watch.includes("getBalance({ address: who })") && watch.includes('functionName: "balanceOf"'));
+  assert.ok(watch.includes("if (!document.hidden)"), "no reads while the tab is hidden");
+  // the form's link opens it; a guide left open in this tab comes back without taking focus
+  assert.ok(panel.includes('<button type="button" id="bridge-exchange-link" className={styles.exchangeLink} disabled={locked} onClick={openGuide}>Funds on an exchange? Withdraw them to this wallet first</button>'));
+  assert.ok(panel.includes('setGuide((open) => open || "resumed")') && panel.includes('focusOnMount: guide === "opened"'));
+  // an arrival opens the bridge through the same guarded setters the pickers use, then ends the watch
+  assert.match(panel, /b\.setOriginChainId\(next\.originChainId\);\s*b\.setOriginAsset\(next\.originAsset\);\s*if \(next\.amount\) b\.setAmount\(next\.amount\);/);
+  assert.ok(panel.includes("const closeGuide = (focus") && panel.includes("clearExchangeWatch();"));
+  assert.ok(guide.includes("exchangeNeedsGas(arrival)"), "a token with no gas beside it is called out");
+  assert.ok(guide.includes("not USDC.e or another bridged version"));
+  assert.ok(guide.includes("navigator.clipboard.writeText(address)") && guide.includes("selection.addRange(range)"), "copy falls back to selecting the address");
+  // the fixture shows the guide from plain props and never starts the live watch
+  assert.doesNotMatch(review, /useExchangeWatch\(/);
+  assert.ok(review.includes("exchangeView={DIALOG_EXCHANGE}"));
+  // Relay deposit addresses stay off: never requested, and a quote carrying one is still refused
+  assert.doesNotMatch(read("../../lib/bridge/relay.ts"), /useDepositAddress/);
+  assert.ok(read("../../lib/bridge/validation.ts").includes('step.kind === "transaction" && isRequestId(step.requestId) && !step.depositAddress'));
+  assert.doesNotMatch(guide, /—/);
+});
diff --git a/app/src/components/bridge/useExchangeWatch.ts b/app/src/components/bridge/useExchangeWatch.ts
new file mode 100644
index 00000000..0af79e5b
--- /dev/null
+++ b/app/src/components/bridge/useExchangeWatch.ts
@@ -0,0 +1,73 @@
+"use client";
+
+import { useEffect, useRef, useState } from "react";
+import { useConfig } from "wagmi";
+import { getPublicClient } from "wagmi/actions";
+import { erc20Abi, type Address } from "viem";
+import type { BridgeHolding, HoldingReader } from "@/lib/bridge/fund";
+import { EXCHANGE_OPEN_KEY, EXCHANGE_POLL_MS, EXCHANGE_WATCH_KEY, findExchangeArrivals, nextExchangeBaseline, parseExchangeWatch, readExchangeHoldings, serializeExchangeWatch, type ExchangeArrival, type ExchangeWatch } from "@/lib/bridge/exchange";
+import type { BridgeChainId } from "@/lib/bridge/types";
+
+/** What the guide shows about the watch: whether a first read is still out, whether reads fail, and what landed. */
+export type ExchangeView = { checking: boolean; unreadable: boolean; arrivals: ExchangeArrival[] };
+export const EXCHANGE_IDLE: ExchangeView = { checking: false, unreadable: false, arrivals: [] };
+
+type Reading = { wallet: string; watch: ExchangeWatch; holdings: BridgeHolding[] };
+
+function savedWatch(wallet: string, now: number): ExchangeWatch | null {
+  try { return parseExchangeWatch(window.sessionStorage.getItem(EXCHANGE_WATCH_KEY), wallet, now); } catch { return null; }
+}
+
+/**
+ * Reads the wallet's ETH and USDC on the exchange networks every few seconds while the guide is open, read-only, and
+ * keeps the lowest balance seen in this tab so that what lands later stands out. Paused while the tab is hidden.
+ */
+export default function useExchangeWatch(address: Address | undefined): ExchangeView {
+  const config = useConfig();
+  const wallet = address?.toLowerCase() ?? "";
+  const [reading, setReading] = useState<Reading | null>(null);
+  const watchRef = useRef<ExchangeWatch | null>(null);
+
+  useEffect(() => {
+    if (!address) return;
+    const key = address.toLowerCase();
+    let stopped = false;
+    let timer = 0;
+    const client = (id: BridgeChainId) => {
+      const pub = getPublicClient(config, { chainId: id });
+      if (!pub) throw new Error("no client");
+      return pub;
+    };
+    const read: HoldingReader = {
+      native: async (id, who) => client(id).getBalance({ address: who }),
+      token: async (id, token, who) => client(id).readContract({ address: token, abi: erc20Abi, functionName: "balanceOf", args: [who] }),
+    };
+    const tick = async () => {
+      if (!document.hidden) {
+        const holdings = await readExchangeHoldings(read, address);
+        if (stopped) return;
+        const now = Date.now();
+        const saved = watchRef.current?.wallet === key ? watchRef.current : savedWatch(key, now) ?? { wallet: key, startedAt: now, baseline: {} };
+        const watch = { ...saved, baseline: nextExchangeBaseline(saved.baseline, holdings) };
+        watchRef.current = watch;
+        try { window.sessionStorage.setItem(EXCHANGE_WATCH_KEY, serializeExchangeWatch(watch)); } catch { /* watched for this view only */ }
+        setReading({ wallet: key, watch, holdings });
+      }
+      if (!stopped) timer = window.setTimeout(() => void tick(), EXCHANGE_POLL_MS);
+    };
+    void tick();
+    return () => { stopped = true; window.clearTimeout(timer); };
+  }, [address, config]);
+
+  if (!wallet) return EXCHANGE_IDLE;
+  if (reading?.wallet !== wallet) return { checking: true, unreadable: false, arrivals: [] };
+  return { checking: false, unreadable: reading.holdings.length === 0, arrivals: findExchangeArrivals(reading.watch.baseline, reading.holdings) };
+}
+
+/** Ends the watch: the guide was closed on purpose, or its funds were taken to the bridge. */
+export function clearExchangeWatch() {
+  try {
+    window.sessionStorage.removeItem(EXCHANGE_WATCH_KEY);
+    window.sessionStorage.removeItem(EXCHANGE_OPEN_KEY);
+  } catch { /* nothing kept */ }
+}
diff --git a/app/src/lib/bridge/exchange.test.ts b/app/src/lib/bridge/exchange.test.ts
new file mode 100644
index 00000000..a1060cfd
--- /dev/null
+++ b/app/src/lib/bridge/exchange.test.ts
@@ -0,0 +1,101 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import type { Address } from "viem";
+import { EXCHANGE_NETWORKS, EXCHANGE_WATCH_MS, exchangeGuideOpen, exchangeNeedsGas, exchangeNext, findExchangeArrivals, nextExchangeBaseline, parseExchangeWatch, readExchangeHoldings, serializeExchangeWatch, type ExchangeArrival } from "./exchange.ts";
+import type { BridgeHolding } from "./fund.ts";
+import { ARBITRUM_USDC, BASE_USDC, BRIDGE_SEND_ASSETS, ETHEREUM_USDC, OPTIMISM_USDC, isBridgeAssetSupported, type BridgeChainId } from "./types.ts";
+
+const WALLET = "0x1111111111111111111111111111111111111111" as Address;
+const eth = (chainId: BridgeChainId, value: number): BridgeHolding => ({ chainId, asset: "ETH", amount: BigInt(Math.round(value * 1e6)) * 10n ** 12n, decimals: 18 });
+const usdc = (chainId: BridgeChainId, value: number): BridgeHolding => ({ chainId, asset: "USDC", amount: BigInt(Math.round(value * 1e6)), decimals: 6 });
+
+test("withdrawals are pointed only at networks the bridge sends ETH and USDC from, Base first", () => {
+  assert.deepEqual([...EXCHANGE_NETWORKS], [8453, 1, 42161, 10]);
+  // each sends ETH and USDC, so every route out of it is one of the send-by-receive pairs the bridge checks live
+  for (const id of EXCHANGE_NETWORKS) {
+    assert.deepEqual([...BRIDGE_SEND_ASSETS[id]], ["ETH", "USDC"], `${id} sends ETH and USDC`);
+    for (const asset of BRIDGE_SEND_ASSETS[id]) assert.ok(isBridgeAssetSupported(id, asset, "input"));
+  }
+  // Robinhood Chain, Arc and Elysium are never suggested as a withdrawal network
+  for (const id of [4663, 5042, 99901]) assert.ok(!(EXCHANGE_NETWORKS as readonly number[]).includes(id), String(id));
+});
+
+test("the watch reads ETH and Circle's USDC on those four networks only, each read standing alone", async () => {
+  const native: number[] = [];
+  const tokens: string[] = [];
+  const holdings = await readExchangeHoldings({
+    native: async (chainId) => { native.push(chainId); if (chainId === 1) throw new Error("rpc down"); return 10n ** 16n; },
+    token: async (chainId, token) => { tokens.push(`${chainId}:${token}`); return 5_000_000n; },
+  }, WALLET);
+  assert.deepEqual([...native].sort(), [1, 10, 42161, 8453].sort());
+  assert.deepEqual(tokens.sort(), [`8453:${BASE_USDC}`, `1:${ETHEREUM_USDC}`, `42161:${ARBITRUM_USDC}`, `10:${OPTIMISM_USDC}`].sort(), "never USDC.e");
+  // Ethereum's ETH did not answer: it is left out, never counted as empty, and its USDC still counts
+  assert.equal(holdings.find((h) => h.chainId === 1 && h.asset === "ETH"), undefined);
+  assert.equal(holdings.find((h) => h.chainId === 1 && h.asset === "USDC")?.amount, 5_000_000n);
+  assert.equal(holdings.length, 7);
+});
+
+test("the baseline starts at what is already there and only ever comes down", () => {
+  const first = nextExchangeBaseline({}, [usdc(42161, 40), eth(42161, 0.01)]);
+  assert.deepEqual(first, { "42161:USDC": 40_000_000n, "42161:ETH": 10n ** 16n });
+  // a rise keeps the baseline, a drop lowers it, and a network read for the first time starts where it stands
+  const next = nextExchangeBaseline(first, [usdc(42161, 65), eth(42161, 0.004), usdc(10, 3)]);
+  assert.deepEqual(next, { "42161:USDC": 40_000_000n, "42161:ETH": 4n * 10n ** 15n, "10:USDC": 3_000_000n });
+  // a network that did not answer keeps its baseline
+  assert.deepEqual(nextExchangeBaseline(next, []), next);
+});
+
+test("an arrival is a rise worth a bridge fee, with the ETH beside it as its gas", () => {
+  const baseline = nextExchangeBaseline({}, [usdc(42161, 40), eth(42161, 0), usdc(8453, 2), eth(8453, 0.01), usdc(10, 0), eth(10, 0)]);
+  // funds already there never count
+  assert.deepEqual(findExchangeArrivals(baseline, [usdc(42161, 40), eth(42161, 0), usdc(8453, 2), eth(8453, 0.01)]), []);
+  const now = [usdc(42161, 290), eth(42161, 0), usdc(8453, 2.5), eth(8453, 0.01), usdc(10, 0), eth(10, 0.0002)];
+  // 250 USDC on Arbitrum with no ETH there; half a dollar on Base and 0.0002 ETH on Optimism are dust
+  assert.deepEqual(findExchangeArrivals(baseline, now), [{ chainId: 42161, asset: "USDC", amount: 250_000_000n, decimals: 6, gas: 0n }]);
+  // a network read for the first time is a baseline, not an arrival
+  assert.deepEqual(findExchangeArrivals(nextExchangeBaseline(baseline, [usdc(1, 500)]), [usdc(1, 500)]), []);
+});
+
+test("a token comes before the ETH that landed beside it, and networks keep their order", () => {
+  const baseline = nextExchangeBaseline({}, [usdc(42161, 0), eth(42161, 0), usdc(8453, 0), eth(1, 0)]);
+  const arrivals = findExchangeArrivals(baseline, [eth(42161, 0.004), usdc(42161, 250), eth(1, 0.05), usdc(8453, 10)]);
+  assert.deepEqual(arrivals.map((a) => `${a.chainId}:${a.asset}`), ["8453:USDC", "1:ETH", "42161:USDC", "42161:ETH"]);
+  assert.equal(arrivals[2].gas, 4n * 10n ** 15n, "the withdrawn ETH pays the USDC's gas");
+  assert.equal(arrivals[3].gas, null, "ETH needs no gas of its own");
+  // Base's USDC with no ETH read on Base: unknown, so no warning
+  assert.equal(arrivals[0].gas, null);
+  assert.deepEqual(arrivals.map(exchangeNeedsGas), [false, false, false, false]);
+  assert.equal(exchangeNeedsGas({ chainId: 10, asset: "USDC", amount: 1n, decimals: 6, gas: 0n }), true);
+});
+
+test("an arrival opens the bridge from where it landed, or needs nothing when it landed where it is wanted", () => {
+  const onArbitrum: ExchangeArrival = { chainId: 42161, asset: "USDC", amount: 25_500_000n, decimals: 6, gas: 0n };
+  assert.deepEqual(exchangeNext(onArbitrum, 5042), { kind: "bridge", originChainId: 42161, originAsset: "USDC", amount: "25.5" });
+  // ETH is left for the sender to size, since some of it pays the gas
+  assert.deepEqual(exchangeNext({ chainId: 1, asset: "ETH", amount: 5n * 10n ** 16n, decimals: 18, gas: null }, 4663), { kind: "bridge", originChainId: 1, originAsset: "ETH", amount: "" });
+  assert.deepEqual(exchangeNext({ chainId: 8453, asset: "USDC", amount: 100_000_000n, decimals: 6, gas: null }, 8453), { kind: "ready" });
+  assert.deepEqual(exchangeNext({ chainId: 8453, asset: "USDC", amount: 100_000_000n, decimals: 6, gas: null }, 99901), { kind: "bridge", originChainId: 8453, originAsset: "USDC", amount: "100" });
+});
+
+test("a saved watch comes back only for its wallet, while fresh, and exactly as saved", () => {
+  const now = Date.UTC(2026, 10, 10, 12, 0);
+  const watch = { wallet: WALLET.toLowerCase(), startedAt: now - 60_000, baseline: { "42161:USDC": 40_000_000n, "8453:ETH": 10n ** 18n } };
+  const raw = serializeExchangeWatch(watch);
+  assert.deepEqual(parseExchangeWatch(raw, WALLET, now), watch, "matched case-insensitively");
+  assert.equal(parseExchangeWatch(raw, "0x2222222222222222222222222222222222222222", now), null, "someone else's");
+  assert.equal(parseExchangeWatch(raw, WALLET, now - 60_000 + EXCHANGE_WATCH_MS + 1), null, "too old");
+  assert.equal(parseExchangeWatch(serializeExchangeWatch({ ...watch, startedAt: now + 120_000 }), WALLET, now), null, "from the future");
+  for (const baseline of [{ "4663:ETH": "1" }, { "42161:USDG": "1" }, { "42161:USDC": "-1" }, { "42161:USDC": "1.5" }, { "42161:USDC": 1 }]) {
+    assert.equal(parseExchangeWatch(JSON.stringify({ wallet: watch.wallet, startedAt: watch.startedAt, baseline }), WALLET, now), null, JSON.stringify(baseline));
+  }
+  for (const junk of [null, "", "{", "[]", "null", JSON.stringify({ wallet: watch.wallet, startedAt: "1", baseline: {} })]) assert.equal(parseExchangeWatch(junk, WALLET, now), null, String(junk));
+  assert.equal(parseExchangeWatch(raw, "", now), null, "no wallet");
+});
+
+test("the guide reopens only when it was left open in this tab recently", () => {
+  const now = Date.UTC(2026, 10, 10, 12, 0);
+  assert.equal(exchangeGuideOpen(String(now - 5 * 60_000), now), true);
+  assert.equal(exchangeGuideOpen(String(now - EXCHANGE_WATCH_MS - 1), now), false);
+  assert.equal(exchangeGuideOpen(String(now + 5 * 60_000), now), false);
+  for (const raw of [null, "", "soon", "NaN"]) assert.equal(exchangeGuideOpen(raw, now), false, String(raw));
+});
diff --git a/app/src/lib/bridge/exchange.ts b/app/src/lib/bridge/exchange.ts
new file mode 100644
index 00000000..84464a8e
--- /dev/null
+++ b/app/src/lib/bridge/exchange.ts
@@ -0,0 +1,124 @@
+import { formatUnits, type Address } from "viem";
+import { FUND_MIN_ETH, FUND_MIN_USD, readHoldingsOn, type BridgeHolding, type HoldingReader } from "./fund";
+import { BRIDGE_SEND_ASSETS, bridgeCurrency, isDollarAsset, type BridgeAsset, type BridgeChainId } from "./types";
+
+/**
+ * From an exchange: the bridge panel's guide for funds that start in an exchange account. The exchange withdraws to the
+ * connected wallet on a network the bridge already sends from, the guide watches that wallet's balances there, and once
+ * the funds land it opens the bridge on that route. Every route it can open is one the bridge already checks; nothing
+ * here signs or sends.
+ *
+ * Relay's deposit addresses (send to an address, the transfer starts by itself) were looked at for this and are not
+ * used: the address cannot be tied to the order it claims to serve. See docs/bridge.md, "From an exchange".
+ */
+
+/**
+ * Where a withdrawal can land: the networks the bridge sends ETH and USDC from. Base comes first because it is also a
+ * launch chain, so funds that land there need no bridge when Base is where they are wanted.
+ */
+export const EXCHANGE_NETWORKS = [8453, 1, 42161, 10] as const satisfies readonly BridgeChainId[];
+export type ExchangeNetworkId = (typeof EXCHANGE_NETWORKS)[number];
+/** How often the balances are read while the guide is open. */
+export const EXCHANGE_POLL_MS = 15_000;
+/** How long a watch is kept in this tab: long enough to close the panel and come back. */
+export const EXCHANGE_WATCH_MS = 2 * 60 * 60_000;
+export const EXCHANGE_OPEN_KEY = "openlaunch.bridge.exchange.open";
+export const EXCHANGE_WATCH_KEY = "openlaunch.bridge.exchange.watch";
+
+export const isExchangeNetwork = (chainId: unknown): chainId is ExchangeNetworkId => (EXCHANGE_NETWORKS as readonly unknown[]).includes(chainId);
+const isNative = (chainId: BridgeChainId, asset: BridgeAsset) => /^0x0{40}$/.test(bridgeCurrency(chainId, asset, "input").address);
+const holdingKey = (holding: { chainId: BridgeChainId; asset: BridgeAsset }) => `${holding.chainId}:${holding.asset}`;
+
+/** What the wallet holds of each sendable asset on the exchange networks. A network that does not answer is left out. */
+export function readExchangeHoldings(read: HoldingReader, wallet: Address): Promise<BridgeHolding[]> {
+  return readHoldingsOn(read, wallet, EXCHANGE_NETWORKS);
+}
+
+/**
+ * The lowest balance seen per network and asset since the watch began. Arrivals are measured from it: a balance first
+ * read now starts at what it holds now, so funds already there never count as arriving, and a balance that drops (spent
+ * on gas, or bridged away) lowers it, so the next withdrawal is measured from where the wallet really stands.
+ */
+export type ExchangeBaseline = Readonly<Record<string, bigint>>;
+export function nextExchangeBaseline(baseline: ExchangeBaseline, holdings: readonly BridgeHolding[]): ExchangeBaseline {
+  const next: Record<string, bigint> = { ...baseline };
+  for (const holding of holdings) {
+    const key = holdingKey(holding);
+    const seen = next[key];
+    next[key] = seen !== undefined && seen < holding.amount ? seen : holding.amount;
+  }
+  return next;
+}
+
+/**
+ * Funds that landed since the watch began. `gas` is the ETH on that network beside a token arrival, since a token can
+ * be sent on only with some; null for ETH itself, or when that read failed.
+ */
+export type ExchangeArrival = { chainId: ExchangeNetworkId; asset: BridgeAsset; amount: bigint; decimals: 6 | 18; gas: bigint | null };
+
+/**
+ * Each rise above the baseline worth a bridge fee (the trade panel's dust floors), in network order, a token before the
+ * ETH that landed beside it: that ETH is most likely its gas.
+ */
+export function findExchangeArrivals(baseline: ExchangeBaseline, holdings: readonly BridgeHolding[]): ExchangeArrival[] {
+  const gas = new Map(holdings.filter((h) => isNative(h.chainId, h.asset)).map((h) => [h.chainId, h.amount]));
+  const order = (h: { chainId: BridgeChainId; asset: BridgeAsset }) => EXCHANGE_NETWORKS.indexOf(h.chainId as ExchangeNetworkId) * 10 + (isNative(h.chainId, h.asset) ? 9 : BRIDGE_SEND_ASSETS[h.chainId].indexOf(h.asset));
+  const arrivals: ExchangeArrival[] = [];
+  for (const holding of holdings) {
+    const { chainId } = holding;
+    if (!isExchangeNetwork(chainId)) continue;
+    const before = baseline[holdingKey(holding)];
+    if (before === undefined || holding.amount <= before) continue;
+    const amount = holding.amount - before;
+    if (Number(formatUnits(amount, holding.decimals)) < (isDollarAsset(holding.asset) ? FUND_MIN_USD : FUND_MIN_ETH)) continue;
+    arrivals.push({ chainId, asset: holding.asset, amount, decimals: holding.decimals, gas: isNative(chainId, holding.asset) ? null : gas.get(chainId) ?? null });
+  }
+  return arrivals.sort((a, b) => order(a) - order(b));
+}
+
+/** A token landed where the wallet has no ETH to pay for sending it on. */
+export const exchangeNeedsGas = (arrival: ExchangeArrival) => arrival.gas === 0n;
+
+/**
+ * What to do with an arrival: nothing when it landed on the network it is wanted on, else bridge from there. A token
+ * arrival fills in its amount; ETH is left for the sender to choose, since some of it pays the gas.
+ */
+export type ExchangeNext = { kind: "ready" } | { kind: "bridge"; originChainId: ExchangeNetworkId; originAsset: BridgeAsset; amount: string };
+export function exchangeNext(arrival: ExchangeArrival, destinationChainId: BridgeChainId): ExchangeNext {
+  if (arrival.chainId === destinationChainId) return { kind: "ready" };
+  return { kind: "bridge", originChainId: arrival.chainId, originAsset: arrival.asset, amount: isNative(arrival.chainId, arrival.asset) ? "" : formatUnits(arrival.amount, arrival.decimals) };
+}
+
+/** A watch as kept in this tab's session storage, so closing the panel does not lose what was already there. */
+export type ExchangeWatch = { wallet: string; startedAt: number; baseline: ExchangeBaseline };
+
+export function serializeExchangeWatch(watch: ExchangeWatch): string {
+  return JSON.stringify({ wallet: watch.wallet, startedAt: watch.startedAt, baseline: Object.fromEntries(Object.entries(watch.baseline).map(([key, value]) => [key, value.toString()])) });
+}
+
+/** The saved watch for `wallet`, or null when there is none, it is someone else's, it is too old, or it does not parse. */
+export function parseExchangeWatch(raw: string | null, wallet: string, now: number): ExchangeWatch | null {
+  if (!raw || !wallet) return null;
+  try {
+    const value: unknown = JSON.parse(raw);
+    if (!value || typeof value !== "object") return null;
+    const { wallet: owner, startedAt, baseline } = value as Record<string, unknown>;
+    if (typeof owner !== "string" || owner !== wallet.toLowerCase()) return null;
+    if (typeof startedAt !== "number" || !Number.isFinite(startedAt) || startedAt > now + 60_000 || now - startedAt > EXCHANGE_WATCH_MS) return null;
+    if (!baseline || typeof baseline !== "object") return null;
+    const parsed: Record<string, bigint> = {};
+    for (const [key, amount] of Object.entries(baseline)) {
+      const [chain, asset] = key.split(":");
+      const chainId = Number(chain);
+      if (!isExchangeNetwork(chainId) || !(BRIDGE_SEND_ASSETS[chainId] as readonly string[]).includes(asset) || typeof amount !== "string" || !/^\d{1,78}$/.test(amount)) return null;
+      parsed[key] = BigInt(amount);
+    }
+    return { wallet: owner, startedAt, baseline: parsed };
+  } catch { return null; }
+}
+
+/** Whether the guide was left open in this tab recently enough to reopen on it. */
+export function exchangeGuideOpen(raw: string | null, now: number): boolean {
+  const openedAt = Number(raw);
+  return raw !== null && Number.isFinite(openedAt) && openedAt <= now + 60_000 && now - openedAt <= EXCHANGE_WATCH_MS;
+}
diff --git a/app/src/lib/bridge/fund.ts b/app/src/lib/bridge/fund.ts
index 30108e66..640b002e 100644
--- a/app/src/lib/bridge/fund.ts
+++ b/app/src/lib/bridge/fund.ts
@@ -31,10 +31,14 @@ export type HoldingReader = {
  * What the wallet holds of every bridge asset on every network but `destination`. Each read stands alone: a network
  * that does not answer is left out, never counted as empty and never allowed to fail the others.
  */
-export async function readBridgeHoldings(read: HoldingReader, wallet: Address, destination: BridgeDestinationId): Promise<BridgeHolding[]> {
+export function readBridgeHoldings(read: HoldingReader, wallet: Address, destination: BridgeDestinationId): Promise<BridgeHolding[]> {
+  return readHoldingsOn(read, wallet, BRIDGE_CHAIN_IDS.filter((chainId) => chainId !== destination));
+}
+
+/** The same reads on the given networks only, each standing alone as above. */
+export async function readHoldingsOn(read: HoldingReader, wallet: Address, chains: readonly BridgeChainId[]): Promise<BridgeHolding[]> {
   const jobs: Promise<BridgeHolding | null>[] = [];
-  for (const chainId of BRIDGE_CHAIN_IDS) {
-    if (chainId === destination) continue;
+  for (const chainId of chains) {
     const gas = bridgesNativeCurrency(chainId) ? null : read.native(chainId, wallet).then((amount) => typeof amount === "bigint" && amount >= 0n ? amount : null, () => null);
     for (const asset of BRIDGE_SEND_ASSETS[chainId]) {
       const currency = bridgeCurrency(chainId, asset, "input");
diff --git a/docs/bridge.md b/docs/bridge.md
index c8fb7cc2..3681cea6 100644
--- a/docs/bridge.md
+++ b/docs/bridge.md
@@ -1,6 +1,6 @@
 # Base, Robinhood, Arc and Elysium bridge (funded from Ethereum, Arbitrum and Optimism)
 
-The header's **Bridge** action opens a focused funding panel without leaving the current token or launch page; `/bridge` shows the same panel as a page. It moves funds between Base (8453), Robinhood Chain (4663), Arc mainnet (5042) and Elysium (99901), and into them from Ethereum (1), Arbitrum (42161) and Optimism (10), always to the same connected wallet address. The three funding networks send only: nothing is ever bridged to them. Base sends/receives ETH or official USDC; Robinhood sends/receives ETH or USDG (Global Dollar, the chain's main stablecoin and the launch form's default quote there). Arc receives native USDC and sends USDC through its ERC-20 interface. Elysium sends its USDC only, and receives USDC or HYPE, its gas token, which is never sent. Ethereum, Arbitrum and Optimism send ETH or Circle's native USDC. Relay converts between ETH, USDC, USDG and HYPE at the reviewed quote. This does not add launched tokens or GITLAWB, change the launch-chain registry, or deploy contracts.
+The header's **Bridge** action opens a focused funding panel without leaving the current token or launch page; `/bridge` shows the same panel as a page. It moves funds between Base (8453), Robinhood Chain (4663), Arc mainnet (5042) and Elysium (99901), and into them from Ethereum (1), Arbitrum (42161) and Optimism (10), always to the same connected wallet address. The three funding networks send only: nothing is ever bridged to them. Base sends/receives ETH or official USDC; Robinhood sends/receives ETH or USDG (Global Dollar, the chain's main stablecoin and the launch form's default quote there). Arc receives native USDC and sends USDC through its ERC-20 interface. Elysium sends its USDC only, and receives USDC or HYPE, its gas token, which is never sent. Ethereum, Arbitrum and Optimism send ETH or Circle's native USDC. Relay converts between ETH, USDC, USDG and HYPE at the reviewed quote. Funds still on an exchange come in through the panel's exchange guide: withdraw to the wallet on Base, Ethereum, Arbitrum or Optimism, then bridge from there. This does not add launched tokens or GITLAWB, change the launch-chain registry, or deploy contracts.
 
 ## Integration
 
@@ -55,6 +55,27 @@ These tests never connect a wallet or submit a transaction.
 
 `/ui-review-bridge` is a development-only visual fixture with disconnected, quote, quoting, high-fee, expired, error, pending, success, uncertain and refund states, plus approval/recovery states. Its synthetic data cannot execute a transaction, and the route returns 404 outside development. The real header action uses the actual integration.
 
+### From an exchange (2026-11-10)
+
+The panel's "Funds on an exchange?" link, under the amount, swaps the form for a four-step guide. It uses only routes the bridge already checks and never asks the wallet for anything.
+
+1. **Address.** The connected wallet's full address with a copy button (selecting the text where the clipboard is refused). Without a wallet it offers Connect wallet. It notes that some smart wallets work only on some networks.
+2. **Network.** Base, Ethereum, Arbitrum or Optimism, each sending ETH or USDC. Base is marked "No bridge needed" when Base is the destination. The copy says to pick native USDC, not USDC.e or another bridged version, since the bridge sends only Circle's USDC, and to withdraw a little ETH beside USDC for gas. It makes no claim about which exchange supports which network.
+3. **Watch.** `useExchangeWatch` reads ETH and USDC on those four networks every 15 seconds through the same public clients as bridge-then-buy (`readHoldingsOn` in `fund.ts`, shared with `readBridgeHoldings`), paused while the tab is hidden. Each read stands alone, so a network that does not answer is skipped rather than read as empty. The baseline per network and asset is the lowest balance seen since the watch began, so funds already there never count as arriving and a balance spent down is measured from where it now stands. A rise of at least $1 of USDC or 0.0005 ETH (the trade panel's dust floors) is an arrival. Arrivals list a token before the ETH that landed beside it.
+4. **Bridge.** Each arrival on a network other than the destination gets a "Bridge … from …" button. It sets the origin network, asset and, for a token, the arrived amount through the same guarded setters the pickers use, then returns to the form for the normal quote and confirmation. ETH is left for the sender to size because some of it pays gas. A token that landed where the wallet holds no ETH gets a warning to withdraw a little ETH there too; an unread ETH balance gives no warning. Funds that land on the destination itself are reported as ready to use.
+
+The watch (baseline and start time) and the open guide are kept in this tab's session storage for two hours. Closing the panel, or connecting a wallet from the guide, reopens it where it was without taking focus. Opening the guide from the link moves focus to its title; Back and Bridge return focus to the link or the amount. Back and Bridge end the watch.
+
+**Why Relay deposit addresses are not used.** Relay can attach a one-time deposit address to a quote (`useDepositAddress`, with `strict` and `refundTo`): anything sent to it starts the order, which would let an exchange withdraw straight into a transfer. All seven bridge networks have it enabled. It stays off because the address cannot be tied to the order it claims to serve:
+
+- In production the addresses are externally owned accounts derived by Lit Protocol key pairs inside a trusted execution environment, from the order's derivation fields (VM types, output chain, currency and recipient, solver, pricing oracle, depositor, refund recipient, price-impact limit, salt) and a root public key Relay does not publish. The quote returns the address but not the derivation inputs, so it cannot be recomputed or checked locally. The CREATE2 `DepositAddressFactory` design in Relay's protocol documents is not what is deployed.
+- On Base the deposits arrive from fresh accounts sweeping themselves into the depository. For example `0xf14443b05f2ee1becbc6d0a220f1f929d7313cbc` sent `depositNative(0xe7c738f7336b0eec062a4aae9bb347e741c4b4a3, orderId)` to `0x4cd00e387622c35bddb9b4c962c136462338bc31` at nonce 0 (`0x860983555ac8542ba5267a5c0f688965fef85bd1a2f6a7da87bdbd0a4d25b323`) and nonce 1 (`0x8c4ea91486506a99eaaf2a941b526fa69c1ef516521e5c26027abc10ee18421f`). Nothing on-chain links that account to an order before the sweep.
+- Tracking needs `/requests/v3?depositAddress=` with an API key, and the request ID can change after the deposit. The sweep's gas is charged to the transfer: an Ethereum USDC route quoted about 3.3% at $25.
+
+The bridge's own checks still refuse a quote that carries a deposit address (`validation.ts`), and `relay.ts` never asks for one.
+
+- **Verification.** Unit tests cover the four networks and their sends, the reads (native USDC only, each standing alone), the baseline, arrivals and dust, ordering, gas, the route an arrival opens, and the saved watch (wallet, age, keys, amounts, malformed input). A UI guard checks that the guide and watch only read, open the bridge through the guarded setters, call out missing gas, and that deposit addresses stay off. Browser check of every guide state on `/ui-review-bridge`, the review dialog's arrival opening Arbitrum USDC to Arc with 25 filled in, `/bridge` without a wallet, a reload resuming the guide, and a phone width. No real withdrawal has been watched yet.
+
 ### HYPE on Elysium (2026-11-10)
 
 HYPE, Elysium's gas token, can now arrive on Elysium as the asset of any route there. It is never sent. With it the bridge has seventy-three routes: thirty-one between the launch chains and forty-two from the funding networks, eleven of them new (into HYPE from Base ETH and USDC, Robinhood ETH and USDG, Arc USDC, and ETH or USDC from each funding network).