@b3dotfun/sdk 0.1.70-alpha.21 → 0.1.70-alpha.22

package/dist/esm/global-account/react/components/B3Provider/BetterAuthProvider.js

@@ -59,20 +59,27 @@ const BetterAuthProvider = ({ partnerId }) => {
         hasAttemptedRestore.current = true;
         const restoreSession = async () => {
             debug("Attempting session restore");
+            // A _ba_token in the URL OUTRANKS a cached Feathers JWT: the user just
+            // arrived through a live sign-in link (magic link / OAuth callback), and
+            // restoring a previous identity first would strand them as the wrong
+            // user with the token silently dropped.
+            const incomingBaToken = new URLSearchParams(window.location.search).get("_ba_token");
             // 1. Try existing Feathers JWT first (fastest — no network call to Better Auth)
-            try {
-                const response = await app.reAuthenticate();
-                if (response?.user) {
-                    debug("Feathers JWT restored", { userId: response.user.userId });
-                    setUser(response.user);
-                    setIsAuthenticated(true);
-                    setIsConnected(true);
-                    setIsAuthenticating(false);
-                    return;
+            if (!incomingBaToken) {
+                try {
+                    const response = await app.reAuthenticate();
+                    if (response?.user) {
+                        debug("Feathers JWT restored", { userId: response.user.userId });
+                        setUser(response.user);
+                        setIsAuthenticated(true);
+                        setIsConnected(true);
+                        setIsAuthenticating(false);
+                        return;
+                    }
+                }
+                catch {
+                    debug("No existing Feathers JWT");
                 }
-            }
-            catch {
-                debug("No existing Feathers JWT");
             }
             // 2. Check for _ba_token in URL (OAuth callback with third-party cookie bypass).
             //    When the API and frontend are on different domains, browsers with third-party
@@ -112,6 +119,23 @@ const BetterAuthProvider = ({ partnerId }) => {
                 }
                 catch (err) {
                     debug("_ba_token exchange failed", err);
+                    // A dead injected token (expired link param, revoked session) must
+                    // not strand a user who HAS a valid cached session — fall back to
+                    // the reAuthenticate lane the token's presence skipped.
+                    try {
+                        const cached = await app.reAuthenticate();
+                        if (cached?.user) {
+                            debug("Fell back to cached Feathers JWT after _ba_token failure", { userId: cached.user.userId });
+                            setUser(cached.user);
+                            setIsAuthenticated(true);
+                            setIsConnected(true);
+                            setIsAuthenticating(false);
+                            return;
+                        }
+                    }
+                    catch {
+                        debug("No cached session to fall back to");
+                    }
                 }
             }
             // 3. Check for a Better Auth session via cookie (works when API and frontend

package/dist/types/anyspend/react/components/AnySpend.d.ts

@@ -64,6 +64,13 @@ export declare function AnySpend(props: {
     allowDirectTransfer?: boolean;
     /** Fixed destination token amount (in wei/smallest unit). When provided, user cannot change the amount. */
     destinationTokenAmount?: string;
+    /**
+     * Editable default destination token amount (in wei/smallest unit). Seeds the same
+     * destination-amount input as `destinationTokenAmount`, but leaves it user-editable. Ignored
+     * when `destinationTokenAmount` is also set — that prop locks the field and wins.
+     * Seeds the field once on first apply; a later change to this value does not re-fill it, so it never overwrites what the user typed.
+     */
+    defaultDestinationTokenAmount?: string;
     /** Opaque metadata passed to the order for callbacks (e.g., workflow form data) */
     callbackMetadata?: Record<string, unknown>;
     /** Optional sender (payer) address — pre-fills token balances when the user address is known ahead of time */
@@ -78,4 +85,16 @@ export declare function AnySpend(props: {
     kycEnabled?: boolean;
     /** Whether to show the "Pay with Fiat" tab. Defaults to true. When false, the fiat tab is hidden and activeTab is forced to "crypto". */
     showFiatOption?: boolean;
+    /**
+     * Internal: true when `AnySpendDeposit` has an amount to prefill (`defaultDestinationTokenAmount`
+     * set), as opposed to any other `AnySpend`/`AnySpendDeposit` usage. Only changes
+     * `CryptoReceiveSection`'s fixed-destination branch: it lets the receive amount become an
+     * editable input (still gated by `disableAmountInput`) instead of a read-only display. Scoped
+     * this narrowly on purpose — `AnySpendDeposit` backs 15+ funding modals that are source-exact-in
+     * (the user sets the "pay with" amount; the receive side is an intended computed display), so
+     * this must stay off for all of them and only turn on for the one page that actually prefills a
+     * receive amount. Not intended for external callers — `AnySpendDeposit` derives this itself.
+     * @internal
+     */
+    isDepositMode?: boolean;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/types/anyspend/react/components/AnySpendDeposit.d.ts

@@ -116,6 +116,14 @@ export interface AnySpendDepositProps {
     pureTransferOnly?: boolean;
     /** Fixed destination token amount (in wei/smallest unit). When provided, user cannot change the amount. */
     destinationTokenAmount?: string;
+    /**
+     * Editable default destination token amount (in wei/smallest unit). Seeds the same
+     * destination-amount input as `destinationTokenAmount`, but leaves it user-editable. Ignored
+     * when `destinationTokenAmount` is also set — that prop locks the field and wins. Applies to
+     * the standard deposit flow only; custom-function deposits ignore it.
+     * Seeds the field once on first apply; a later change to this value does not re-fill it, so it never overwrites what the user typed.
+     */
+    defaultDestinationTokenAmount?: string;
     /** Opaque metadata passed to the order for callbacks (e.g., workflow form data) */
     callbackMetadata?: Record<string, unknown>;
     /** Optional sender (payer) address — pre-fills token balances when the user address is known ahead of time */
@@ -162,4 +170,4 @@ export interface AnySpendDepositProps {
  *   onSuccess={(amount) => console.log(`Deposited ${amount}`)}
  * />
  */
-export declare function AnySpendDeposit({ loadOrder, mode, recipientAddress, paymentType: initialPaymentType, sourceTokenAddress, sourceTokenChainId: initialSourceChainId, destinationTokenAddress, destinationTokenChainId, lockDestinationToken, onSuccess, onOpenCustomModal, mainFooter, onTokenSelect, customUsdInputValues, preferEoa, minDestinationAmount, header, orderType, depositContractConfig, showChainSelection, showFiatOption, supportedChains, topChainsCount, onClose, returnToHomeUrl, customRecipientLabel, returnHomeLabel, isCustomDeposit, classes, allowDirectTransfer, pureTransferOnly, destinationTokenAmount, callbackMetadata, senderAddress, slots, content, theme, }: AnySpendDepositProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function AnySpendDeposit({ loadOrder, mode, recipientAddress, paymentType: initialPaymentType, sourceTokenAddress, sourceTokenChainId: initialSourceChainId, destinationTokenAddress, destinationTokenChainId, lockDestinationToken, onSuccess, onOpenCustomModal, mainFooter, onTokenSelect, customUsdInputValues, preferEoa, minDestinationAmount, header, orderType, depositContractConfig, showChainSelection, showFiatOption, supportedChains, topChainsCount, onClose, returnToHomeUrl, customRecipientLabel, returnHomeLabel, isCustomDeposit, classes, allowDirectTransfer, pureTransferOnly, destinationTokenAmount, defaultDestinationTokenAmount, callbackMetadata, senderAddress, slots, content, theme, }: AnySpendDepositProps): import("react/jsx-runtime").JSX.Element | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b3dotfun/sdk",
-  "version": "0.1.70-alpha.21",
+  "version": "0.1.70-alpha.22",
   "source": "src/index.ts",
   "main": "./dist/cjs/index.js",
   "react-native": "./dist/cjs/index.native.js",

package/src/anyspend/react/components/AnySpend.tsx

@@ -146,6 +146,13 @@ export function AnySpend(props: {
   allowDirectTransfer?: boolean;
   /** Fixed destination token amount (in wei/smallest unit). When provided, user cannot change the amount. */
   destinationTokenAmount?: string;
+  /**
+   * Editable default destination token amount (in wei/smallest unit). Seeds the same
+   * destination-amount input as `destinationTokenAmount`, but leaves it user-editable. Ignored
+   * when `destinationTokenAmount` is also set — that prop locks the field and wins.
+   * Seeds the field once on first apply; a later change to this value does not re-fill it, so it never overwrites what the user typed.
+   */
+  defaultDestinationTokenAmount?: string;
   /** Opaque metadata passed to the order for callbacks (e.g., workflow form data) */
   callbackMetadata?: Record<string, unknown>;
   /** Optional sender (payer) address — pre-fills token balances when the user address is known ahead of time */
@@ -160,6 +167,18 @@ export function AnySpend(props: {
   kycEnabled?: boolean;
   /** Whether to show the "Pay with Fiat" tab. Defaults to true. When false, the fiat tab is hidden and activeTab is forced to "crypto". */
   showFiatOption?: boolean;
+  /**
+   * Internal: true when `AnySpendDeposit` has an amount to prefill (`defaultDestinationTokenAmount`
+   * set), as opposed to any other `AnySpend`/`AnySpendDeposit` usage. Only changes
+   * `CryptoReceiveSection`'s fixed-destination branch: it lets the receive amount become an
+   * editable input (still gated by `disableAmountInput`) instead of a read-only display. Scoped
+   * this narrowly on purpose — `AnySpendDeposit` backs 15+ funding modals that are source-exact-in
+   * (the user sets the "pay with" amount; the receive side is an intended computed display), so
+   * this must stay off for all of them and only turn on for the one page that actually prefills a
+   * receive amount. Not intended for external callers — `AnySpendDeposit` derives this itself.
+   * @internal
+   */
+  isDepositMode?: boolean;
 }) {
   const fingerprintConfig = getFingerprintConfig();
 
@@ -194,10 +213,12 @@ function AnySpendInner({
   classes,
   allowDirectTransfer = false,
   destinationTokenAmount,
+  defaultDestinationTokenAmount,
   callbackMetadata,
   senderAddress,
   kycEnabled = false,
   showFiatOption = true,
+  isDepositMode = false,
 }: {
   sourceChainId?: number;
   destinationTokenAddress?: string;
@@ -220,6 +241,7 @@ function AnySpendInner({
   classes?: AnySpendClasses;
   allowDirectTransfer?: boolean;
   destinationTokenAmount?: string;
+  defaultDestinationTokenAmount?: string;
   callbackMetadata?: Record<string, unknown>;
   senderAddress?: string;
   slots?: AnySpendSlots;
@@ -227,6 +249,7 @@ function AnySpendInner({
   theme?: AnySpendTheme;
   kycEnabled?: boolean;
   showFiatOption?: boolean;
+  isDepositMode?: boolean;
 }) {
   const { slots, content } = useAnySpendCustomization();
   const searchParams = useSearchParamsSSR();
@@ -438,6 +461,21 @@ function AnySpendInner({
   }, [selectedDstToken, isBuyMode]);
 
   const [isSrcInputDirty, setIsSrcInputDirty] = useState(true);
+  // Synchronous mirror of `isSrcInputDirty`. `setIsSrcInputDirty` is async relative to OTHER
+  // effects in the same commit — the quote effect (declared later, same commit) would otherwise
+  // read a pre-flip closure value and clear a just-seeded receive amount before it ever paints.
+  // Every flip goes through `markSrcDirty`, which writes this ref in the same statement, so
+  // same-commit siblings always see the latest intent. Deliberately NOT kept in sync by its own
+  // effect: an effect reading `isSrcInputDirty` from its closure would itself go stale across
+  // React 18 StrictMode's dev-mode double-invoke of mount effects (same closure re-run twice)
+  // and re-stomp this ref back to the pre-flip value between the two passes.
+  const isSrcInputDirtyRef = useRef(isSrcInputDirty);
+  // Single writer for the direction flag: keeps state and its synchronous ref mirror in lockstep
+  // so no call site — parent or child (CryptoPaySection) — can flip one without the other.
+  const markSrcDirty = useCallback((next: boolean) => {
+    setIsSrcInputDirty(next);
+    isSrcInputDirtyRef.current = next;
+  }, []);
   // Add refs to track if we've applied metadata
   const appliedSrcMetadataRef = useRef(false);
   const appliedDstMetadataRef = useRef(false);
@@ -500,17 +538,23 @@ function AnySpendInner({
     appliedDstMetadataRef.current = false;
   }, [selectedDstToken.address, selectedDstToken.chainId]);
 
-  // Prefill destination amount if provided (for fixed amount mode)
+  // Prefill destination amount if provided — fixed (locking) mode wins over the editable default,
+  // since `destinationTokenAmount` also disables the input (see `disableAmountInput` below).
   const appliedDestinationAmount = useRef(false);
+  const seedDestinationAmount = destinationTokenAmount ?? defaultDestinationTokenAmount;
   useEffect(() => {
     // Only apply when we have real metadata (not default decimals)
-    if (destinationTokenAmount && dstTokenMetadata?.decimals && !appliedDestinationAmount.current) {
-      appliedDestinationAmount.current = true;
-      const formattedAmount = formatUnits(BigInt(destinationTokenAmount), dstTokenMetadata.decimals);
-      setDstAmount(formattedAmount);
-      setIsSrcInputDirty(false); // Switch to EXACT_OUTPUT mode
+    if (seedDestinationAmount && dstTokenMetadata?.decimals && !appliedDestinationAmount.current) {
+      try {
+        const formattedAmount = formatUnits(BigInt(seedDestinationAmount), dstTokenMetadata.decimals);
+        appliedDestinationAmount.current = true;
+        setDstAmount(formattedAmount);
+        markSrcDirty(false); // Switch to EXACT_OUTPUT mode
+      } catch {
+        // invalid seed value — no-op rather than throw into the effect (fail-closed)
+      }
     }
-  }, [destinationTokenAmount, dstTokenMetadata]);
+  }, [seedDestinationAmount, dstTokenMetadata, markSrcDirty]);
 
   // Load swap configuration from URL on initial render
   useEffect(() => {
@@ -535,7 +579,7 @@ function AnySpendInner({
               setSrcAmountOnRamp(fromAmountParam);
             } else {
               setSrcAmount(fromAmountParam);
-              setIsSrcInputDirty(true);
+              markSrcDirty(true);
             }
           }
         } catch (error) {
@@ -548,7 +592,7 @@ function AnySpendInner({
 
     // Mark that we've processed the initial URL
     initialUrlProcessed.current = true;
-  }, [searchParams, loadOrder, disableUrlParamManagement]);
+  }, [searchParams, loadOrder, disableUrlParamManagement, markSrcDirty]);
 
   // Update URL when swap configuration changes - but not on initial load
   const updateSwapParamsInURL = useCallback(() => {
@@ -805,6 +849,14 @@ function AnySpendInner({
 
   // Update dependent amount when relay price changes
   useEffect(() => {
+    // Read the ref (not the closed-over `isSrcInputDirty` param) for the branch decision: the
+    // SEED effect (declared above, same commit when it fires) writes to the ref synchronously
+    // when it flips this to exact-out mode, so this effect sees that flip immediately even
+    // though `setIsSrcInputDirty`'s state update won't be visible in THIS render's closure until
+    // the next commit. Using the stale closure value here was the actual bug — it caused this
+    // effect to still treat a freshly-seeded exact-out amount as exact-in-with-no-data and clear
+    // it before it ever painted. The dependency array below stays on the real state, so this
+    // effect still re-runs correctly on every genuine transition.
     if (
       anyspendQuote?.data &&
       anyspendQuote.data.currencyIn?.amount &&
@@ -812,7 +864,7 @@ function AnySpendInner({
       anyspendQuote.data.currencyOut?.amount &&
       anyspendQuote.data.currencyOut?.currency?.decimals
     ) {
-      if (isSrcInputDirty) {
+      if (isSrcInputDirtyRef.current) {
         // The user is driving the SOURCE (exact-in): reflect the quote's OUTPUT even
         // when a fixed destinationTokenAmount pre-filled the receive. That lock only
         // governs the INITIAL exact-out state (untouched source → compute the pay for
@@ -828,7 +880,7 @@ function AnySpendInner({
         setSrcAmount(formatTokenAmount(BigInt(amount), decimals, 6, false));
       }
     } else {
-      if (isSrcInputDirty) {
+      if (isSrcInputDirtyRef.current) {
         setDstAmount("");
       } else {
         setSrcAmount("");
@@ -1446,7 +1498,7 @@ function AnySpendInner({
               srcAmount={srcAmount}
               setSrcAmount={setSrcAmount}
               isSrcInputDirty={isSrcInputDirty}
-              setIsSrcInputDirty={setIsSrcInputDirty}
+              setIsSrcInputDirty={markSrcDirty}
               selectedCryptoPaymentMethod={effectiveCryptoPaymentMethod}
               onSelectCryptoPaymentMethod={() => navigateToPanel(PanelView.CRYPTO_PAYMENT_METHOD, "forward")}
               anyspendQuote={anyspendQuote}
@@ -1537,7 +1589,7 @@ function AnySpendInner({
           {/* Receive section - Hidden when fiat tab is active */}
           {activeTab === "crypto" && (
             <CryptoReceiveSection
-              isDepositMode={false}
+              isDepositMode={isDepositMode}
               isBuyMode={isBuyMode}
               effectiveRecipientAddress={effectiveRecipientAddress}
               recipientName={recipientName || undefined}
@@ -1550,7 +1602,7 @@ function AnySpendInner({
               setSelectedDstToken={setSelectedDstToken}
               isSrcInputDirty={isSrcInputDirty}
               onChangeDstAmount={value => {
-                setIsSrcInputDirty(false);
+                markSrcDirty(false);
                 setDstAmount(value);
               }}
               disableAmountInput={!!destinationTokenAmount}

package/src/anyspend/react/components/AnySpendDeposit.tsx

@@ -140,6 +140,14 @@ export interface AnySpendDepositProps {
   pureTransferOnly?: boolean;
   /** Fixed destination token amount (in wei/smallest unit). When provided, user cannot change the amount. */
   destinationTokenAmount?: string;
+  /**
+   * Editable default destination token amount (in wei/smallest unit). Seeds the same
+   * destination-amount input as `destinationTokenAmount`, but leaves it user-editable. Ignored
+   * when `destinationTokenAmount` is also set — that prop locks the field and wins. Applies to
+   * the standard deposit flow only; custom-function deposits ignore it.
+   * Seeds the field once on first apply; a later change to this value does not re-fill it, so it never overwrites what the user typed.
+   */
+  defaultDestinationTokenAmount?: string;
   /** Opaque metadata passed to the order for callbacks (e.g., workflow form data) */
   callbackMetadata?: Record<string, unknown>;
   /** Optional sender (payer) address — pre-fills token balances when the user address is known ahead of time */
@@ -289,6 +297,7 @@ export function AnySpendDeposit({
   allowDirectTransfer = false,
   pureTransferOnly = false,
   destinationTokenAmount,
+  defaultDestinationTokenAmount,
   callbackMetadata,
   senderAddress,
   slots,
@@ -845,6 +854,10 @@ export function AnySpendDeposit({
             destinationTokenAddress={destinationTokenAddress}
             destinationTokenChainId={destinationTokenChainId}
             lockDestinationToken={lockDestinationToken}
+            // Scoped to ONLY the prefill case (not every AnySpendDeposit caller — 15+ other
+            // funding modals rely on the source-exact-in "computed display" behavior this would
+            // otherwise change): editable destination amount only when there's a value to seed.
+            isDepositMode={!!defaultDestinationTokenAmount}
             onSuccess={txHash => onSuccess?.(txHash ?? "")}
             onTokenSelect={onTokenSelect}
             customUsdInputValues={customUsdInputValues}
@@ -857,6 +870,7 @@ export function AnySpendDeposit({
             classes={classes?.anySpend}
             allowDirectTransfer={allowDirectTransfer}
             destinationTokenAmount={destinationTokenAmount}
+            defaultDestinationTokenAmount={defaultDestinationTokenAmount}
             callbackMetadata={callbackMetadata}
             senderAddress={senderAddress}
             showFiatOption={showFiatOption}

package/src/anyspend/react/components/__tests__/AnySpend.seedEffect.test.tsx

@@ -0,0 +1,191 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { formatUnits } from "viem";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { StrictMode, useCallback, useEffect, useRef, useState } from "react";
+import { describe, expect, it } from "vitest";
+
+/**
+ * Regression test for fix round 3: the destination-amount prefill (`defaultDestinationTokenAmount`)
+ * never reached the visible input on the live `/b3os-deposit?...&amount=...` page, even though the
+ * SEED effect in `AnySpend.tsx` fired and called `setDstAmount(formattedAmount)`.
+ *
+ * Root cause (confirmed via live console instrumentation, not guessed): `AnySpend.tsx` declares two
+ * effects that both touch `dstAmount` — SEED (prefills from `defaultDestinationTokenAmount` once
+ * `dstTokenMetadata` resolves) and QUOTE (mirrors the relay quote into `dstAmount`/`srcAmount`,
+ * branching on `isSrcInputDirty`). On the `/b3os-deposit` page, `dstTokenMetadata` for the
+ * destination token is already resolved by the time `<AnySpend>` mounts, so SEED and QUOTE both run
+ * within the SAME initial-mount effects flush. SEED flips `isSrcInputDirty` to false, but that state
+ * update isn't visible in QUOTE's closure until the NEXT render — so within that same flush, QUOTE
+ * still reads the stale `isSrcInputDirty === true` and, seeing no quote data yet (the quote query is
+ * disabled until a nonzero destination amount seeds the swap), clears `dstAmount` back to ""
+ * immediately after SEED set it. The fix mirrors `isSrcInputDirty` into a ref written in the same
+ * statement as the state flip, and has QUOTE read `isSrcInputDirtyRef.current`.
+ *
+ * Fix round 4 tightens that ref-sync into a SINGLE writer, `markSrcDirty`, that flips state and ref
+ * together. The earlier round wrote the ref inline at three of four call sites, but the fourth — the
+ * `setIsSrcInputDirty` prop handed to `CryptoPaySection` (the pay-amount input) — passed the RAW
+ * state setter, so typing a source amount after an exact-out prefill flipped state to true while the
+ * ref stayed false. The next quote then took the EXACT_OUTPUT branch and froze the receive amount
+ * instead of mirroring a fresh quote. Routing every write (SEED, URL-loader, dst-amount handler, AND
+ * the CryptoPaySection prop) through `markSrcDirty` closes that gap for present and future callers.
+ *
+ * This harness copies the SEED and QUOTE effects out of `AnySpend.tsx` verbatim (same state names,
+ * same `markSrcDirty` single-writer shape, same effect bodies and dependency arrays — see
+ * `AnySpend.tsx`'s ref declaration, SEED effect, and QUOTE effect), rather than mounting the real
+ * `<AnySpend>` component. A full mount needs ~20 hooks (auth, wallet, router, modal store,
+ * geo-onramp, gas price, quote, create-order, payment-method state, etc.) mocked with controllable
+ * return values just to reach this effect pair — the same tradeoff already made twice in this suite
+ * for much smaller subtrees (see the doc comments in `CryptoReceiveSection.test.tsx` and
+ * `AnySpendDeposit.isDepositMode.test.tsx`). What this test verifies instead is the exact mechanism
+ * that broke: real React 18 timing (uncontrolled, unmocked), under `StrictMode` so the double-invoke
+ * this bug depended on is actually exercised, plus a source-scan lock so no future call site can
+ * reintroduce a bare setter that bypasses the ref.
+ */
+
+const DST_DECIMALS = 18;
+const SEED_AMOUNT_WEI = "100000000000000000"; // 0.1 ETH, matching the live repro's &amount= param
+const TYPED_PAY_AMOUNT = "0.05"; // what the user types into the PAY field after the prefill lands
+const FRESH_QUOTE_DST = "0.099"; // stand-in for a fresh quote's currencyOut (receive) amount
+const FRESH_QUOTE_SRC = "0.101"; // stand-in for a fresh quote's currencyIn (pay) amount
+
+function SeedEffectHarness({ hasQuoteData }: { hasQuoteData: boolean }) {
+  const [dstAmount, setDstAmount] = useState("");
+  const [srcAmount, setSrcAmount] = useState("");
+  const [isSrcInputDirty, setIsSrcInputDirty] = useState(true);
+  const isSrcInputDirtyRef = useRef(isSrcInputDirty);
+
+  // Single writer for the direction flag (verbatim shape from AnySpend.tsx): flips state and its
+  // synchronous ref mirror together, so no call site — including the pay-input path below — can
+  // flip one without the other.
+  const markSrcDirty = useCallback((next: boolean) => {
+    setIsSrcInputDirty(next);
+    isSrcInputDirtyRef.current = next;
+  }, []);
+
+  const appliedDestinationAmount = useRef(false);
+  // dstTokenMetadata is available synchronously from the first render — this is the precondition
+  // that put SEED and QUOTE in the SAME initial-mount effects flush on the live page.
+  const dstTokenMetadata = { decimals: DST_DECIMALS };
+
+  // --- SEED effect (verbatim from AnySpend.tsx) ---
+  useEffect(() => {
+    if (SEED_AMOUNT_WEI && dstTokenMetadata?.decimals && !appliedDestinationAmount.current) {
+      appliedDestinationAmount.current = true;
+      const formattedAmount = formatUnits(BigInt(SEED_AMOUNT_WEI), dstTokenMetadata.decimals);
+      setDstAmount(formattedAmount);
+      markSrcDirty(false); // Switch to EXACT_OUTPUT mode
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [dstTokenMetadata]);
+
+  // --- QUOTE effect (verbatim from AnySpend.tsx) ---
+  useEffect(() => {
+    if (hasQuoteData) {
+      if (isSrcInputDirtyRef.current) {
+        setDstAmount(FRESH_QUOTE_DST); // stand-in for a real quote's currencyOut amount
+      } else {
+        setSrcAmount(FRESH_QUOTE_SRC); // stand-in for a real quote's currencyIn amount
+      }
+    } else {
+      if (isSrcInputDirtyRef.current) {
+        setDstAmount("");
+      } else {
+        setSrcAmount("");
+      }
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [hasQuoteData, isSrcInputDirty]);
+
+  // Simulates CryptoPaySection's pay-amount onChangeInput, which now receives `markSrcDirty` as its
+  // `setIsSrcInputDirty` prop in AnySpend.tsx. Fires AFTER the exact-out prefill has landed.
+  const onPayInput = () => {
+    markSrcDirty(true);
+    setSrcAmount(TYPED_PAY_AMOUNT);
+  };
+
+  return (
+    <div>
+      <div data-testid="dst-amount">{dstAmount}</div>
+      <div data-testid="src-amount">{srcAmount}</div>
+      <button data-testid="pay-input" onClick={onPayInput}>
+        edit pay
+      </button>
+    </div>
+  );
+}
+
+describe("AnySpend seed/quote effect race (fix round 3)", () => {
+  it("prefill survives the same-commit SEED+QUOTE race with no quote data yet (matches the live /b3os-deposit repro)", () => {
+    render(
+      <StrictMode>
+        <SeedEffectHarness hasQuoteData={false} />
+      </StrictMode>,
+    );
+
+    // Bug: this was "" — QUOTE's stale isSrcInputDirty read clobbered SEED's setDstAmount("0.1").
+    expect(screen.getByTestId("dst-amount").textContent).toBe("0.1");
+  });
+
+  it("prefill survives when a quote resolves in the same flush (isSrcInputDirtyRef routes the quote to srcAmount, not dstAmount)", () => {
+    render(
+      <StrictMode>
+        <SeedEffectHarness hasQuoteData={true} />
+      </StrictMode>,
+    );
+
+    // Once seeded, the swap is exact-out: a resolving quote should update the PAY side,
+    // leaving the seeded receive amount untouched.
+    expect(screen.getByTestId("dst-amount").textContent).toBe("0.1");
+    expect(screen.getByTestId("src-amount").textContent).toBe(FRESH_QUOTE_SRC);
+  });
+});
+
+describe("AnySpend pay-side edit after exact-out prefill (fix round 4)", () => {
+  it("editing the PAY amount re-quotes the receive side because markSrcDirty flips the ref, not just state", () => {
+    render(
+      <StrictMode>
+        <SeedEffectHarness hasQuoteData={true} />
+      </StrictMode>,
+    );
+
+    // Precondition: the exact-out prefill landed and the quote routed to the PAY side.
+    expect(screen.getByTestId("dst-amount").textContent).toBe("0.1");
+    expect(screen.getByTestId("src-amount").textContent).toBe(FRESH_QUOTE_SRC);
+
+    // User edits the PAY amount. Through the RAW setter this flipped state true but left the ref
+    // false, so the next quote took the EXACT_OUTPUT branch — freezing the receive amount at the
+    // seeded 0.1 and overwriting the typed pay value. Through markSrcDirty the ref flips too.
+    fireEvent.click(screen.getByTestId("pay-input"));
+
+    // Receive mirrors a FRESH quote (not frozen at the seeded 0.1)...
+    expect(screen.getByTestId("dst-amount").textContent).toBe(FRESH_QUOTE_DST);
+    // ...and the typed pay value sticks (not overwritten by the exact-out quote).
+    expect(screen.getByTestId("src-amount").textContent).toBe(TYPED_PAY_AMOUNT);
+  });
+
+  it("AnySpend.tsx routes every isSrcInputDirty write through markSrcDirty (no bare setter can bypass the ref)", () => {
+    let source: string;
+    try {
+      source = readFileSync(path.resolve(__dirname, "../AnySpend.tsx"), "utf8");
+    } catch {
+      throw new Error("Could not read AnySpend.tsx — if the file was moved, update this path");
+    }
+
+    // The state tuple `[isSrcInputDirty, setIsSrcInputDirty]` never matches `setIsSrcInputDirty(`.
+    // Exactly one call may exist: the write inside `markSrcDirty`. Any other is a ref-sync gap.
+    const bareCalls = source.match(/setIsSrcInputDirty\(/g) ?? [];
+    expect(bareCalls.length).toBe(1);
+
+    // And that single writer must flip the ref in the same body, or the "one writer" is not
+    // actually ref-syncing.
+    expect(source).toMatch(
+      /const markSrcDirty = useCallback\(\(next: boolean\) => \{\s*setIsSrcInputDirty\(next\);\s*isSrcInputDirtyRef\.current = next;/,
+    );
+
+    // The original round-4 bug wasn't a bare call at all — it was the raw setter handed to a
+    // child as a PROP VALUE (`setIsSrcInputDirty={setIsSrcInputDirty}`), which the bare-call
+    // regex above doesn't catch and TypeScript doesn't flag. Guard against that shape too.
+    expect(source).not.toMatch(/=\s*\{\s*setIsSrcInputDirty\s*\}/);
+  });
+});