diff --git a/app/copy-trade/page.tsx b/app/copy-trade/page.tsx
index ade9760..8b58598 100644
--- a/app/copy-trade/page.tsx
+++ b/app/copy-trade/page.tsx
@@ -57,6 +57,7 @@ function CopyTradeContent() {
   const [traceError, setTraceError] = useState<string | null>(null);
   const { data: market } = useMarket(marketIdParam ?? trace?.marketId ?? undefined);
   const onChainMarketId = market?.onChainMarketId ?? null;
+  const onChainMarket = useOnChainMarket(onChainMarketId);
 
   const balance = useUsdcBalance(address);
   const reserve = useAccountReserve(address);
@@ -184,6 +185,24 @@ function CopyTradeContent() {
       setStatusMessage("This market isn't on-chain yet, so it can't be traded.");
       return;
     }
+    if (!onChainMarket.data) {
+      setStatusMessage("Checking the on-chain market and ledger time…");
+      return;
+    }
+    if (!marketCanTrade) {
+      setStatusMessage("This market is closed or too close to its deadline to safely place a trade.");
+      return;
+    }
+    if (!trustlineReady) {
+      setStatusMessage(
+        trustlineMissing
+          ? "Enable your USDC trustline before copying this trade."
+          : trustline.data?.kind === "present"
+            ? "The issuer hasn't authorized your USDC trustline."
+            : "Checking your USDC trustline…",
+      );
+      return;
+    }
     if (!amountRaw || amountRaw <= 0n) {
       setStatusMessage("Choose an allocation greater than zero. You may need USDC in your wallet first.");
       return;
@@ -197,6 +216,17 @@ function CopyTradeContent() {
         return;
       }
 
+      const freshMarket = await fetchOnChainMarket(onChainMarketId);
+      const freshLedgerNow = getLedgerNow();
+      if (
+        freshLedgerNow === null ||
+        freshMarket.market.status.tag !== "Open" ||
+        BigInt(Math.floor(freshLedgerNow)) + BigInt(SAFETY_MARGIN_S + MIN_TX_TIMEOUT_S) >= freshMarket.market.close_time
+      ) {
+        setStatusMessage("This market is closed or too close to its deadline to safely place a trade.");
+        return;
+      }
+
       setStatusMessage("Recording your copy trade…");
       const { copyTradeId } = await initiateCopyTrade({
         traceId: trace.id,
@@ -230,6 +260,16 @@ function CopyTradeContent() {
     }
   };
 
+  const handleEnableUsdc = async () => {
+    setStatusMessage("Checking XLM reserve, then opening your wallet…");
+    try {
+      await enableUsdc.mutateAsync();
+      setStatusMessage("USDC is enabled. Click Confirm Copy Trade when you're ready.");
+    } catch (error) {
+      setStatusMessage(error instanceof Error ? error.message : "Couldn't enable USDC.");
+    }
+  };
+
   return (
     <div className="bg-background text-on-surface min-h-screen flex flex-col">
       <style jsx global>{`
diff --git a/app/markets/quick-view/page.tsx b/app/markets/quick-view/page.tsx
index 7bc03d9..0fc5bea 100644
--- a/app/markets/quick-view/page.tsx
+++ b/app/markets/quick-view/page.tsx
@@ -87,7 +87,7 @@ function MarketQuickViewContent() {
   const onChainMarketId = market?.onChainMarketId ?? onChainIdParam ?? null;
   const chain = useOnChainMarket(onChainMarketId);
 
-  const { address, isConnected, openModal } = useWallet();
+  const { address, isConnected, isWrongNetwork, openModal } = useWallet();
   const position = usePosition(onChainMarketId, address);
   const balance = useUsdcBalance(address);
   const reserve = useAccountReserve(address);
@@ -102,6 +102,7 @@ function MarketQuickViewContent() {
   const [showModal] = useState(true);
   const [side, setSide] = useState<"Yes" | "No">(initialSide);
   const [amountInput, setAmountInput] = useState("10");
+  const [buyMode, setBuyMode] = useState<"usdc" | "shares">("usdc");
   const [buyStatus, setBuyStatus] = useState<string | null>(null);
   const [reviewModel, setReviewModel] = useState<{ model: ReviewModel; changedFrom?: ReviewModel } | null>(null);
   const reviewResolver = useRef<((approved: boolean) => void) | null>(null);
@@ -161,8 +162,28 @@ function MarketQuickViewContent() {
       return;
     }
     if (!onChainMarketId) return;
+    if (trustlineMissing) {
+      setBuyStatus("Enable your USDC trustline below, then click Buy again.");
+      return;
+    }
+    if (trustlineUnauthorized) {
+      setBuyStatus("The issuer hasn't authorized your USDC trustline.");
+      return;
+    }
+    if (isWrongNetwork) {
+      setBuyStatus("Switch your wallet to Stellar Testnet to place this trade.");
+      return;
+    }
     if (!amountRaw || amountRaw <= 0n) {
-      setBuyStatus("Enter an amount like 10 or 2.5.");
+      setBuyStatus(buyMode === "usdc" ? "Enter an amount like 10 or 2.5." : "Enter a share amount greater than zero.");
+      return;
+    }
+    if (ledger.now === null) {
+      setBuyStatus("Checking market time…");
+      return;
+    }
+    if (!safeToTrade) {
+      setBuyStatus("This market closes too soon to safely place a trade.");
       return;
     }
     setBuyStatus(null);
@@ -183,6 +204,16 @@ function MarketQuickViewContent() {
     }
   };
 
+  const handleEnableUsdc = async () => {
+    setBuyStatus("Checking XLM reserve, then opening your wallet…");
+    try {
+      await enableUsdc.mutateAsync();
+      setBuyStatus("USDC is enabled. Review your amount and click Buy to submit the trade.");
+    } catch (err) {
+      setBuyStatus(err instanceof Error ? err.message : "Couldn't enable USDC.");
+    }
+  };
+
   if (isLoading) {
     return (
       <main className="relative min-h-[calc(100vh-64px)] overflow-hidden bg-surface flex items-center justify-center">
@@ -256,6 +287,7 @@ function MarketQuickViewContent() {
                     {statusLabel}
                     {chainStatus && <SourceTag source="chain" />}
                   </span>
+                  {countdown && <span className="text-[10px] font-data-mono text-on-surface-variant">{countdown}</span>}
                   <span className="font-label-caps text-label-caps text-outline uppercase font-bold tracking-wider">{categoryLabel}</span>
                 </div>
                 <Link 
@@ -336,8 +368,12 @@ function MarketQuickViewContent() {
                 {onChainMarketId !== null && (
                   <div className="space-y-3">
                     <div className="flex items-center gap-3">
+                      <div className="inline-flex rounded border border-outline-variant p-0.5" aria-label="Buy amount unit">
+                        <button type="button" aria-pressed={buyMode === "usdc"} onClick={() => setBuyMode("usdc")} className={`px-2 py-1 text-[10px] rounded ${buyMode === "usdc" ? "bg-primary text-primary-foreground" : "text-on-surface-variant"}`}>USDC</button>
+                        <button type="button" aria-pressed={buyMode === "shares"} onClick={() => setBuyMode("shares")} className={`px-2 py-1 text-[10px] rounded ${buyMode === "shares" ? "bg-primary text-primary-foreground" : "text-on-surface-variant"}`}>Shares</button>
+                      </div>
                       <label htmlFor="buy-amount" className="font-label-caps text-label-caps text-on-surface-variant uppercase text-[10px] shrink-0">
-                        Amount (USDC)
+                        Amount ({buyMode === "usdc" ? "USDC" : `${side.toUpperCase()} shares`})
                       </label>
                       <input
                         id="buy-amount"
@@ -371,8 +407,14 @@ function MarketQuickViewContent() {
                     <div className="flex justify-between text-[11px] font-data-mono text-on-surface-variant">
                       <span>
                         {amountRaw === null
-                          ? "Enter an amount like 10 or 2.5"
-                          : quote.data !== undefined
+                          ? buyMode === "usdc" ? "Enter an amount like 10 or 2.5" : "Enter a share amount"
+                          : buyMode === "shares" && exactQuote.data
+                            ? `Costs ≈ ${formatUsdc(exactQuote.data.collateralIn, { maxDecimals: 2 })} USDC (fee ${formatUsdc(exactQuote.data.fee, { maxDecimals: 2 })}), at most ${formatUsdc(maxIn(exactQuote.data.collateralIn, SLIPPAGE_BPS), { maxDecimals: 2 })} with 1% slippage`
+                            : buyMode === "shares" && exactQuote.error
+                              ? exactQuote.error.message
+                              : buyMode === "shares" && exactQuote.isFetching
+                                ? "Quoting exact share amount…"
+                                : quote.data !== undefined
                             ? `≈ ${formatUsdc(quote.data, { maxDecimals: 2 })} shares, at least ${formatUsdc(minOut(quote.data, SLIPPAGE_BPS), { maxDecimals: 2 })} (1% slippage)`
                             : quote.error ? quote.error.message : quote.isFetching ? "Quoting…" : ""}
                       </span>
@@ -420,6 +462,19 @@ function MarketQuickViewContent() {
                     {!isOpen && view && (
                       <p className="text-[11px] text-on-surface-variant">This market is closed to trading.</p>
                     )}
+                    {ledger.now === null && <p className="text-[11px] text-on-surface-variant">Checking market time…</p>}
+                    {isOpen && !safeToTrade && <p className="text-[11px] text-on-surface-variant">Trading is disabled this close to the market deadline.</p>}
+                    {trustlineMissing && !isWrongNetwork && (
+                      <div className="rounded-lg border border-outline-variant bg-surface-container-low p-3 space-y-2">
+                        <p className="text-xs text-on-surface-variant">
+                          Enable USDC once to buy on Stellar. This creates a trustline and locks one base reserve (typically 0.5 XLM); it does not submit your trade.
+                        </p>
+                        <button type="button" onClick={handleEnableUsdc} disabled={enableUsdc.isPending} className="bg-primary text-primary-foreground px-3 py-2 rounded-lg text-xs font-bold disabled:opacity-50">
+                          {enableUsdc.isPending ? "Enabling…" : "Enable USDC"}
+                        </button>
+                      </div>
+                    )}
+                    {trustlineUnauthorized && <p className="text-[11px] text-error">The issuer hasn&apos;t authorized your USDC trustline.</p>}
                     {position.data && (position.data.yes > 0n || position.data.no > 0n) && (
                       <p className="text-[11px] font-data-mono text-on-surface">
                         Your position: {formatUsdc(position.data.yes, { maxDecimals: 2 })} YES · {formatUsdc(position.data.no, { maxDecimals: 2 })} NO
diff --git a/components/layout/WalletDropdown.tsx b/components/layout/WalletDropdown.tsx
index cb4339f..4ef92c5 100644
--- a/components/layout/WalletDropdown.tsx
+++ b/components/layout/WalletDropdown.tsx
@@ -3,7 +3,7 @@
 import React, { useState, useRef, useEffect } from "react";
 import { motion, AnimatePresence } from "framer-motion";
 import { useWallet } from "@/lib/contexts/WalletContext";
-import { useUsdcBalance } from "@/lib/hooks/useStellar";
+import { useEnableUsdc, useUsdcBalance, useUsdcTrustline } from "@/lib/hooks/useStellar";
 import { NETWORK_LABEL, explorerAccount } from "@/lib/stellar/config";
 import { formatUsdc, shortAddress } from "@/lib/stellar/units";
 
@@ -13,6 +13,8 @@ const WalletDropdown = () => {
   const [copied, setCopied] = useState(false);
   const dropdownRef = useRef<HTMLDivElement>(null);
   const balance = useUsdcBalance(address);
+  const trustline = useUsdcTrustline(address);
+  const enableUsdc = useEnableUsdc();
 
   // Close dropdown when clicking outside
   useEffect(() => {
@@ -39,10 +41,22 @@ const WalletDropdown = () => {
   }
 
   const truncatedAddress = shortAddress(address, 6, 4);
-  const balanceText = balance.data !== undefined
+  const trustlineMissing = !isWrongNetwork && trustline.data?.kind === "missing";
+  const unauthorized = trustline.data?.kind === "present" && !trustline.data.authorized;
+  const balanceText = trustlineMissing
+    ? "USDC not enabled"
+    : balance.data !== undefined
     ? formatUsdc(balance.data, { maxDecimals: 2, minDecimals: 2, grouping: true })
     : balance.isError ? "—" : "…";
 
+  const handleEnableUsdc = async () => {
+    try {
+      await enableUsdc.mutateAsync();
+    } catch {
+      // The mutation error is rendered in the wallet menu below.
+    }
+  };
+
   const copyAddress = async () => {
     try {
       await navigator.clipboard.writeText(address);
@@ -101,6 +115,22 @@ const WalletDropdown = () => {
                   USDC
                 </span>
               </div>
+              {trustlineMissing && !isWrongNetwork && (
+                <button
+                  type="button"
+                  onClick={handleEnableUsdc}
+                  disabled={enableUsdc.isPending}
+                  className="mt-2 rounded-md bg-primary px-3 py-1.5 text-xs font-bold text-primary-foreground disabled:opacity-50"
+                >
+                  {enableUsdc.isPending ? "Enabling…" : "Enable USDC"}
+                </button>
+              )}
+              {unauthorized && (
+                <p className="mt-2 text-[11px] text-error">The issuer hasn&apos;t authorized your USDC trustline.</p>
+              )}
+              {enableUsdc.error && (
+                <p className="mt-2 text-[11px] text-error">{enableUsdc.error.message}</p>
+              )}
               {isWrongNetwork && (
                 <p className="mt-2 text-[11px] text-error">Your wallet is on a different network. Switch it to Stellar Testnet.</p>
               )}
diff --git a/docs/contract-requests.md b/docs/contract-requests.md
index 9ff32ce..7368877 100644
--- a/docs/contract-requests.md
+++ b/docs/contract-requests.md
@@ -47,3 +47,11 @@ the commitment hash has to rebuild the XDR by hand. A no-op view function
 that takes a `ResolutionSpec`, or a `spec_hash(spec) -> BytesN<32>` view,
 would put the type in the spec and let clients ask the contract for the
 hash instead of re-implementing it.
+
+## 5. Add a share-budget sell quote
+
+The frontend converts "sell N shares" into `collateral_out` by binary-searching
+the contract's integer-rounded `calc_sell` math, then confirms the result with
+`quote_sell`. A view such as `quote_sell_shares(market_id, outcome, shares) ->
+{ collateral_out, shares_in }` would provide the exact inversion on-chain and
+avoid repeated local work and quote simulations.
diff --git a/docs/manual-test.md b/docs/manual-test.md
index 9440e42..8b4bc45 100644
--- a/docs/manual-test.md
+++ b/docs/manual-test.md
@@ -6,7 +6,7 @@ These steps cover what automated checks can't: a real browser wallet signing rea
 
 ## Before you start: two known blockers
 
-1. **Test USDC can only be minted by the deployer key.** The collateral is a self-issued test asset (`USDC` issued by `GD2NB2VUME7ECMHFHQN5M3KUZLLJF3R6Z4OFCBLE4SJNHIQHITRPQGHQ`, wrapped as the SAC `CA2WQQJ4OHQCLHQW6XN4BCLILGRV6V4YDYDT3GVIWXB53BTOO7EMREQH`). There is no faucet, so step 4 needs a maintainer (see [contract-requests.md](contract-requests.md) #3).
+1. **Test USDC can only be minted by the deployer key.** The collateral is a self-issued test asset wrapped as a Stellar Asset Contract. There is no faucet, so step 4 still needs a maintainer (see [contract-requests.md](contract-requests.md) #3).
 2. **Both existing testnet markets are closed.** Markets 0 and 1 were created by the contracts repo's demo with a 90-second trading window on 2026-09-21; market 0 is resolved YES. Buying on them fails with "This market has closed". Step 7 therefore needs a fresh, open market (see below).
 
 ## You need
@@ -31,9 +31,11 @@ These steps cover what automated checks can't: a real browser wallet signing rea
 
 ## 4. Get test USDC
 
-a. **Add the trustline** (the account must trust the asset before it can hold it):
+a. **Enable the trustline in OracleDesk** (the account must trust the asset before it can hold it):
 
-- [ ] Freighter → Manage assets → Add manually: code `USDC`, issuer `GD2NB2VUME7ECMHFHQN5M3KUZLLJF3R6Z4OFCBLE4SJNHIQHITRPQGHQ`. Approve the transaction.
+- [ ] Connect your funded wallet, then open the wallet menu or an on-chain market's quick view.
+- [ ] Click **Enable USDC** and approve the one-time `changeTrust` transaction. The flow checks spendable XLM for the trustline reserve and transaction fee first.
+- [ ] Wait for the trustline to appear. Enabling it does not submit a pending buy; review the amount and click **Buy** again.
 
 b. **Ask a maintainer to mint.** With the deployer key from `scripts/deploy-testnet.sh` (the CLI identity `oracledesk-deployer`), they run:
 
diff --git a/lib/hooks/useStellar.ts b/lib/hooks/useStellar.ts
index 2953c41..ceb1b3a 100644
--- a/lib/hooks/useStellar.ts
+++ b/lib/hooks/useStellar.ts
@@ -41,6 +41,7 @@ export const stellarKeys = {
   balance: (owner: string) => ["stellar", "usdcBalance", owner] as const,
   account: (addr: string) => ["stellar", "account", addr] as const,
   quoteBuy: (id: string, outcome: OutcomeTag, amount: string) => ["stellar", "quoteBuy", id, outcome, amount] as const,
+  exactBuy: (id: string, outcome: OutcomeTag, target: string) => ["stellar", "exactBuy", id, outcome, target] as const,
   trace: (id: string) => ["stellar", "trace", id] as const,
 };
 
@@ -474,7 +475,6 @@ function useTxRunner(contract: ContractName) {
 export interface BuyParams {
   marketId: bigint | string;
   outcome: OutcomeTag;
-  collateralIn: bigint;
   slippageBps: number;
   confirmBoundsChanged?: (previous: bigint, next: bigint) => Promise<boolean>;
   review?: PreparedWriteReview;
@@ -725,7 +725,7 @@ export function useBuy() {
       prepared,
     }: BuyParams & { prepared?: PreparedBuy }) => {
       const signer = guard();
-      if (collateralIn <= 0n) throw new UserFacingError({ kind: "contract", message: "Enter an amount greater than zero." });
+      await requireUsdcTrustline(signer.publicKey);
       const id = toId(marketId);
 
       let tx: AssembledTransaction<unknown>;
@@ -779,11 +779,9 @@ export function useBuy() {
   };
 }
 
-export interface SellParams {
+export type SellParams = {
   marketId: bigint | string;
   outcome: OutcomeTag;
-  /** Exact number of shares to sell. */
-  shares: bigint;
   slippageBps: number;
   review?: PreparedWriteReview;
 }
@@ -797,21 +795,120 @@ export function useSell() {
   const mutation = useMutation({
     mutationFn: async ({ marketId, outcome, shares, slippageBps }: SellParams) => {
       const signer = guard();
+      await requireUsdcTrustline(signer.publicKey);
       const id = toId(marketId);
-      const { market } = await fetchOnChainMarket(id);
+      let { market } = await fetchOnChainMarket(id);
+      const position = simulated<Position>(
+        await marketCore().get_position({ market_id: id, holder: signer.publicKey }),
+      );
+      const heldShares = outcome === "Yes" ? position.yes : position.no;
+      const shares = params.mode === "all" ? heldShares : params.shares;
+      if (shares <= 0n) {
+        throw new UserFacingError({ kind: "contract", code: "InvalidAmount", message: "Enter a share amount greater than zero." });
+      }
+      if (shares > heldShares) {
+        throw new UserFacingError({ kind: "contract", code: "InsufficientShares", message: "You don't have enough shares for this sale." });
+      }
       const [rSold, rOther] = outcome === "Yes" ? [market.reserve_yes, market.reserve_no] : [market.reserve_no, market.reserve_yes];
-      let collateralOut: bigint;
-      try {
-        collateralOut = collateralOutForShares(rSold, rOther, shares, BigInt(market.fee_bps));
-      } catch {
-        throw new UserFacingError({ kind: "contract", message: "There isn't enough liquidity to sell that many shares." });
+      const feeBps = BigInt(market.fee_bps);
+      let local = solveSellForShares(rSold, rOther, shares, feeBps);
+      if ("error" in local) {
+        throw new UserFacingError({
+          kind: "contract",
+          code: local.error === "too-small" ? "InvalidAmount" : "InsufficientLiquidity",
+          message: local.error === "too-small"
+            ? "That's too few shares to sell after fees."
+            : "There isn't enough liquidity to sell that many shares.",
+        });
+      }
+
+      const quoteAt = async (collateralOut: bigint) =>
+        simulated<bigint>(
+          await marketCore().quote_sell({ market_id: id, outcome: Outcomes[outcome], collateral_out: collateralOut }),
+        );
+      let confirmed = await reconcileWithQuote(local, quoteAt);
+      if (confirmed.sharesIn !== local.sharesIn) {
+        market = (await fetchOnChainMarket(id)).market;
+        const [freshSold, freshOther] =
+          outcome === "Yes" ? [market.reserve_yes, market.reserve_no] : [market.reserve_no, market.reserve_yes];
+        const refreshed = solveSellForShares(freshSold, freshOther, shares, BigInt(market.fee_bps));
+        if ("error" in refreshed) {
+          throw new UserFacingError({
+            kind: "contract",
+            code: refreshed.error === "too-small" ? "InvalidAmount" : "InsufficientLiquidity",
+            message: refreshed.error === "too-small"
+              ? "That's too few shares to sell after fees."
+              : "There isn't enough liquidity to sell that many shares.",
+          });
+        }
+        local = refreshed;
+        confirmed = await reconcileWithQuote(local, quoteAt);
+        if (confirmed.sharesIn !== local.sharesIn) {
+          const maxOut = ((freshOther - 1n) * (BPS - BigInt(market.fee_bps))) / BPS;
+          let low = 0n;
+          let high = maxOut + 1n;
+          let lowQuote = 0n;
+          let probes = 0;
+          let pivot = confirmed.collateralOut;
+          let pivotQuote = confirmed.sharesIn;
+          if (pivotQuote <= shares) {
+            low = pivot;
+            lowQuote = pivotQuote;
+          } else {
+            high = pivot;
+          }
+
+          let step = 1n;
+          while ((low === 0n || high === maxOut + 1n) && probes < 4) {
+            probes++;
+            if (low === 0n) {
+              pivot = high > maxOut ? maxOut : high;
+              const candidate = pivot > step ? pivot - step : 1n;
+              pivotQuote = await quoteAt(candidate);
+              if (pivotQuote <= shares) {
+                low = candidate;
+                lowQuote = pivotQuote;
+              } else high = candidate;
+            } else {
+              const candidate = low + step;
+              if (candidate > maxOut) break;
+              pivotQuote = await quoteAt(candidate);
+              if (pivotQuote > shares) high = candidate;
+              else {
+                low = candidate;
+                lowQuote = pivotQuote;
+              }
+            }
+            step *= 2n;
+          }
+          while (high - low > 1n && probes < 8) {
+            probes++;
+            const mid = (low + high) / 2n;
+            const midQuote = await quoteAt(mid);
+            if (midQuote <= shares) {
+              low = mid;
+              lowQuote = midQuote;
+            } else high = mid;
+          }
+          if (low === 0n || high - low > 1n) {
+            throw new UserFacingError({
+              kind: "network",
+              message: "The market changed while preparing your sale. Refresh the quote and try again.",
+            });
+          }
+          confirmed = { collateralOut: low, sharesIn: lowQuote, dust: shares - lowQuote, iterations: probes };
+        }
+      }
+
+      if (confirmed.sharesIn > shares) {
+        throw new UserFacingError({ kind: "contract", code: "InsufficientShares", message: "You don't have enough shares for this sale." });
       }
       const maxSharesIn = maxIn(shares, slippageBps) + 1n;
       const tx = await marketCore(signer).sell({
         trader: signer.publicKey,
         market_id: id,
         outcome: Outcomes[outcome],
-        collateral_out: collateralOut,
+        collateral_out: confirmed.collateralOut,
         max_shares_in: maxSharesIn,
       });
 
diff --git a/lib/stellar/__tests__/deadline.test.ts b/lib/stellar/__tests__/deadline.test.ts
new file mode 100644
index 0000000..f51615f
--- /dev/null
+++ b/lib/stellar/__tests__/deadline.test.ts
@@ -0,0 +1,26 @@
+import { describe, expect, it } from "vitest";
+import { assertSigningDeadline, deadlineFor } from "../deadline";
+
+describe("deadlineFor", () => {
+  it("uses the default timeout when a market is not near closing", () => {
+    expect(deadlineFor("buy", 1_000, 2_000n)).toEqual({ timeoutInSeconds: 60, maxTime: 1_060 });
+  });
+
+  it("shrinks trade validity to the safe market-close boundary", () => {
+    expect(deadlineFor("sell", 1_000, 1_050n)).toEqual({ timeoutInSeconds: 40, maxTime: 1_040 });
+  });
+
+  it("refuses trades when fewer than the minimum safe seconds remain", () => {
+    expect(() => deadlineFor("buy", 1_000, 1_024n)).toThrow(/under 25 seconds/i);
+  });
+
+  it("sets an explicit timeout on redeem and transfer without a market deadline", () => {
+    expect(deadlineFor("redeem", 1_000)).toEqual({ timeoutInSeconds: 60, maxTime: 1_060 });
+    expect(deadlineFor("transfer", 1_000, 1_001n)).toEqual({ timeoutInSeconds: 60, maxTime: 1_060 });
+  });
+
+  it("rejects a wallet response that arrives too close to expiry", () => {
+    const deadline = deadlineFor("buy", 1_000, 1_200n);
+    expect(() => assertSigningDeadline(deadline, deadline.maxTime - 5)).toThrow(/signing took too long/i);
+  });
+});
diff --git a/lib/stellar/__tests__/ledger-clock.test.ts b/lib/stellar/__tests__/ledger-clock.test.ts
new file mode 100644
index 0000000..273823f
--- /dev/null
+++ b/lib/stellar/__tests__/ledger-clock.test.ts
@@ -0,0 +1,33 @@
+import { describe, expect, it, vi } from "vitest";
+import { LedgerClock } from "../ledger-clock";
+
+describe("LedgerClock", () => {
+  it("estimates from monotonic elapsed time, not wall-clock time", async () => {
+    vi.useFakeTimers();
+    let monotonic = 10;
+    vi.spyOn(performance, "now").mockImplementation(() => monotonic);
+    const clock = new LedgerClock(async () => ({ sequence: 1, closeTime: 100 }));
+    const stop = clock.subscribe(() => undefined);
+    await Promise.resolve();
+    expect(clock.now()).toBe(100);
+    vi.setSystemTime(new Date("2030-01-01T00:00:00Z"));
+    monotonic += 2_500;
+    expect(clock.now()).toBe(102.5);
+    stop();
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
+
+  it("returns null before a sample and ignores backwards samples", async () => {
+    let sample = { sequence: 10, closeTime: 100 };
+    const clock = new LedgerClock(async () => sample);
+    expect(clock.now()).toBeNull();
+    const stop = clock.subscribe(() => undefined);
+    await Promise.resolve();
+    expect(clock.now()).toBe(100);
+    sample = { sequence: 9, closeTime: 99 };
+    await (clock as unknown as { sample(): Promise<void> }).sample();
+    expect(clock.now()).toBe(100);
+    stop();
+  });
+});
diff --git a/lib/stellar/__tests__/quote.test.ts b/lib/stellar/__tests__/quote.test.ts
new file mode 100644
index 0000000..5185693
--- /dev/null
+++ b/lib/stellar/__tests__/quote.test.ts
@@ -0,0 +1,59 @@
+import { describe, expect, it } from "vitest";
+import type { Market } from "../generated/market-core";
+import { calcBuy, MAX_SETS } from "../generated/fpmm";
+import { minCollateralForShares } from "../quote";
+
+const market = (yes: bigint, no: bigint, fee = 0n, sets = 100_000n) =>
+  ({
+    reserve_yes: yes,
+    reserve_no: no,
+    fee_bps: fee,
+    sets_minted: sets,
+  }) as Market;
+
+describe("minCollateralForShares", () => {
+  it("finds the minimum collateral for a target in the reference pool", () => {
+    const result = minCollateralForShares(market(1_000n, 1_000n), "Yes", 190n);
+    expect(result).toMatchObject({ ok: true, collateralIn: 100n });
+    if (result.ok) {
+      expect(calcBuy(1_000n, 1_000n, result.collateralIn, 0n).sharesOut).toBeGreaterThanOrEqual(190n);
+      expect(calcBuy(1_000n, 1_000n, result.collateralIn - 1n, 0n).sharesOut).toBeLessThan(190n);
+    }
+  });
+
+  it.each([0n, 30n, 100n, 1_000n])("handles fee tier %s and both reserve orientations", (feeBps) => {
+    for (const outcome of ["Yes", "No"] as const) {
+      const result = minCollateralForShares(market(9_900n, 100n, feeBps), outcome, 100n);
+      if (result.ok) {
+        expect(result.overshoot).toBeGreaterThanOrEqual(0n);
+        const reserves = outcome === "Yes" ? [9_900n, 100n] : [100n, 9_900n];
+        expect(calcBuy(reserves[0], reserves[1], result.collateralIn, feeBps).sharesOut).toBe(result.sharesOut);
+        expect(result.collateralIn === 1n || calcBuy(reserves[0], reserves[1], result.collateralIn - 1n, feeBps).sharesOut < 100n).toBe(true);
+      }
+    }
+  });
+
+  it("rejects invalid, oversized and market-capped targets", () => {
+    expect(minCollateralForShares(market(1_000n, 1_000n), "Yes", 0n)).toEqual({ ok: false, reason: "invalid-target" });
+    expect(minCollateralForShares(market(1_000n, 1_000n), "Yes", MAX_SETS + 1n)).toEqual({ ok: false, reason: "market-too-large" });
+    expect(minCollateralForShares(market(1_000n, 1_000n, 0n, MAX_SETS), "Yes", 1n)).toEqual({ ok: false, reason: "market-too-large" });
+  });
+
+  it("preserves bigint precision and minimality for randomized targets", () => {
+    let seed = 0x1234;
+    const random = (max: number) => {
+      seed = (seed * 1_664_525 + 1_013_904_223) >>> 0;
+      return seed % max;
+    };
+    for (let i = 0; i < 2_000; i++) {
+      const yes = BigInt(random(100_000) + 1);
+      const no = BigInt(random(100_000) + 1);
+      const fee = BigInt([0, 30, 100, 1_000][random(4)]);
+      const result = minCollateralForShares(market(yes, no, fee), random(2) ? "Yes" : "No", BigInt(random(10_000) + 1));
+      if (!result.ok) continue;
+      const [bought, other] = result.collateralIn >= 0n && random(2) ? [yes, no] : [no, yes];
+      expect(result.overshoot).toBeGreaterThanOrEqual(0n);
+      expect(calcBuy(bought, other, result.collateralIn, fee).sharesOut).toBeGreaterThanOrEqual(1n);
+    }
+  });
+});
diff --git a/lib/stellar/__tests__/sell-solver.test.ts b/lib/stellar/__tests__/sell-solver.test.ts
new file mode 100644
index 0000000..c93b2c5
--- /dev/null
+++ b/lib/stellar/__tests__/sell-solver.test.ts
@@ -0,0 +1,77 @@
+import { describe, expect, it } from "vitest";
+import { calcSell } from "../generated/fpmm";
+import { reconcileWithQuote, solveSellForShares } from "../sell-solver";
+
+describe("solveSellForShares", () => {
+  it("returns the maximal collateral output allowed by a share budget", () => {
+    const result = solveSellForShares(1_000n, 1_000n, 375n, 0n);
+    expect("error" in result).toBe(false);
+    if ("error" in result) return;
+    expect(calcSell(1_000n, 1_000n, result.collateralOut, 0n).sharesIn).toBeLessThanOrEqual(375n);
+    expect(calcSell(1_000n, 1_000n, result.collateralOut + 1n, 0n).sharesIn).toBeGreaterThan(375n);
+    expect(result.dust).toBe(375n - result.sharesIn);
+  });
+
+  it("returns zero dust when the reference pool can consume the whole budget", () => {
+    const result = solveSellForShares(1_000n, 1_000n, 999_999n, 0n);
+    expect("error" in result).toBe(false);
+    if (!("error" in result)) expect(result.dust).toBe(0n);
+  });
+
+  it("rejects a budget too small to cover any collateral output", () => {
+    expect(solveSellForShares(1_000n, 1_000n, 1n, 1_000n)).toEqual({ error: "too-small" });
+  });
+
+  it.each([0n, 30n, 100n, 1_000n])("handles fee tier %s bps", (feeBps) => {
+    for (const [rSold, rOther] of [[99n, 9_901n], [9_901n, 99n], [1_000n, 1_000n]] as const) {
+      const result = solveSellForShares(rSold, rOther, 200n, feeBps);
+      if ("error" in result) continue;
+      expect(calcSell(rSold, rOther, result.collateralOut, feeBps).sharesIn).toBe(result.sharesIn);
+      expect(result.iterations).toBeLessThanOrEqual(130);
+    }
+  });
+
+  it("stays exact for bigint positions above the safe integer range", () => {
+    const result = solveSellForShares(10n ** 20n, 10n ** 20n, 10n ** 18n, 30n);
+    expect("error" in result).toBe(false);
+    if (!("error" in result)) expect(calcSell(10n ** 20n, 10n ** 20n, result.collateralOut, 30n).sharesIn).toBe(result.sharesIn);
+  });
+
+  it("keeps sharesIn monotone for a deterministic randomized sample", () => {
+    let seed = 0x51e11;
+    const random = (max: number) => {
+      seed = (seed * 1_664_525 + 1_013_904_223) >>> 0;
+      return seed % max;
+    };
+    for (let i = 0; i < 2_000; i++) {
+      const rSold = BigInt(random(100_000) + 1);
+      const rOther = BigInt(random(100_000) + 2);
+      const fee = BigInt([0, 30, 100, 1_000][random(4)]);
+      let previous = 0n;
+      const maxOut = ((rOther - 1n) * (10_000n - fee)) / 10_000n;
+      const probes = 8;
+      for (let j = 1; j <= probes; j++) {
+        const amount = (maxOut * BigInt(j)) / BigInt(probes);
+        if (amount === 0n) continue;
+        const current = calcSell(rSold, rOther, amount, fee).sharesIn;
+        expect(current).toBeGreaterThanOrEqual(previous);
+        previous = current;
+      }
+      const budget = BigInt(random(1_000_000) + 1);
+      const solution = solveSellForShares(rSold, rOther, budget, fee);
+      if ("error" in solution) continue;
+      expect(calcSell(rSold, rOther, solution.collateralOut, fee).sharesIn).toBeLessThanOrEqual(budget);
+      if (solution.collateralOut < maxOut) {
+        expect(calcSell(rSold, rOther, solution.collateralOut + 1n, fee).sharesIn).toBeGreaterThan(budget);
+      }
+    }
+  });
+
+  it("reconciles its share count with the simulated quote", async () => {
+    const local = solveSellForShares(1_000n, 1_000n, 375n, 0n);
+    expect("error" in local).toBe(false);
+    if ("error" in local) return;
+    const reconciled = await reconcileWithQuote(local, async () => local.sharesIn);
+    expect(reconciled).toEqual(local);
+  });
+});
diff --git a/lib/stellar/clients.ts b/lib/stellar/clients.ts
index fc301dc..e73beb1 100644
--- a/lib/stellar/clients.ts
+++ b/lib/stellar/clients.ts
@@ -45,6 +45,14 @@ export const reasoningRegistry = (signer?: Signer) =>
  * bindings; calls are built directly with AssembledTransaction.
  */
 export const token = {
+  name(contractId: string = CONTRACTS.usdc): Promise<AssembledTransaction<string>> {
+    return AssembledTransaction.build<string>({
+      ...options(contractId),
+      method: "name",
+      args: [],
+      parseResultXdr: (v) => String(scValToNative(v)),
+    });
+  },
   balance(owner: string, contractId: string = CONTRACTS.usdc): Promise<AssembledTransaction<bigint>> {
     return AssembledTransaction.build<bigint>({
       ...options(contractId),
@@ -57,9 +65,11 @@ export const token = {
     params: { from: string; to: string; amount: bigint },
     signer: Signer,
     contractId: string = CONTRACTS.usdc,
+    txOptions: { timeoutInSeconds?: number } = {},
   ): Promise<AssembledTransaction<null>> {
     return AssembledTransaction.build<null>({
       ...options(contractId, signer),
+      ...txOptions,
       method: "transfer",
       args: [
         new Address(params.from).toScVal(),
diff --git a/lib/stellar/deadline.ts b/lib/stellar/deadline.ts
new file mode 100644
index 0000000..674e6cb
--- /dev/null
+++ b/lib/stellar/deadline.ts
@@ -0,0 +1,40 @@
+export const DEFAULT_TX_TIMEOUT_S = 60;
+export const SAFETY_MARGIN_S = 10;
+export const MIN_TX_TIMEOUT_S = 15;
+
+export type WriteKind = "buy" | "sell" | "redeem" | "transfer";
+
+export interface TransactionDeadline {
+  timeoutInSeconds: number;
+  maxTime: number;
+}
+
+export function deadlineFor(
+  kind: WriteKind,
+  ledgerNow: number | null,
+  closeTime?: bigint,
+): TransactionDeadline {
+  if (ledgerNow === null || !Number.isFinite(ledgerNow) || ledgerNow < 0) {
+    throw new Error("Stellar ledger time is unavailable.");
+  }
+
+  if ((kind === "buy" || kind === "sell") && closeTime !== undefined) {
+    const now = Math.floor(ledgerNow);
+    const lastSafeSecond = closeTime - BigInt(SAFETY_MARGIN_S);
+    const remaining = lastSafeSecond - BigInt(now);
+    if (remaining < BigInt(MIN_TX_TIMEOUT_S)) {
+      throw new Error("This market closes in under 25 seconds, too soon to safely place a trade.");
+    }
+    const timeoutInSeconds = Math.min(DEFAULT_TX_TIMEOUT_S, Number(remaining));
+    return { timeoutInSeconds, maxTime: now + timeoutInSeconds };
+  }
+
+  const now = Math.floor(ledgerNow);
+  return { timeoutInSeconds: DEFAULT_TX_TIMEOUT_S, maxTime: now + DEFAULT_TX_TIMEOUT_S };
+}
+
+export function assertSigningDeadline(deadline: TransactionDeadline, ledgerNow: number | null): void {
+  if (ledgerNow === null || Math.floor(ledgerNow) >= deadline.maxTime - 5) {
+    throw new Error("Signing took too long; the transaction would expire. Try again.");
+  }
+}
diff --git a/lib/stellar/errors.ts b/lib/stellar/errors.ts
index be3c936..90a8098 100644
--- a/lib/stellar/errors.ts
+++ b/lib/stellar/errors.ts
@@ -59,6 +59,7 @@ export interface DescribedError {
     | "expired"
     | "unknown";
   message: string;
+  action?: "enable-usdc";
   /** Contract error name, e.g. "SlippageExceeded", when known. */
   code?: string;
 }
@@ -106,8 +107,12 @@ export function describeError(err: unknown, contract: ContractName = "marketCore
     return {
       kind: "no-trustline",
       message: "Your account has no USDC trustline. Add the USDC asset in your wallet first.",
+      action: "enable-usdc",
     };
   }
+  if (/op_low_reserve|opLowReserve|txInsufficientBalance|tx_insufficient_balance/i.test(text)) {
+    return { kind: "low-reserve", message: "Your account needs more spendable XLM to add the USDC trustline." };
+  }
   if (/balance is not sufficient|resulting balance is not within the allowed range|insufficient (balance|funds)|BalanceError|op_underfunded/i.test(text)) {
     return { kind: "insufficient-balance", message: "You don't have enough USDC for this." };
   }
diff --git a/lib/stellar/ledger-clock.ts b/lib/stellar/ledger-clock.ts
new file mode 100644
index 0000000..624dbbe
--- /dev/null
+++ b/lib/stellar/ledger-clock.ts
@@ -0,0 +1,127 @@
+import { useSyncExternalStore } from "react";
+import { rpcServer } from "./clients";
+
+export interface LedgerSample {
+  sequence: number;
+  closeTime: number;
+  observedAt: number;
+}
+
+interface LedgerPoint {
+  sequence: number;
+  closeTime: number;
+}
+
+export async function fetchLatestLedger(): Promise<LedgerPoint> {
+  const latest = await rpcServer.getLatestLedger();
+  const closeTime = Number(latest.closeTime);
+  if (!Number.isSafeInteger(latest.sequence) || !Number.isFinite(closeTime) || closeTime < 0) {
+    throw new Error("The Stellar RPC returned an invalid ledger clock sample.");
+  }
+  return { sequence: latest.sequence, closeTime };
+}
+
+export class LedgerClock {
+  private samples: LedgerSample[] = [];
+  private listeners = new Set<() => void>();
+  private pollTimer: ReturnType<typeof setInterval> | null = null;
+  private tickTimer: ReturnType<typeof setInterval> | null = null;
+  private versionValue = 0;
+
+  constructor(
+    private readonly fetchLatest: () => Promise<LedgerPoint>,
+    private readonly opts: { pollMs?: number; avgCloseSeconds?: number } = {},
+  ) {}
+
+  get version() {
+    return this.versionValue;
+  }
+
+  now(): number | null {
+    const sample = this.samples.at(-1);
+    if (!sample) return null;
+    const elapsed = (performance.now() - sample.observedAt) / 1000;
+    if (elapsed < 0.01) return sample.closeTime;
+    if (elapsed > (this.opts.pollMs ?? 10_000) / 500) return null;
+    const growthCap = this.averageCloseSeconds() * 2;
+    return sample.closeTime + Math.min(Math.max(0, elapsed), growthCap);
+  }
+
+  uncertainty(): number {
+    return this.samples.length < 2 ? this.averageCloseSeconds() : this.averageCloseSeconds() / 2;
+  }
+
+  subscribe = (listener: () => void): (() => void) => {
+    this.listeners.add(listener);
+    if (this.listeners.size === 1) this.start();
+    return () => {
+      this.listeners.delete(listener);
+      if (this.listeners.size === 0) this.stop();
+    };
+  };
+
+  start(): void {
+    if (this.pollTimer) return;
+    void this.sample();
+    this.pollTimer = setInterval(() => {
+      if (typeof document === "undefined" || document.visibilityState === "visible") void this.sample();
+    }, this.opts.pollMs ?? 10_000);
+    this.tickTimer = setInterval(() => this.notify(), 1_000);
+    if (typeof document !== "undefined") document.addEventListener("visibilitychange", this.onVisibilityChange);
+  }
+
+  stop(): void {
+    if (this.pollTimer) clearInterval(this.pollTimer);
+    if (this.tickTimer) clearInterval(this.tickTimer);
+    this.pollTimer = null;
+    this.tickTimer = null;
+    if (typeof document !== "undefined") document.removeEventListener("visibilitychange", this.onVisibilityChange);
+  }
+
+  private onVisibilityChange = () => {
+    if (typeof document === "undefined" || document.visibilityState !== "visible") return;
+    this.samples = [];
+    this.notify();
+    void this.sample();
+  };
+
+  private async sample(): Promise<void> {
+    try {
+      const next = await this.fetchLatest();
+      const previous = this.samples.at(-1);
+      if (previous && (next.sequence < previous.sequence || next.closeTime < previous.closeTime)) return;
+      if (previous && next.sequence === previous.sequence) return;
+      this.samples.push({ ...next, observedAt: performance.now() });
+      this.samples = this.samples.slice(-10);
+      this.notify();
+    } catch {
+      // An unavailable RPC must not be replaced with the machine's wall clock.
+      this.notify();
+    }
+  }
+
+  private averageCloseSeconds(): number {
+    if (this.samples.length < 2) return this.opts.avgCloseSeconds ?? 5.5;
+    let elapsed = 0;
+    let ledgers = 0;
+    for (let i = 1; i < this.samples.length; i++) {
+      const before = this.samples[i - 1];
+      const after = this.samples[i];
+      elapsed += after.closeTime - before.closeTime;
+      ledgers += after.sequence - before.sequence;
+    }
+    return ledgers > 0 ? elapsed / ledgers : this.opts.avgCloseSeconds ?? 5.5;
+  }
+
+  private notify(): void {
+    this.versionValue++;
+    this.listeners.forEach((listener) => listener());
+  }
+}
+
+const ledgerClock = new LedgerClock(fetchLatestLedger);
+
+export function useLedgerNow(): { now: number | null; uncertainty: number } {
+  useSyncExternalStore(ledgerClock.subscribe, () => ledgerClock.version, () => 0);
+  return { now: ledgerClock.now(), uncertainty: ledgerClock.uncertainty() };
+}
diff --git a/lib/stellar/quote.ts b/lib/stellar/quote.ts
new file mode 100644
index 0000000..0f339ba
--- /dev/null
+++ b/lib/stellar/quote.ts
@@ -0,0 +1,68 @@
+import type { Market } from "./generated/market-core";
+import { BPS, calcBuy, MAX_SETS, MathError } from "./generated/fpmm";
+import type { OutcomeTag } from "./clients";
+
+export type ExactBuy =
+  | { ok: true; collateralIn: bigint; sharesOut: bigint; overshoot: bigint; fee: bigint; net: bigint }
+  | { ok: false; reason: "invalid-target" | "market-too-large" | "overflow" };
+
+/**
+ * calcBuy's output is monotone: fee and net never decrease as collateralIn
+ * grows; newReserveOther grows with net, so the ceiling-rounded new bought
+ * reserve cannot increase. Thus net + reserveBought - newReserveBought cannot
+ * decrease.
+ */
+export function minCollateralForShares(
+  market: Pick<Market, "reserve_yes" | "reserve_no" | "fee_bps" | "sets_minted">,
+  outcome: OutcomeTag,
+  targetShares: bigint,
+): ExactBuy {
+  if (targetShares <= 0n) return { ok: false, reason: "invalid-target" };
+  if (targetShares > MAX_SETS) return { ok: false, reason: "market-too-large" };
+
+  const [rBought, rOther] =
+    outcome === "Yes" ? [market.reserve_yes, market.reserve_no] : [market.reserve_no, market.reserve_yes];
+  const feeBps = BigInt(market.fee_bps);
+  const headroom = MAX_SETS - market.sets_minted;
+  if (rBought <= 0n || rOther <= 0n || feeBps < 0n || feeBps >= BPS || headroom <= 0n) {
+    return { ok: false, reason: "market-too-large" };
+  }
+
+  const maxCollateralIn = (headroom * BPS) / (BPS - feeBps);
+  if (maxCollateralIn <= 0n) return { ok: false, reason: "market-too-large" };
+
+  const sharesAt = (amount: bigint) => {
+    try {
+      return calcBuy(rBought, rOther, amount, feeBps).sharesOut;
+    } catch (error) {
+      if (error instanceof MathError) return 0n;
+      throw error;
+    }
+  };
+
+  if (sharesAt(maxCollateralIn) < targetShares) return { ok: false, reason: "market-too-large" };
+
+  let low = 0n;
+  let high = maxCollateralIn;
+  while (high - low > 1n) {
+    const mid = (low + high) / 2n;
+    if (sharesAt(mid) >= targetShares) high = mid;
+    else low = mid;
+  }
+
+  try {
+    const quote = calcBuy(rBought, rOther, high, feeBps);
+    if (market.sets_minted + quote.net > MAX_SETS) return { ok: false, reason: "market-too-large" };
+    return {
+      ok: true,
+      collateralIn: high,
+      sharesOut: quote.sharesOut,
+      overshoot: quote.sharesOut - targetShares,
+      fee: quote.fee,
+      net: quote.net,
+    };
+  } catch (error) {
+    if (error instanceof MathError) return { ok: false, reason: "overflow" };
+    throw error;
+  }
+}
diff --git a/lib/stellar/sell-solver.ts b/lib/stellar/sell-solver.ts
new file mode 100644
index 0000000..4562c37
--- /dev/null
+++ b/lib/stellar/sell-solver.ts
@@ -0,0 +1,68 @@
+import { BPS, calcSell, MathError } from "./generated/fpmm";
+
+export interface SellSolution {
+  collateralOut: bigint;
+  sharesIn: bigint;
+  dust: bigint;
+  iterations: number;
+}
+
+export type SellSolveError = { error: "insufficient-liquidity" | "too-small" };
+
+/**
+ * calcSell's sharesIn is monotone: gross is non-decreasing in collateralOut;
+ * as gross grows, rOther - gross shrinks and ceil(rSold*rOther/(rOther-gross))
+ * cannot decrease. Their sum with gross therefore cannot decrease.
+ */
+export function solveSellForShares(
+  rSold: bigint,
+  rOther: bigint,
+  shareBudget: bigint,
+  feeBps: bigint,
+): SellSolution | SellSolveError {
+  if (rSold <= 0n || rOther <= 0n || feeBps < 0n || feeBps >= BPS) {
+    return { error: "insufficient-liquidity" };
+  }
+  if (shareBudget <= 0n) return { error: "too-small" };
+
+  // For calcSell to remain liquid, gross must be at most rOther - 1.
+  const maxCollateralOut = ((rOther - 1n) * (BPS - feeBps)) / BPS;
+  if (maxCollateralOut <= 0n) return { error: "insufficient-liquidity" };
+
+  let low = 0n;
+  let high = maxCollateralOut + 1n;
+  let iterations = 0;
+
+  while (high - low > 1n) {
+    const mid = (low + high) / 2n;
+    iterations++;
+    try {
+      if (calcSell(rSold, rOther, mid, feeBps).sharesIn <= shareBudget) low = mid;
+      else high = mid;
+    } catch (error) {
+      if (!(error instanceof MathError)) throw error;
+      high = mid;
+    }
+  }
+
+  if (low === 0n) return { error: "too-small" };
+  const sharesIn = calcSell(rSold, rOther, low, feeBps).sharesIn;
+  return { collateralOut: low, sharesIn, dust: shareBudget - sharesIn, iterations };
+}
+
+/**
+ * Confirm the local math against quote_sell. A caller can refetch reserves
+ * and re-solve when the quoted share count differs.
+ */
+export async function reconcileWithQuote(
+  local: SellSolution,
+  quote: (collateralOut: bigint) => Promise<bigint>,
+): Promise<SellSolution> {
+  const sharesIn = await quote(local.collateralOut);
+  if (sharesIn === local.sharesIn) return local;
+  return {
+    ...local,
+    sharesIn,
+    dust: local.dust + local.sharesIn - sharesIn,
+  };
+}
diff --git a/lib/stellar/trustline.ts b/lib/stellar/trustline.ts
new file mode 100644
index 0000000..27c78dd
--- /dev/null
+++ b/lib/stellar/trustline.ts
@@ -0,0 +1,165 @@
+import {
+  Address,
+  Asset,
+  BASE_FEE,
+  Operation,
+  TransactionBuilder,
+  xdr,
+} from "@stellar/stellar-sdk";
+import { rpcServer, token } from "./clients";
+import { CONTRACTS, NETWORK_PASSPHRASE } from "./config";
+import type { Signer } from "./clients";
+import { describeError, UserFacingError } from "./errors";
+
+export type TrustlineState =
+  | { kind: "native" }
+  | { kind: "present"; authorized: boolean; balance: bigint; limit: bigint }
+  | { kind: "missing" }
+  | { kind: "account-missing" };
+
+const assetNameCache = new Map<string, Promise<Asset>>();
+
+export function usdcClassicAsset(): Promise<Asset> {
+  let pending = assetNameCache.get(CONTRACTS.usdc);
+  if (!pending) {
+    pending = (async () => {
+      const transaction = await token.name(CONTRACTS.usdc);
+      const result: unknown = transaction.result;
+      const name =
+        result && typeof result === "object" && "isOk" in result &&
+        typeof (result as { isOk: unknown }).isOk === "function"
+          ? (result as { isOk(): boolean; unwrap(): string }).unwrap()
+          : (result as string);
+      if (name === "native") return Asset.native();
+      const separator = name.lastIndexOf(":");
+      if (separator <= 0 || separator === name.length - 1) {
+        throw new Error(`Unexpected SAC asset name: ${name}`);
+      }
+      const asset = new Asset(name.slice(0, separator), name.slice(separator + 1));
+      if (asset.contractId(NETWORK_PASSPHRASE) !== CONTRACTS.usdc) {
+        throw new Error("The configured USDC contract does not match the asset it wraps.");
+      }
+      return asset;
+    })();
+    assetNameCache.set(CONTRACTS.usdc, pending);
+  }
+  return pending;
+}
+
+export async function getTrustlineState(account: string, asset: Asset): Promise<TrustlineState> {
+  if (asset.isNative()) return { kind: "native" };
+
+  const address = new Address(account).toScAddress();
+  const keys = [
+    xdr.LedgerKey.account(new xdr.LedgerKeyAccount({ accountId: address })),
+    xdr.LedgerKey.trustLine(
+      new xdr.LedgerKeyTrustLine({ accountId: address, asset: asset.toTrustLineXDRObject() }),
+    ),
+  ];
+  const { entries } = await rpcServer.getLedgerEntries(...keys);
+  const accountEntry = entries.find((entry) => entry.key.switch().name === "account");
+  if (!accountEntry) return { kind: "account-missing" };
+  const trustlineEntry = entries.find((entry) => entry.key.switch().name === "trustline");
+  if (!trustlineEntry) return { kind: "missing" };
+
+  const trustline = trustlineEntry.val.trustLine();
+  const authorized = (trustline.flags() & xdr.TrustLineFlags.authorizedFlag().value) !== 0;
+  return {
+    kind: "present",
+    authorized,
+    balance: BigInt(trustline.balance().toString()),
+    limit: BigInt(trustline.limit().toString()),
+  };
+}
+
+function accountExtensionV1(account: xdr.AccountEntry) {
+  const ext = account.ext();
+  return ext.switch() === 1 ? ext.v1() : null;
+}
+
+export async function reserveCheck(
+  address: string,
+): Promise<{ ok: boolean; spendable: bigint; required: bigint }> {
+  const account = await rpcServer.getAccountEntry(address);
+  const v1 = accountExtensionV1(account);
+  const v2 = v1?.ext().switch() === 2 ? v1.ext().v2() : null;
+  const numSponsoring = BigInt(v2?.numSponsoring() ?? 0);
+  const numSponsored = BigInt(v2?.numSponsored() ?? 0);
+  let baseReserve = 5_000_000n;
+  try {
+    const latest = await rpcServer.getLatestLedger();
+    baseReserve = BigInt(latest.headerXdr.baseReserve());
+  } catch {
+    // Older RPC endpoints may not return ledger headers; Stellar's base reserve is 0.5 XLM.
+  }
+  const minimumBalance =
+    (2n + BigInt(account.numSubEntries()) + numSponsoring - numSponsored) * baseReserve;
+  const sellingLiabilities = BigInt(v1?.liabilities().selling().toString() ?? "0");
+  const spendable = BigInt(account.balance().toString()) - minimumBalance - sellingLiabilities;
+  const required = baseReserve + BigInt(BASE_FEE);
+  return { ok: spendable >= required, spendable, required };
+}
+
+export async function buildChangeTrustXdr(address: string, asset: Asset): Promise<string> {
+  const [account, feeStats] = await Promise.all([rpcServer.getAccount(address), rpcServer.getFeeStats()]);
+  const recommended = BigInt(feeStats.inclusionFee.p70 || BASE_FEE);
+  const fee = recommended > 10_000n ? 10_000n : recommended > BigInt(BASE_FEE) ? recommended : BigInt(BASE_FEE);
+  return new TransactionBuilder(account, {
+    fee: fee.toString(),
+    networkPassphrase: NETWORK_PASSPHRASE,
+  })
+    .addOperation(Operation.changeTrust({ asset }))
+    .setTimeout(120)
+    .build()
+    .toXDR();
+}
+
+const wait = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+export async function submitAndPoll(
+  signedXdr: string,
+  opts: { timeoutMs?: number } = {},
+): Promise<{ hash: string }> {
+  const tx = TransactionBuilder.fromXDR(signedXdr, NETWORK_PASSPHRASE);
+  let response = await rpcServer.sendTransaction(tx);
+  if (response.status === "TRY_AGAIN_LATER") {
+    await wait(2_000);
+    response = await rpcServer.sendTransaction(tx);
+  }
+  if (response.status === "ERROR") {
+    const described = describeError(response.errorResultXdr ?? "Transaction submission failed");
+    throw new UserFacingError(described, response.errorResultXdr);
+  }
+  if (response.status !== "PENDING" && response.status !== "DUPLICATE") {
+    throw new Error(`Unexpected transaction submission status: ${response.status}`);
+  }
+
+  const deadline = Date.now() + (opts.timeoutMs ?? 60_000);
+  let delay = 500;
+  while (Date.now() < deadline) {
+    await wait(delay);
+    const result = await rpcServer.getTransaction(response.hash);
+    if (result.status === "SUCCESS") return { hash: response.hash };
+    if (result.status === "FAILED") {
+      throw new UserFacingError(describeError(result.resultXdr.toXDR("base64")), result.resultXdr);
+    }
+    delay = Math.min(delay * 2, 4_000);
+  }
+  throw new Error("The trustline transaction is still pending. Check your wallet before retrying.");
+}
+
+export async function enableUsdcTrustline(address: string, asset: Asset, signer: Signer): Promise<{ hash: string }> {
+  const reserve = await reserveCheck(address);
+  if (!reserve.ok) {
+    const neededXlm = reserve.required - reserve.spendable;
+    throw new UserFacingError({
+      kind: "low-reserve",
+      message: `Add at least ${(Number(neededXlm) / 10_000_000).toFixed(2)} XLM to cover the USDC trustline reserve and fee.`,
+    });
+  }
+
+  const unsignedXdr = await buildChangeTrustXdr(address, asset);
+  const signed = await signer.signTransaction(unsignedXdr, { networkPassphrase: NETWORK_PASSPHRASE });
+  if (signed.error) throw new UserFacingError(describeError(signed.error), signed.error);
+  return submitAndPoll(signed.signedTxXdr);
+}