@swype-org/react-sdk 0.2.242 → 0.2.263

package/dist/index.cjs

@@ -1154,12 +1154,225 @@ function useBlinkDepositAmount() {
   };
 }
 
+// src/walletConnectorResolver.ts
+function normalize(value) {
+  return (value ?? "").trim().toLowerCase();
+}
+function buildTargetMatchers(target) {
+  const values = [target.providerName, target.wagmiConnectorId].map(normalize).filter(Boolean);
+  const aliases = new Set(values);
+  for (const value of values) {
+    if (value.includes("metamask")) {
+      aliases.add("metamask");
+      aliases.add("io.metamask");
+    }
+    if (value === "base" || value === "base account" || value === "base app" || value.includes("coinbase")) {
+      aliases.add("base");
+      aliases.add("coinbase");
+      aliases.add("coinbasewalletsdk");
+    }
+    if (value.includes("trust")) {
+      aliases.add("trust");
+      aliases.add("trustwallet");
+    }
+    if (value.includes("okx")) {
+      aliases.add("okx");
+      aliases.add("okxwallet");
+      aliases.add("com.okx.wallet");
+    }
+    if (value.includes("rabby")) {
+      aliases.add("rabby");
+      aliases.add("io.rabby");
+    }
+    if (value.includes("phantom")) {
+      aliases.add("phantom");
+      aliases.add("app.phantom");
+    }
+    if (value.includes("injected")) {
+      aliases.add("injected");
+    }
+  }
+  return [...aliases];
+}
+function connectorMatchesWallet(connector, target) {
+  if (!connector) {
+    return false;
+  }
+  const connectorId = normalize(connector.id);
+  const connectorName = normalize(connector.name);
+  if (target.wagmiConnectorId) {
+    const targetConnectorId = normalize(target.wagmiConnectorId);
+    if (connectorId === targetConnectorId) {
+      return true;
+    }
+  }
+  const matchers = buildTargetMatchers(target);
+  if (matchers.length === 0) {
+    return false;
+  }
+  return matchers.some(
+    (matcher) => connectorId === matcher || connectorName === matcher || connectorId.includes(matcher) || connectorName.includes(matcher)
+  );
+}
+function resolveWalletConnector(connectors, target) {
+  if (target.wagmiConnectorId || target.providerName) {
+    return connectors.find((connector) => connectorMatchesWallet(connector, target));
+  }
+  const metaMaskConnector = connectors.find((connector) => connectorMatchesWallet(
+    connector,
+    { wagmiConnectorId: "metamask" }
+  ));
+  return metaMaskConnector ?? connectors[0];
+}
+
+// src/wagmiRevokeAndDisconnect.ts
+var REVOKE_METHOD = "wallet_revokePermissions";
+var REVOKE_PARAMS = [{ eth_accounts: {} }];
+var EIP6963_DISCOVERY_MS = 200;
+async function tryRevoke(provider, context) {
+  if (!provider?.request) return false;
+  try {
+    await provider.request({ method: REVOKE_METHOD, params: REVOKE_PARAMS });
+    console.info("[blink-sdk][revoke] ok", context);
+    return true;
+  } catch (err) {
+    const code = err?.code;
+    const message = err instanceof Error ? err.message : String(err);
+    console.info("[blink-sdk][revoke] failed", { ...context, code, message });
+    return false;
+  }
+}
+async function getProviderForConnector(connector) {
+  try {
+    const provider = await connector.getProvider();
+    return provider ?? null;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.info("[blink-sdk][revoke] connector.getProvider() threw", {
+      connectorId: connector.id,
+      message
+    });
+    return null;
+  }
+}
+async function discoverEip6963Providers(windowImpl, timeoutMs) {
+  return new Promise((resolve) => {
+    const seen = /* @__PURE__ */ new Map();
+    const onAnnounce = (event) => {
+      const detail = event.detail;
+      if (!detail || !detail.info?.uuid) return;
+      seen.set(detail.info.uuid, detail);
+    };
+    windowImpl.addEventListener("eip6963:announceProvider", onAnnounce);
+    try {
+      windowImpl.dispatchEvent(new Event("eip6963:requestProvider"));
+    } catch {
+    }
+    const timer = setTimeout(() => {
+      windowImpl.removeEventListener(
+        "eip6963:announceProvider",
+        onAnnounce
+      );
+      resolve([...seen.values()]);
+    }, timeoutMs);
+    if (typeof timer.unref === "function") {
+      timer.unref();
+    }
+  });
+}
+async function probeAccounts(provider) {
+  if (!provider.request) return [];
+  try {
+    const accounts = await provider.request({ method: "eth_accounts" });
+    return Array.isArray(accounts) ? accounts : [];
+  } catch {
+    return [];
+  }
+}
+async function revokeAndDisconnectConnector(deps) {
+  const activeConnector = deps.getActiveConnector();
+  if (activeConnector) {
+    const provider = await getProviderForConnector(activeConnector);
+    await tryRevoke(provider, {
+      layer: 1,
+      source: "wagmi-connector",
+      rdns: activeConnector.id
+    });
+    await deps.disconnectFn(activeConnector).catch(() => {
+    });
+    return;
+  }
+  let recentRdns = null;
+  try {
+    recentRdns = await deps.getRecentConnectorId() ?? null;
+  } catch {
+  }
+  if (recentRdns) {
+    const matchedConnector = resolveWalletConnector(deps.listConnectors(), {
+      wagmiConnectorId: recentRdns
+    });
+    if (matchedConnector) {
+      const provider = await getProviderForConnector(matchedConnector);
+      const revoked = await tryRevoke(provider, {
+        layer: 2,
+        source: "recent-connector",
+        rdns: matchedConnector.id
+      });
+      await deps.disconnectFn(matchedConnector).catch(() => {
+      });
+      if (revoked) return;
+    } else {
+      console.info("[blink-sdk][revoke] recentConnectorId has no matching connector", {
+        recentRdns
+      });
+    }
+  }
+  const win = deps.windowImpl ?? (typeof window === "undefined" ? null : window);
+  if (!win) {
+    console.warn("[blink-sdk][revoke] no candidate found and no window for EIP-6963 fallback");
+    return;
+  }
+  const announces = await discoverEip6963Providers(
+    win,
+    deps.eip6963TimeoutMs ?? EIP6963_DISCOVERY_MS
+  );
+  if (announces.length === 0) {
+    console.warn("[blink-sdk][revoke] EIP-6963 enumeration found no providers");
+    return;
+  }
+  let anyRevoked = false;
+  for (const detail of announces) {
+    const accounts = await probeAccounts(detail.provider);
+    if (accounts.length === 0) continue;
+    const ok = await tryRevoke(detail.provider, {
+      layer: 3,
+      source: "eip6963-broadcast",
+      rdns: detail.info.rdns
+    });
+    if (ok) anyRevoked = true;
+  }
+  if (!anyRevoked) {
+    console.warn("[blink-sdk][revoke] EIP-6963 enumeration found no providers with a grant");
+  }
+}
+async function revokeAndDisconnectActiveWagmiConnector(wagmiConfig) {
+  await revokeAndDisconnectConnector({
+    getActiveConnector: () => core.getAccount(wagmiConfig).connector,
+    getRecentConnectorId: async () => {
+      const value = await wagmiConfig.storage?.getItem("recentConnectorId");
+      return typeof value === "string" ? value : null;
+    },
+    listConnectors: () => core.getConnectors(wagmiConfig),
+    disconnectFn: (connector) => core.disconnect(wagmiConfig, { connector })
+  });
+}
+
 // src/otherWalletConnect.ts
 function findWalletConnectConnector(connectors) {
   return connectors.find((connector) => {
-    const id = normalize(connector.id);
-    const name = normalize(connector.name);
-    const type = normalize(connector.type);
+    const id = normalize2(connector.id);
+    const name = normalize2(connector.name);
+    const type = normalize2(connector.type);
     return id === "walletconnect" || id === "wallet-connect" || name === "walletconnect" || name === "wallet connect" || type === "walletconnect";
   });
 }
@@ -1176,9 +1389,9 @@ function findReownExtensionConnector(connectors, wallet) {
   const eligible = connectors.filter((connector) => !findWalletConnectConnector([connector]));
   const match = eligible.find((connector) => {
     const connectorValues = [
-      normalize(connector.id),
-      normalize(connector.name),
-      normalize(connector.type)
+      normalize2(connector.id),
+      normalize2(connector.name),
+      normalize2(connector.type)
     ].filter(Boolean);
     return targets.some(
       (target) => connectorValues.some(
@@ -1207,8 +1420,8 @@ async function findReownExtensionConnectorAsync(connectors, wallet, bridgeClient
     });
     return void 0;
   }
-  const targetRdns = normalize(resolved.rdns);
-  const match = connectors.find((connector) => normalize(connector.id) === targetRdns);
+  const targetRdns = normalize2(resolved.rdns);
+  const match = connectors.find((connector) => normalize2(connector.id) === targetRdns);
   console.info("[blink-bridge] findReownExtensionConnectorAsync \u2192 match", {
     walletName: wallet.name,
     flag: resolved.flag,
@@ -1226,84 +1439,59 @@ function getReownExtensionTargets(wallet) {
   return [...targets];
 }
 function addTarget(targets, value) {
-  const normalized = normalize(value);
+  const normalized = normalize2(value);
   if (normalized) {
     targets.add(normalized);
   }
 }
-function normalize(value) {
+function normalize2(value) {
   return (value ?? "").trim().toLowerCase().replaceAll(/[^a-z0-9.]/g, "");
 }
 
-// src/walletConnectorResolver.ts
-function normalize2(value) {
-  return (value ?? "").trim().toLowerCase();
-}
-function buildTargetMatchers(target) {
-  const values = [target.providerName, target.wagmiConnectorId].map(normalize2).filter(Boolean);
-  const aliases = new Set(values);
-  for (const value of values) {
-    if (value.includes("metamask")) {
-      aliases.add("metamask");
-      aliases.add("io.metamask");
-    }
-    if (value === "base" || value === "base account" || value === "base app" || value.includes("coinbase")) {
-      aliases.add("base");
-      aliases.add("coinbase");
-      aliases.add("coinbasewalletsdk");
-    }
-    if (value.includes("trust")) {
-      aliases.add("trust");
-      aliases.add("trustwallet");
-    }
-    if (value.includes("okx")) {
-      aliases.add("okx");
-      aliases.add("okxwallet");
-      aliases.add("com.okx.wallet");
-    }
-    if (value.includes("rabby")) {
-      aliases.add("rabby");
-      aliases.add("io.rabby");
-    }
-    if (value.includes("phantom")) {
-      aliases.add("phantom");
-      aliases.add("app.phantom");
-    }
-    if (value.includes("injected")) {
-      aliases.add("injected");
-    }
-  }
-  return [...aliases];
-}
-function connectorMatchesWallet(connector, target) {
-  if (!connector) {
-    return false;
-  }
-  const connectorId = normalize2(connector.id);
-  const connectorName = normalize2(connector.name);
-  if (target.wagmiConnectorId) {
-    const targetConnectorId = normalize2(target.wagmiConnectorId);
-    if (connectorId === targetConnectorId) {
-      return true;
-    }
-  }
-  const matchers = buildTargetMatchers(target);
-  if (matchers.length === 0) {
-    return false;
-  }
-  return matchers.some(
-    (matcher) => connectorId === matcher || connectorName === matcher || connectorId.includes(matcher) || connectorName.includes(matcher)
-  );
-}
-function resolveWalletConnector(connectors, target) {
-  if (target.wagmiConnectorId || target.providerName) {
-    return connectors.find((connector) => connectorMatchesWallet(connector, target));
+// src/resolveScreen.ts
+function screenForPhase(phase) {
+  switch (phase.step) {
+    case "initializing":
+    case "data-loading":
+      return "loading";
+    case "manual-transfer":
+      return "manual-transfer";
+    case "login":
+      return "login";
+    case "deposit-options":
+      return "deposit-options";
+    case "wallet-picker":
+      return "wallet-picker";
+    case "wallet-setup":
+      if (phase.mobile) {
+        return "open-wallet";
+      }
+      if (phase.desktopWait) {
+        return "open-wallet";
+      }
+      return "setup-deposit";
+    case "select-source":
+      return phase.isDesktop ? "setup" : "select-source";
+    case "one-tap-setup":
+      return "setup";
+    case "token-picker":
+      return "token-picker";
+    case "guest-source-picker":
+      return "guest-source-picker";
+    case "deposit":
+      return "deposit";
+    case "processing":
+      return "processing";
+    case "confirm-sign":
+      return "confirm-sign";
+    case "completed":
+    case "failed":
+      return "success";
+    case "amount-too-low":
+      return "amount-too-low";
+    case "enter-amount":
+      return "enter-amount";
   }
-  const metaMaskConnector = connectors.find((connector) => connectorMatchesWallet(
-    connector,
-    { wagmiConnectorId: "metamask" }
-  ));
-  return metaMaskConnector ?? connectors[0];
 }
 
 // src/passkey-delegation.ts
@@ -1747,8 +1935,9 @@ async function fetchAccount(apiBaseUrl, token, accountId, credentialId) {
   return await res.json();
 }
 async function createAccount(apiBaseUrl, token, params) {
+  const provisionalId = params.id ?? crypto.randomUUID();
   const body = {
-    id: params.id ?? crypto.randomUUID(),
+    id: provisionalId,
     name: params.name,
     credentialId: params.credentialId
   };
@@ -1776,7 +1965,8 @@ async function createAccount(apiBaseUrl, token, params) {
     body: JSON.stringify(body)
   });
   if (!res.ok) await throwApiError(res);
-  return await res.json();
+  const account = await res.json();
+  return { ...account, id: account.id ?? provisionalId };
 }
 async function createAccountAuthorizationSession(apiBaseUrl, token, accountId, credentialId, options) {
   const body = { credentialId };
@@ -7369,289 +7559,706 @@ function EffectiveDepositAmountProvider({
   return /* @__PURE__ */ jsxRuntime.jsx(EffectiveDepositAmountContext.Provider, { value: memoValue, children });
 }
 
-// src/resolveScreen.ts
-function screenForPhase(phase) {
-  switch (phase.step) {
-    case "initializing":
-    case "data-loading":
-      return "loading";
-    case "manual-transfer":
-      return "manual-transfer";
-    case "login":
-      return "login";
-    case "deposit-options":
-      return "deposit-options";
-    case "wallet-picker":
-      return "wallet-picker";
-    case "wallet-setup":
-      if (phase.mobile) {
-        return "open-wallet";
-      }
-      if (phase.desktopWait) {
-        return "open-wallet";
-      }
-      return "setup-deposit";
-    case "select-source":
-      return phase.isDesktop ? "setup" : "select-source";
-    case "one-tap-setup":
-      return "setup";
-    case "token-picker":
-      return "token-picker";
-    case "guest-source-picker":
-      return "guest-source-picker";
-    case "deposit":
-      return "deposit";
-    case "processing":
-      return "processing";
-    case "confirm-sign":
-      return "confirm-sign";
+// src/manualTransferUtils.ts
+function screenForSession(session) {
+  if (!session) return "source-selector";
+  switch (session.status) {
+    case "awaiting_deposit":
+      return "awaiting-deposit";
+    case "deposit_received":
+      return "deposit-received";
+    case "routing":
+      return "deposit-routing";
     case "completed":
+      return "deposit-complete";
+    case "refunded":
     case "failed":
-      return "success";
-    case "amount-too-low":
-      return "amount-too-low";
-    case "enter-amount":
-      return "enter-amount";
+    case "wrong_token":
+      return "deposit-failed";
   }
 }
-
-// src/processingStatus.ts
-var PROCESSING_TIMEOUT_MS = 18e4;
-var TERMINAL_TRANSFER_STATUSES = /* @__PURE__ */ new Set(["COMPLETED", "FAILED", "EXPIRED"]);
-var SIGNABLE_TRANSFER_STATUSES = /* @__PURE__ */ new Set(["CREATED", "AUTHORIZED"]);
-function isTerminalTransferStatus(status) {
-  return TERMINAL_TRANSFER_STATUSES.has(status);
-}
-function isTransferSignable(transfer) {
-  return transfer != null && SIGNABLE_TRANSFER_STATUSES.has(transfer.status);
-}
-function isTransferAwaitingCompletion(transfer) {
-  if (!transfer) return false;
-  return !isTerminalTransferStatus(transfer.status);
-}
-function resolvePreferredTransfer(polledTransfer, localTransfer) {
-  return polledTransfer ?? localTransfer;
+function isSameChainSameTokenSelection(option, destination) {
+  return option.chainId === destination.chainId && option.tokenAddress.toLowerCase() === destination.token.address.toLowerCase();
 }
-function getTransferStatus(polledTransfer, localTransfer) {
-  const transfer = resolvePreferredTransfer(polledTransfer, localTransfer);
-  return transfer?.status ?? "UNKNOWN";
+function feeCopy(_session) {
+  return "No fees";
 }
-function hasProcessingTimedOut(processingStartedAtMs, nowMs) {
-  if (!processingStartedAtMs) return false;
-  return nowMs - processingStartedAtMs >= PROCESSING_TIMEOUT_MS;
+function toTransfer(session) {
+  return {
+    id: session.sessionId,
+    status: session.status,
+    amount: {
+      amount: Number(session.deliveredAmountUsd ?? session.minAmountUsd),
+      currency: "USD"
+    },
+    sources: [],
+    destinations: [{
+      id: session.sessionId,
+      chainId: session.destination.chainId,
+      address: session.destination.address,
+      token: { address: session.destination.token.address, symbol: "" },
+      amount: { amount: Number(session.deliveredAmountUsd ?? session.minAmountUsd), currency: "USD" }
+    }],
+    createDate: session.createDate,
+    updateDate: session.updateDate
+  };
 }
-var STATUS_DISPLAY_LABELS = {
-  CREATED: "created",
-  AUTHORIZED: "authorized",
-  SENDING: "sending",
-  SENT: "confirming delivery",
-  COMPLETED: "completed",
-  FAILED: "failed"
-};
-function getStatusDisplayLabel(status) {
-  return STATUS_DISPLAY_LABELS[status] ?? status;
+var SOLANA_CHAIN_ID = 792703809;
+var SOLANA_NATIVE_SOL_ADDRESS = "11111111111111111111111111111111";
+function formatDepositUri(address, chainId, depToken) {
+  if (chainId === SOLANA_CHAIN_ID) {
+    if (!depToken || depToken === SOLANA_NATIVE_SOL_ADDRESS) {
+      return `solana:${address}`;
+    }
+    return `solana:${address}?spl-token=${depToken}`;
+  }
+  return address;
 }
-function buildProcessingTimeoutMessage(status) {
-  const label = getStatusDisplayLabel(status);
-  return `Payment is taking longer than expected (status: ${label}). Please try again.`;
+var dataUrlCache = /* @__PURE__ */ new Map();
+var inFlight = /* @__PURE__ */ new Map();
+function keyFor(uri, colors) {
+  return `${uri}|${colors.dark}|${colors.light}`;
+}
+function getCachedQrDataUrl(uri, colors) {
+  return dataUrlCache.get(keyFor(uri, colors)) ?? null;
+}
+function getOrRenderQrDataUrl(uri, colors) {
+  const key = keyFor(uri, colors);
+  const cached = dataUrlCache.get(key);
+  if (cached) return Promise.resolve(cached);
+  const pending = inFlight.get(key);
+  if (pending) return pending;
+  const promise = QRCode__namespace.toDataURL(uri, {
+    errorCorrectionLevel: "H",
+    margin: 1,
+    width: 203,
+    color: { dark: colors.dark, light: colors.light }
+  }).then((url) => {
+    dataUrlCache.set(key, url);
+    inFlight.delete(key);
+    return url;
+  }).catch((err) => {
+    inFlight.delete(key);
+    throw err;
+  });
+  inFlight.set(key, promise);
+  return promise;
 }
 
-// src/paymentResolvePhase.ts
-function hasActiveWallet(accounts) {
-  return accounts.some((a) => a.wallets.some((w) => w.status === "ACTIVE"));
-}
-function resolveTerminalPhase(state) {
-  if (state.amountTooLow != null) {
-    return {
-      step: "amount-too-low",
-      minAmountUsd: state.amountTooLow.minAmountUsd
-    };
-  }
-  const transferCompleted = state.transfer?.status === "COMPLETED";
-  const needsPasskeyBootstrap = state.privyAuthenticated && !state.activeCredentialId;
-  if (transferCompleted && !needsPasskeyBootstrap && !state.loginRequested) {
-    return { step: "completed", transfer: state.transfer };
-  }
-  if (state.transfer?.status === "FAILED") {
-    return {
-      step: "failed",
-      transfer: state.transfer,
-      error: state.error ?? "Transfer failed."
-    };
-  }
-  if (state.creatingTransfer || isTransferAwaitingCompletion(state.transfer)) {
-    return { step: "processing", transfer: state.transfer };
-  }
-  return null;
+// src/hooks/useManualTransferSession.ts
+function perTokenKey(chainId, tokenAddress) {
+  return `${chainId}:${tokenAddress.toLowerCase()}`;
 }
-function resolveStickyPhase(state) {
-  const currentPhase = state.phase;
-  if (currentPhase.step === "manual-transfer" && !state.loginRequested) {
-    return currentPhase;
-  }
-  if (currentPhase.step === "deposit-options" && !state.loginRequested && !state.privyAuthenticated) {
-    return currentPhase;
-  }
-  if (!state.loginRequested && state.setupFlowScreen === "one-tap-setup") {
-    return { step: "one-tap-setup", action: null };
-  }
-  if (!state.loginRequested && state.setupFlowScreen === "deposit-confirm" && state.selectedAccountId != null) {
-    return {
-      step: "wallet-setup",
-      mobile: null,
-      accountId: state.selectedAccountId
-    };
-  }
-  if (!state.loginRequested && state.mobileTokenAuthorizationPending) {
-    return {
-      step: "wallet-setup",
-      mobile: { deeplinkUri: "", providerId: state.selectedProviderId },
-      accountId: null
-    };
-  }
-  const isFundingSourceSubflow = !state.loginRequested && (currentPhase.step === "token-picker" || currentPhase.step === "guest-source-picker" || currentPhase.step === "select-source" || currentPhase.step === "confirm-sign");
-  if (isFundingSourceSubflow) {
-    return currentPhase;
-  }
-  if ((state.standardDesktopInlineOpenWallet || state.desktopWait != null) && state.privyAuthenticated && state.activeCredentialId != null && state.selectedAccountId != null && !state.loginRequested) {
-    return {
-      step: "wallet-setup",
-      mobile: null,
-      desktopWait: state.desktopWait,
-      accountId: state.selectedAccountId
+function useManualTransferSession({
+  destination,
+  merchantAuthorization,
+  idempotencyKey,
+  onComplete,
+  onError,
+  pollEnabled = true
+}) {
+  const { apiBaseUrl, tokens } = useBlinkConfig();
+  const [sourceOptions, setSourceOptions] = react.useState(null);
+  const [loadingSources, setLoadingSources] = react.useState(true);
+  const [selectedToken, setSelectedToken] = react.useState("");
+  const [selectedChainId, setSelectedChainId] = react.useState("");
+  const [sessionsByFamily, setSessionsByFamily] = react.useState({});
+  const [perTokenSessions, setPerTokenSessions] = react.useState({});
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [copiedAddress, setCopiedAddress] = react.useState(null);
+  const completedRef = react.useRef(/* @__PURE__ */ new Set());
+  const premintedFamiliesRef = react.useRef(/* @__PURE__ */ new Set());
+  const inFlightPerTokenRef = react.useRef(/* @__PURE__ */ new Set());
+  react.useEffect(() => {
+    if (!merchantAuthorization) return;
+    let cancelled = false;
+    setLoadingSources(true);
+    fetchManualTransferSources(apiBaseUrl, { merchantAuthorization, destination }).then((sources) => {
+      if (cancelled) return;
+      setSourceOptions(sources);
+      setLoadingSources(false);
+      const destTokenAddrLower = destination.token.address.toLowerCase();
+      const destMatch = sources.find(
+        (s) => s.chainId === destination.chainId && s.tokenAddress.toLowerCase() === destTokenAddrLower
+      );
+      const svmCanonical = sources.find((s) => s.canonical && s.chainFamily === "svm");
+      const evmCanonical = sources.find((s) => s.canonical && s.chainFamily === "evm");
+      const defaultOption = destMatch ?? svmCanonical ?? evmCanonical ?? sources[0];
+      if (defaultOption) {
+        setSelectedToken(defaultOption.tokenSymbol);
+        setSelectedChainId(String(defaultOption.chainId));
+      }
+    }).catch((err) => {
+      if (!cancelled) {
+        setError(err instanceof Error ? err.message : String(err));
+        setLoadingSources(false);
+      }
+    });
+    return () => {
+      cancelled = true;
     };
-  }
-  if (state.mobileFlow && state.deeplinkUri != null) {
-    return {
-      step: "wallet-setup",
-      mobile: { deeplinkUri: state.deeplinkUri, providerId: state.selectedProviderId },
-      accountId: null
+  }, [apiBaseUrl, destination, merchantAuthorization]);
+  react.useEffect(() => {
+    if (!sourceOptions || !merchantAuthorization) return;
+    const canonicals = sourceOptions.filter((s) => s.canonical);
+    if (canonicals.length === 0) return;
+    let cancelled = false;
+    for (const opt of canonicals) {
+      if (premintedFamiliesRef.current.has(opt.chainFamily)) continue;
+      premintedFamiliesRef.current.add(opt.chainFamily);
+      const family = opt.chainFamily;
+      const run = async () => {
+        try {
+          const created = await createManualTransfer(apiBaseUrl, {
+            merchantAuthorization,
+            destination,
+            idempotencyKey,
+            source: { chainId: opt.chainId, tokenAddress: opt.tokenAddress }
+          });
+          if (cancelled) return;
+          setSessionsByFamily((prev) => ({ ...prev, [family]: created }));
+          const uri = formatDepositUri(created.depositAddress, opt.chainId, opt.tokenAddress);
+          void getOrRenderQrDataUrl(uri, { dark: tokens.text, light: tokens.bg });
+        } catch (err) {
+          if (cancelled) return;
+          premintedFamiliesRef.current.delete(family);
+          setError(err instanceof Error ? err.message : String(err));
+        }
+      };
+      void run();
+    }
+    return () => {
+      cancelled = true;
     };
-  }
-  if (currentPhase.step === "wallet-picker" && currentPhase.reason === "switch" && !state.creatingTransfer && !(state.mobileFlow && state.deeplinkUri)) {
-    return currentPhase;
-  }
-  return null;
-}
-function deriveFreshPhase(state) {
-  if (!state.privyReady) {
-    return { step: "initializing" };
-  }
-  if (state.privyAuthenticated && !state.activeCredentialId && !state.passkeyConfigLoaded) {
-    return { step: "initializing" };
-  }
-  if (state.loginRequested) {
-    return { step: "login" };
-  }
-  if (state.enableFullWidget && !state.privyAuthenticated) {
-    return { step: "deposit-options" };
-  }
-  if (!state.privyAuthenticated) {
-    return { step: "login" };
-  }
-  if (state.loadingData && state.activeCredentialId != null) {
-    return { step: "data-loading" };
-  }
-  if (state.requireAmountEntry) {
-    return { step: "enter-amount" };
-  }
-  if (state.activeCredentialId != null && !hasActiveWallet(state.accounts) && !state.mobileFlow) {
-    return { step: "wallet-picker", reason: "link" };
-  }
-  if (state.activeCredentialId != null && hasActiveWallet(state.accounts) && !state.loadingData) {
-    return { step: "deposit" };
-  }
-  return { step: "wallet-picker", reason: "entry" };
-}
-function resolvePhase(state) {
-  return resolveTerminalPhase(state) ?? resolveStickyPhase(state) ?? deriveFreshPhase(state);
-}
-
-// src/paymentReducer.ts
-var DEFAULT_ONE_TAP_LIMIT = 1e4;
-function deriveSourceTypeAndId(state) {
-  if (state.selectedWalletId) {
-    return { sourceType: "walletId", sourceId: state.selectedWalletId };
-  }
-  if (state.selectedAccountId) {
-    return { sourceType: "accountId", sourceId: state.selectedAccountId };
-  }
-  return { sourceType: "accountId", sourceId: "" };
-}
-function clearStaleSelection(state) {
-  if (state.selectedAccountId == null) return state;
-  const stillExists = state.accounts.some((a) => a.id === state.selectedAccountId);
-  if (stillExists) return state;
+  }, [
+    apiBaseUrl,
+    destination,
+    idempotencyKey,
+    merchantAuthorization,
+    sourceOptions,
+    tokens.text,
+    tokens.bg
+  ]);
+  const tokenChoices = react.useMemo(
+    () => Array.from(new Set((sourceOptions ?? []).map((opt) => opt.tokenSymbol))),
+    [sourceOptions]
+  );
+  const chainChoices = react.useMemo(() => {
+    const seen = /* @__PURE__ */ new Set();
+    return (sourceOptions ?? []).filter((opt) => {
+      if (seen.has(opt.chainId)) return false;
+      seen.add(opt.chainId);
+      return true;
+    });
+  }, [sourceOptions]);
+  const tokenLogoUriBySymbol = react.useMemo(() => {
+    const out = {};
+    for (const opt of sourceOptions ?? []) {
+      if (out[opt.tokenSymbol] == null) {
+        out[opt.tokenSymbol] = opt.tokenLogoUri;
+      }
+    }
+    return out;
+  }, [sourceOptions]);
+  const selectedOption = react.useMemo(
+    () => (sourceOptions ?? []).find(
+      (opt) => opt.tokenSymbol === selectedToken && String(opt.chainId) === selectedChainId
+    ) ?? null,
+    [sourceOptions, selectedToken, selectedChainId]
+  );
+  const tokensForSelectedChain = react.useMemo(() => {
+    if (!selectedChainId) return null;
+    return new Set(
+      (sourceOptions ?? []).filter((opt) => String(opt.chainId) === selectedChainId).map((opt) => opt.tokenSymbol)
+    );
+  }, [sourceOptions, selectedChainId]);
+  const chainsForSelectedToken = react.useMemo(() => {
+    if (!selectedToken) return null;
+    return new Set(
+      (sourceOptions ?? []).filter((opt) => opt.tokenSymbol === selectedToken).map((opt) => opt.chainId)
+    );
+  }, [sourceOptions, selectedToken]);
+  const session = react.useMemo(() => {
+    if (!selectedOption) return null;
+    const perToken = perTokenSessions[perTokenKey(selectedOption.chainId, selectedOption.tokenAddress)] ?? null;
+    if (isSameChainSameTokenSelection(selectedOption, destination)) {
+      return perToken ?? sessionsByFamily[selectedOption.chainFamily] ?? null;
+    }
+    const familySession = sessionsByFamily[selectedOption.chainFamily];
+    if (familySession) return familySession;
+    return perToken;
+  }, [selectedOption, destination, sessionsByFamily, perTokenSessions]);
+  const depositAddress = session?.depositAddress;
+  const qrReady = !!depositAddress;
+  const lastFeeCopyRef = react.useRef(null);
+  const nextFeeCopy = session ? feeCopy() : null;
+  const sessionFeeCopy = nextFeeCopy === lastFeeCopyRef.current ? lastFeeCopyRef.current : lastFeeCopyRef.current = nextFeeCopy;
+  const activeSessionId = session?.sessionId;
+  const activeSessionStatus = session?.status;
+  react.useEffect(() => {
+    if (!pollEnabled) return;
+    if (!activeSessionId) return;
+    if (activeSessionStatus && ["completed", "failed", "refunded", "wrong_token"].includes(activeSessionStatus)) return;
+    const timer = window.setInterval(() => {
+      fetchManualTransferSession(apiBaseUrl, activeSessionId).then((updated) => {
+        setSessionsByFamily((prev) => {
+          for (const family of Object.keys(prev)) {
+            if (prev[family]?.sessionId === updated.sessionId) {
+              return { ...prev, [family]: updated };
+            }
+          }
+          return prev;
+        });
+        setPerTokenSessions((prev) => {
+          for (const key of Object.keys(prev)) {
+            if (prev[key]?.sessionId === updated.sessionId) {
+              return { ...prev, [key]: updated };
+            }
+          }
+          return prev;
+        });
+      }).catch((err) => setError(err instanceof Error ? err.message : String(err)));
+    }, 2e3);
+    return () => window.clearInterval(timer);
+  }, [apiBaseUrl, activeSessionId, activeSessionStatus, pollEnabled]);
+  const completionSignature = react.useMemo(() => {
+    const entries2 = [];
+    for (const family of Object.keys(sessionsByFamily)) {
+      const s = sessionsByFamily[family];
+      if (s) entries2.push([s.sessionId, s.status]);
+    }
+    for (const key of Object.keys(perTokenSessions)) {
+      const s = perTokenSessions[key];
+      entries2.push([s.sessionId, s.status]);
+    }
+    entries2.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+    return JSON.stringify(entries2);
+  }, [sessionsByFamily, perTokenSessions]);
+  react.useEffect(() => {
+    const all = [];
+    for (const family of Object.keys(sessionsByFamily)) {
+      const s = sessionsByFamily[family];
+      if (s) all.push(s);
+    }
+    for (const key of Object.keys(perTokenSessions)) {
+      all.push(perTokenSessions[key]);
+    }
+    for (const s of all) {
+      if (s.status !== "completed") continue;
+      if (completedRef.current.has(s.sessionId)) continue;
+      completedRef.current.add(s.sessionId);
+      onComplete?.(toTransfer(s));
+      break;
+    }
+  }, [completionSignature, onComplete]);
+  react.useEffect(() => {
+    if (!error) return;
+    onError?.(error);
+  }, [error, onError]);
+  const createSession = react.useCallback(async (option) => {
+    if (!merchantAuthorization) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const created = await createManualTransfer(apiBaseUrl, {
+        merchantAuthorization,
+        destination,
+        idempotencyKey,
+        source: { chainId: option.chainId, tokenAddress: option.tokenAddress }
+      });
+      const key = perTokenKey(option.chainId, option.tokenAddress);
+      setPerTokenSessions((prev) => ({ ...prev, [key]: created }));
+      const uri = formatDepositUri(created.depositAddress, option.chainId, option.tokenAddress);
+      void getOrRenderQrDataUrl(uri, { dark: tokens.text, light: tokens.bg });
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setLoading(false);
+    }
+  }, [apiBaseUrl, destination, idempotencyKey, merchantAuthorization, tokens.text, tokens.bg]);
+  react.useEffect(() => {
+    if (!selectedOption) return;
+    const sameTokenSelection = isSameChainSameTokenSelection(selectedOption, destination);
+    if (!sameTokenSelection) {
+      if (sessionsByFamily[selectedOption.chainFamily]) return;
+      if (premintedFamiliesRef.current.has(selectedOption.chainFamily)) return;
+    }
+    const key = perTokenKey(selectedOption.chainId, selectedOption.tokenAddress);
+    if (perTokenSessions[key]) return;
+    if (inFlightPerTokenRef.current.has(key)) return;
+    inFlightPerTokenRef.current.add(key);
+    void createSession(selectedOption).finally(() => {
+      inFlightPerTokenRef.current.delete(key);
+    });
+  }, [selectedOption, destination, sessionsByFamily, perTokenSessions, createSession]);
+  const resetSessionForNewSelection = react.useCallback(() => {
+    setError(null);
+  }, []);
+  const selectToken = react.useCallback((value) => {
+    setSelectedToken(value);
+    const pairValid = (sourceOptions ?? []).some(
+      (opt) => opt.tokenSymbol === value && String(opt.chainId) === selectedChainId
+    );
+    if (!pairValid) {
+      const firstChain = (sourceOptions ?? []).find(
+        (opt) => opt.tokenSymbol === value
+      );
+      setSelectedChainId(
+        firstChain ? String(firstChain.chainId) : ""
+      );
+    }
+  }, [selectedChainId, sourceOptions]);
+  const selectChainId = react.useCallback((value) => {
+    setSelectedChainId(value);
+    const pairValid = (sourceOptions ?? []).some(
+      (opt) => opt.tokenSymbol === selectedToken && String(opt.chainId) === value
+    );
+    if (!pairValid) {
+      const firstToken = (sourceOptions ?? []).find(
+        (opt) => String(opt.chainId) === value
+      );
+      setSelectedToken(
+        firstToken ? firstToken.tokenSymbol : ""
+      );
+    }
+  }, [selectedToken, sourceOptions]);
+  const screen = screenForSession(session);
+  const copyDepositAddress = react.useCallback(async (address) => {
+    try {
+      await navigator.clipboard.writeText(address);
+    } catch {
+      const textarea = document.createElement("textarea");
+      textarea.value = address;
+      textarea.setAttribute("readonly", "");
+      textarea.style.position = "absolute";
+      textarea.style.opacity = "0";
+      document.body.appendChild(textarea);
+      textarea.select();
+      try {
+        document.execCommand("copy");
+      } finally {
+        document.body.removeChild(textarea);
+      }
+    }
+    setCopiedAddress(address);
+    window.setTimeout(() => setCopiedAddress((cur) => cur === address ? null : cur), 1500);
+  }, []);
+  const backToSourceSelector = react.useCallback(() => {
+    setCopiedAddress(null);
+    setError(null);
+    if (!selectedOption) return;
+    const family = selectedOption.chainFamily;
+    setSessionsByFamily((prev) => {
+      if (!prev[family]) return prev;
+      const next = { ...prev };
+      delete next[family];
+      return next;
+    });
+    premintedFamiliesRef.current.delete(family);
+    const ptKey = perTokenKey(selectedOption.chainId, selectedOption.tokenAddress);
+    setPerTokenSessions((prev) => {
+      if (!prev[ptKey]) return prev;
+      const next = { ...prev };
+      delete next[ptKey];
+      return next;
+    });
+  }, [selectedOption]);
   return {
-    ...state,
-    selectedAccountId: null,
-    selectedWalletId: null,
-    selectedTokenSymbol: null
+    sourceOptions,
+    loadingSources,
+    selectedToken,
+    selectedChainId,
+    session,
+    loading,
+    error,
+    qrReady,
+    copiedAddress,
+    tokenChoices,
+    chainChoices,
+    tokenLogoUriBySymbol,
+    selectedOption,
+    tokensForSelectedChain,
+    chainsForSelectedToken,
+    screen,
+    sessionFeeCopy,
+    depositAddress,
+    createSession,
+    copyDepositAddress,
+    backToSourceSelector,
+    resetSessionForNewSelection,
+    selectToken,
+    selectChainId
   };
 }
-function createInitialState(config) {
-  return {
-    phase: config.initialPhase ?? { step: "initializing" },
-    error: null,
-    setupFlowScreen: null,
-    providers: [],
-    accounts: [],
-    chains: [],
-    loadingData: false,
-    depositSelectionRefreshing: false,
-    selectedProviderId: null,
-    selectedAccountId: null,
-    selectedWalletId: null,
-    selectedTokenSymbol: null,
-    savedSelection: null,
-    amount: config.depositAmount != null ? config.depositAmount.toString() : "",
-    transfer: null,
-    pendingTransferId: null,
-    creatingTransfer: false,
-    passkeyConfigLoaded: false,
-    activeCredentialId: config.activeCredentialId,
-    knownCredentialIds: [],
-    oneTapLimit: DEFAULT_ONE_TAP_LIMIT,
-    oneTapLimitSavedDuringSetup: false,
-    mobileFlow: false,
-    deeplinkUri: null,
-    increasingLimit: false,
-    activePublicKey: null,
-    loginRequested: false,
-    standardDesktopInlineOpenWallet: false,
-    desktopWait: null,
-    setupAuthorizationSessionId: null,
-    mobileTokenAuthorizationPending: false,
-    privyReady: false,
-    privyAuthenticated: false,
-    lastResumedAt: 0,
-    setupDepositAmount: null,
-    setupDepositToken: null,
-    setupDepositConfirmed: false,
-    guestWalletPrepared: null,
-    guestWalletDeeplinksPreparing: false,
-    amountTooLow: null,
-    enableFullWidget: config.enableFullWidget ?? false,
-    requireAmountEntry: config.depositAmount == null
-  };
+var ManualTransferSessionContext = react.createContext(null);
+function ManualTransferSessionProvider({
+  destination,
+  merchantAuthorization,
+  idempotencyKey,
+  onComplete,
+  onError,
+  pollEnabled,
+  children
+}) {
+  const session = useManualTransferSession({
+    destination,
+    merchantAuthorization,
+    idempotencyKey,
+    onComplete,
+    onError,
+    pollEnabled
+  });
+  return /* @__PURE__ */ jsxRuntime.jsx(ManualTransferSessionContext.Provider, { value: session, children });
 }
-function clearAuthenticatedSessionState(state) {
-  return {
-    ...state,
-    error: null,
-    setupFlowScreen: null,
-    providers: [],
-    accounts: [],
-    chains: [],
-    loadingData: false,
-    depositSelectionRefreshing: false,
-    selectedProviderId: null,
-    selectedAccountId: null,
-    selectedWalletId: null,
-    selectedTokenSymbol: null,
-    savedSelection: null,
-    transfer: null,
-    pendingTransferId: null,
+function useManualTransferSessionContext() {
+  const ctx = react.useContext(ManualTransferSessionContext);
+  if (!ctx) {
+    throw new Error(
+      "useManualTransferSessionContext must be used within a <ManualTransferSessionProvider>"
+    );
+  }
+  return ctx;
+}
+
+// src/processingStatus.ts
+var PROCESSING_TIMEOUT_MS = 18e4;
+var TERMINAL_TRANSFER_STATUSES = /* @__PURE__ */ new Set(["COMPLETED", "FAILED", "EXPIRED"]);
+var SIGNABLE_TRANSFER_STATUSES = /* @__PURE__ */ new Set(["CREATED", "AUTHORIZED"]);
+function isTerminalTransferStatus(status) {
+  return TERMINAL_TRANSFER_STATUSES.has(status);
+}
+function isTransferSignable(transfer) {
+  return transfer != null && SIGNABLE_TRANSFER_STATUSES.has(transfer.status);
+}
+function isTransferAwaitingCompletion(transfer) {
+  if (!transfer) return false;
+  return !isTerminalTransferStatus(transfer.status);
+}
+function resolvePreferredTransfer(polledTransfer, localTransfer) {
+  return polledTransfer ?? localTransfer;
+}
+function getTransferStatus(polledTransfer, localTransfer) {
+  const transfer = resolvePreferredTransfer(polledTransfer, localTransfer);
+  return transfer?.status ?? "UNKNOWN";
+}
+function hasProcessingTimedOut(processingStartedAtMs, nowMs) {
+  if (!processingStartedAtMs) return false;
+  return nowMs - processingStartedAtMs >= PROCESSING_TIMEOUT_MS;
+}
+var STATUS_DISPLAY_LABELS = {
+  CREATED: "created",
+  AUTHORIZED: "authorized",
+  SENDING: "sending",
+  SENT: "confirming delivery",
+  COMPLETED: "completed",
+  FAILED: "failed"
+};
+function getStatusDisplayLabel(status) {
+  return STATUS_DISPLAY_LABELS[status] ?? status;
+}
+function buildProcessingTimeoutMessage(status) {
+  const label = getStatusDisplayLabel(status);
+  return `Payment is taking longer than expected (status: ${label}). Please try again.`;
+}
+
+// src/paymentResolvePhase.ts
+function hasActiveWallet(accounts) {
+  return accounts.some((a) => a.wallets.some((w) => w.status === "ACTIVE"));
+}
+function resolveTerminalPhase(state) {
+  if (state.amountTooLow != null) {
+    return {
+      step: "amount-too-low",
+      minAmountUsd: state.amountTooLow.minAmountUsd
+    };
+  }
+  const transferCompleted = state.transfer?.status === "COMPLETED";
+  const needsPasskeyBootstrap = state.privyAuthenticated && !state.activeCredentialId;
+  if (transferCompleted && !needsPasskeyBootstrap && !state.loginRequested) {
+    return { step: "completed", transfer: state.transfer };
+  }
+  if (state.transfer?.status === "FAILED") {
+    return {
+      step: "failed",
+      transfer: state.transfer,
+      error: state.error ?? "Transfer failed."
+    };
+  }
+  if (state.creatingTransfer || isTransferAwaitingCompletion(state.transfer)) {
+    return { step: "processing", transfer: state.transfer };
+  }
+  return null;
+}
+function resolveStickyPhase(state) {
+  const currentPhase = state.phase;
+  if (currentPhase.step === "manual-transfer" && !state.loginRequested) {
+    return currentPhase;
+  }
+  if (currentPhase.step === "deposit-options" && !state.loginRequested && !state.privyAuthenticated) {
+    return currentPhase;
+  }
+  if (!state.loginRequested && state.setupFlowScreen === "one-tap-setup") {
+    return { step: "one-tap-setup", action: null };
+  }
+  if (!state.loginRequested && state.setupFlowScreen === "deposit-confirm" && state.selectedAccountId != null) {
+    return {
+      step: "wallet-setup",
+      mobile: null,
+      accountId: state.selectedAccountId
+    };
+  }
+  if (!state.loginRequested && state.mobileTokenAuthorizationPending) {
+    return {
+      step: "wallet-setup",
+      mobile: { deeplinkUri: "", providerId: state.selectedProviderId },
+      accountId: null
+    };
+  }
+  const isFundingSourceSubflow = !state.loginRequested && (currentPhase.step === "token-picker" || currentPhase.step === "guest-source-picker" || currentPhase.step === "select-source" || currentPhase.step === "confirm-sign");
+  if (isFundingSourceSubflow) {
+    return currentPhase;
+  }
+  if ((state.standardDesktopInlineOpenWallet || state.desktopWait != null) && state.privyAuthenticated && state.activeCredentialId != null && state.selectedAccountId != null && !state.loginRequested) {
+    return {
+      step: "wallet-setup",
+      mobile: null,
+      desktopWait: state.desktopWait,
+      accountId: state.selectedAccountId
+    };
+  }
+  if (state.mobileFlow && state.deeplinkUri != null) {
+    return {
+      step: "wallet-setup",
+      mobile: { deeplinkUri: state.deeplinkUri, providerId: state.selectedProviderId },
+      accountId: null
+    };
+  }
+  if (currentPhase.step === "wallet-picker" && currentPhase.reason === "switch" && !state.creatingTransfer && !(state.mobileFlow && state.deeplinkUri)) {
+    return currentPhase;
+  }
+  return null;
+}
+function deriveFreshPhase(state) {
+  if (!state.privyReady) {
+    return { step: "initializing" };
+  }
+  if (state.privyAuthenticated && !state.activeCredentialId && !state.passkeyConfigLoaded) {
+    return { step: "initializing" };
+  }
+  if (state.loginRequested) {
+    return { step: "login" };
+  }
+  if (state.enableFullWidget && !state.privyAuthenticated) {
+    return { step: "deposit-options" };
+  }
+  if (!state.privyAuthenticated) {
+    return { step: "login" };
+  }
+  if (state.loadingData && state.activeCredentialId != null) {
+    return { step: "data-loading" };
+  }
+  if (state.requireAmountEntry) {
+    return { step: "enter-amount" };
+  }
+  if (state.activeCredentialId != null && !hasActiveWallet(state.accounts) && !state.mobileFlow) {
+    return { step: "wallet-picker", reason: "link" };
+  }
+  if (state.activeCredentialId != null && hasActiveWallet(state.accounts) && !state.loadingData) {
+    return { step: "deposit" };
+  }
+  return { step: "wallet-picker", reason: "entry" };
+}
+function resolvePhase(state) {
+  return resolveTerminalPhase(state) ?? resolveStickyPhase(state) ?? deriveFreshPhase(state);
+}
+
+// src/paymentReducer.ts
+var DEFAULT_ONE_TAP_LIMIT = 1e4;
+function deriveSourceTypeAndId(state) {
+  if (state.selectedWalletId) {
+    return { sourceType: "walletId", sourceId: state.selectedWalletId };
+  }
+  if (state.selectedAccountId) {
+    return { sourceType: "accountId", sourceId: state.selectedAccountId };
+  }
+  return { sourceType: "accountId", sourceId: "" };
+}
+function clearStaleSelection(state) {
+  if (state.selectedAccountId == null) return state;
+  if (state.desktopWait != null) return state;
+  const stillExists = state.accounts.some((a) => a.id === state.selectedAccountId);
+  if (stillExists) return state;
+  return {
+    ...state,
+    selectedAccountId: null,
+    selectedWalletId: null,
+    selectedTokenSymbol: null
+  };
+}
+function createInitialState(config) {
+  return {
+    phase: config.initialPhase ?? { step: "initializing" },
+    error: null,
+    setupFlowScreen: null,
+    providers: [],
+    accounts: [],
+    chains: [],
+    loadingData: false,
+    depositSelectionRefreshing: false,
+    selectedProviderId: null,
+    selectedAccountId: null,
+    selectedWalletId: null,
+    selectedTokenSymbol: null,
+    savedSelection: null,
+    amount: config.depositAmount != null ? config.depositAmount.toString() : "",
+    transfer: null,
+    pendingTransferId: null,
+    creatingTransfer: false,
+    passkeyConfigLoaded: false,
+    activeCredentialId: config.activeCredentialId,
+    knownCredentialIds: [],
+    oneTapLimit: DEFAULT_ONE_TAP_LIMIT,
+    oneTapLimitSavedDuringSetup: false,
+    mobileFlow: false,
+    deeplinkUri: null,
+    increasingLimit: false,
+    activePublicKey: null,
+    loginRequested: false,
+    standardDesktopInlineOpenWallet: false,
+    desktopWait: null,
+    setupAuthorizationSessionId: null,
+    mobileTokenAuthorizationPending: false,
+    privyReady: false,
+    privyAuthenticated: false,
+    lastResumedAt: 0,
+    setupDepositAmount: null,
+    setupDepositToken: null,
+    setupDepositConfirmed: false,
+    guestWalletPrepared: null,
+    guestWalletDeeplinksPreparing: false,
+    amountTooLow: null,
+    enableFullWidget: config.enableFullWidget ?? false,
+    requireAmountEntry: config.depositAmount == null
+  };
+}
+function clearAuthenticatedSessionState(state) {
+  return {
+    ...state,
+    error: null,
+    setupFlowScreen: null,
+    providers: [],
+    accounts: [],
+    chains: [],
+    loadingData: false,
+    depositSelectionRefreshing: false,
+    selectedProviderId: null,
+    selectedAccountId: null,
+    selectedWalletId: null,
+    selectedTokenSymbol: null,
+    savedSelection: null,
+    transfer: null,
+    pendingTransferId: null,
     creatingTransfer: false,
     passkeyConfigLoaded: false,
     activeCredentialId: null,
@@ -8095,552 +8702,118 @@ function applyAction(state, action) {
         // unauthenticated path) preserves the flag implicitly via the
         // surrounding `...state` spread, so no change is needed there.
         enableFullWidget: state.enableFullWidget
-      };
-    case "SYNC_PRIVY_SESSION":
-      if (action.ready && !action.authenticated) {
-        return {
-          ...clearAuthenticatedSessionState(state),
-          privyReady: true,
-          privyAuthenticated: false
-        };
-      }
-      return {
-        ...state,
-        privyReady: action.ready,
-        privyAuthenticated: action.authenticated,
-        ...action.authenticated ? { loginRequested: false } : {}
-      };
-    case "SYNC_AMOUNT":
-      return {
-        ...state,
-        amount: action.amount,
-        requireAmountEntry: action.amount === "" ? state.requireAmountEntry : false
-      };
-    case "SET_AMOUNT_INPUT":
-      return { ...state, amount: action.value };
-    case "FINALIZE_AMOUNT":
-      return { ...state, requireAmountEntry: false };
-    case "PAGE_RESUMED":
-      return { ...state, lastResumedAt: Date.now() };
-    // ── Setup deposit (combined first-time flow) ────────────────
-    case "SET_SETUP_DEPOSIT_AMOUNT":
-      return { ...state, setupDepositAmount: action.amount };
-    case "SET_SETUP_DEPOSIT_TOKEN":
-      return {
-        ...state,
-        setupDepositToken: {
-          symbol: action.symbol,
-          chainName: action.chainName,
-          ...action.walletId ? { walletId: action.walletId } : {},
-          ...action.tokenAddress ? { tokenAddress: action.tokenAddress } : {},
-          ...action.chainId != null ? { chainId: action.chainId } : {}
-        }
-      };
-    case "CLEAR_SETUP_DEPOSIT_TOKEN":
-      return { ...state, setupDepositToken: null };
-    case "CONFIRM_SETUP_DEPOSIT":
-      return { ...state, setupDepositConfirmed: true };
-    default:
-      return state;
-  }
-}
-
-// src/setupDepositConfirmation.ts
-function deriveEffectiveSetupSource(setupDepositToken, setupSelectedSourceOption) {
-  if (setupDepositToken) return setupDepositToken;
-  if (setupSelectedSourceOption) {
-    return {
-      symbol: setupSelectedSourceOption.tokenSymbol,
-      chainName: setupSelectedSourceOption.chainName,
-      walletId: setupSelectedSourceOption.walletId,
-      tokenAddress: setupSelectedSourceOption.tokenAddress,
-      chainId: setupSelectedSourceOption.chainId != null ? Number(setupSelectedSourceOption.chainId) : void 0
-    };
-  }
-  return null;
-}
-function planConfirmSetupDeposit(input) {
-  const effective = deriveEffectiveSetupSource(
-    input.setupDepositToken,
-    input.setupSelectedSourceOption
-  );
-  if (!effective) {
-    return { kind: "error", error: "Select a source token before continuing." };
-  }
-  if (!effective.walletId) {
-    return {
-      kind: "error",
-      error: "Selected source is not ready yet. Wait for wallet discovery to finish."
-    };
-  }
-  const actions = [
-    { type: "SET_ERROR", error: null },
-    {
-      type: "SET_SETUP_DEPOSIT_TOKEN",
-      symbol: effective.symbol,
-      chainName: effective.chainName,
-      walletId: effective.walletId,
-      tokenAddress: effective.tokenAddress,
-      chainId: effective.chainId
-    }
-  ];
-  if (input.selectedAccountId) {
-    actions.push({
-      type: "SELECT_ACCOUNT",
-      accountId: input.selectedAccountId,
-      walletId: effective.walletId
-    });
-    actions.push({
-      type: "SELECT_TOKEN",
-      walletId: effective.walletId,
-      tokenSymbol: effective.symbol
-    });
-  }
-  actions.push({ type: "SET_SETUP_FLOW_SCREEN", screen: "one-tap-setup" });
-  actions.push({ type: "CONFIRM_SETUP_DEPOSIT" });
-  return {
-    kind: "proceed",
-    actions,
-    resolveSource: {
-      chainName: effective.chainName,
-      tokenSymbol: effective.symbol
-    }
-  };
-}
-
-// src/manualTransferUtils.ts
-function screenForSession(session) {
-  if (!session) return "source-selector";
-  switch (session.status) {
-    case "awaiting_deposit":
-      return "awaiting-deposit";
-    case "deposit_received":
-      return "deposit-received";
-    case "routing":
-      return "deposit-routing";
-    case "completed":
-      return "deposit-complete";
-    case "refunded":
-    case "failed":
-    case "wrong_token":
-      return "deposit-failed";
-  }
-}
-function feeCopy(_session) {
-  return "No fees";
-}
-function toTransfer(session) {
-  return {
-    id: session.sessionId,
-    status: session.status,
-    amount: {
-      amount: Number(session.deliveredAmountUsd ?? session.minAmountUsd),
-      currency: "USD"
-    },
-    sources: [],
-    destinations: [{
-      id: session.sessionId,
-      chainId: session.destination.chainId,
-      address: session.destination.address,
-      token: { address: session.destination.token.address, symbol: "" },
-      amount: { amount: Number(session.deliveredAmountUsd ?? session.minAmountUsd), currency: "USD" }
-    }],
-    createDate: session.createDate,
-    updateDate: session.updateDate
-  };
-}
-var SOLANA_CHAIN_ID = 792703809;
-var SOLANA_NATIVE_SOL_ADDRESS = "11111111111111111111111111111111";
-function formatDepositUri(address, chainId, depToken) {
-  if (chainId === SOLANA_CHAIN_ID) {
-    if (!depToken || depToken === SOLANA_NATIVE_SOL_ADDRESS) {
-      return `solana:${address}`;
-    }
-    return `solana:${address}?spl-token=${depToken}`;
-  }
-  return address;
-}
-
-// src/hooks/useManualTransferSession.ts
-function useManualTransferSession({
-  destination,
-  merchantAuthorization,
-  idempotencyKey,
-  mock = false,
-  onComplete,
-  onError
-}) {
-  const { apiBaseUrl } = useBlinkConfig();
-  const [sourceOptions, setSourceOptions] = react.useState(null);
-  const [loadingSources, setLoadingSources] = react.useState(true);
-  const [selectedToken, setSelectedToken] = react.useState("");
-  const [selectedChainId, setSelectedChainId] = react.useState("");
-  const [session, setSession] = react.useState(null);
-  const [loading, setLoading] = react.useState(false);
-  const [error, setError] = react.useState(null);
-  const [qrReady, setQrReady] = react.useState(false);
-  const [copiedAddress, setCopiedAddress] = react.useState(null);
-  const completedRef = react.useRef(null);
-  const lastCreatedOptionRef = react.useRef(null);
-  react.useEffect(() => {
-    if (!merchantAuthorization) return;
-    let cancelled = false;
-    setLoadingSources(true);
-    fetchManualTransferSources(apiBaseUrl, { merchantAuthorization, destination }).then((sources) => {
-      if (!cancelled) {
-        setSourceOptions(sources);
-        setLoadingSources(false);
-        const defaultOption = sources.find(
-          (opt) => opt.tokenSymbol === "USDC" && opt.chainId === 792703809
-        );
-        if (defaultOption) {
-          setSelectedToken("USDC");
-          setSelectedChainId("792703809");
-        }
-      }
-    }).catch((err) => {
-      if (!cancelled) {
-        setError(err instanceof Error ? err.message : String(err));
-        setLoadingSources(false);
-      }
-    });
-    return () => {
-      cancelled = true;
-    };
-  }, [apiBaseUrl, destination, merchantAuthorization]);
-  const depositAddress = session?.depositAddress;
-  react.useEffect(() => {
-    if (!depositAddress) {
-      setQrReady(false);
-      return;
-    }
-    const timer = window.setTimeout(() => setQrReady(true), 1200);
-    return () => window.clearTimeout(timer);
-  }, [depositAddress]);
-  const lastFeeCopyRef = react.useRef(null);
-  const nextFeeCopy = session ? feeCopy() : null;
-  const sessionFeeCopy = nextFeeCopy === lastFeeCopyRef.current ? lastFeeCopyRef.current : lastFeeCopyRef.current = nextFeeCopy;
-  const advanceMockStatus = react.useCallback((status) => {
-    setSession((prev) => prev ? { ...prev, status } : prev);
-  }, []);
-  react.useEffect(() => {
-    if (mock) return;
-    if (!session?.sessionId || ["completed", "failed", "refunded", "wrong_token"].includes(session.status)) return;
-    const timer = window.setInterval(() => {
-      fetchManualTransferSession(apiBaseUrl, session.sessionId).then(setSession).catch((err) => setError(err instanceof Error ? err.message : String(err)));
-    }, 2e3);
-    return () => window.clearInterval(timer);
-  }, [apiBaseUrl, mock, session?.sessionId, session?.status]);
-  react.useEffect(() => {
-    if (mock) return;
-    if (!session?.sessionId || session.status !== "awaiting_deposit") return;
-    const sessionId = session.sessionId;
-    const timer = window.setInterval(() => {
-      refreshManualTransferQuote(apiBaseUrl, sessionId).then(({ quoteValidUntil, minAmountUsd, slippage }) => {
-        setSession(
-          (prev) => prev && prev.sessionId === sessionId ? { ...prev, quoteValidUntil, minAmountUsd, slippage } : prev
-        );
-      }).catch((err) => {
-        console.warn("[manual-transfer] refresh quote failed", err);
-      });
-    }, 1e4);
-    return () => window.clearInterval(timer);
-  }, [apiBaseUrl, mock, session?.sessionId, session?.status]);
-  react.useEffect(() => {
-    if (session?.status !== "completed") return;
-    if (completedRef.current === session.sessionId) return;
-    completedRef.current = session.sessionId;
-    onComplete?.(toTransfer(session));
-  }, [onComplete, session]);
-  react.useEffect(() => {
-    if (!error) return;
-    onError?.(error);
-  }, [error, onError]);
-  const tokenChoices = react.useMemo(
-    () => Array.from(new Set((sourceOptions ?? []).map((opt) => opt.tokenSymbol))),
-    [sourceOptions]
-  );
-  const chainChoices = react.useMemo(() => {
-    const seen = /* @__PURE__ */ new Set();
-    return (sourceOptions ?? []).filter((opt) => {
-      if (seen.has(opt.chainId)) return false;
-      seen.add(opt.chainId);
-      return true;
-    });
-  }, [sourceOptions]);
-  const tokenLogoUriBySymbol = react.useMemo(() => {
-    const out = {};
-    for (const opt of sourceOptions ?? []) {
-      if (out[opt.tokenSymbol] == null) {
-        out[opt.tokenSymbol] = opt.tokenLogoUri;
-      }
-    }
-    return out;
-  }, [sourceOptions]);
-  const selectedOption = react.useMemo(
-    () => (sourceOptions ?? []).find(
-      (opt) => opt.tokenSymbol === selectedToken && String(opt.chainId) === selectedChainId
-    ) ?? null,
-    [sourceOptions, selectedToken, selectedChainId]
-  );
-  const tokensForSelectedChain = react.useMemo(() => {
-    if (!selectedChainId) return null;
-    return new Set(
-      (sourceOptions ?? []).filter((opt) => String(opt.chainId) === selectedChainId).map((opt) => opt.tokenSymbol)
-    );
-  }, [sourceOptions, selectedChainId]);
-  const chainsForSelectedToken = react.useMemo(() => {
-    if (!selectedToken) return null;
-    return new Set(
-      (sourceOptions ?? []).filter((opt) => opt.tokenSymbol === selectedToken).map((opt) => opt.chainId)
-    );
-  }, [sourceOptions, selectedToken]);
-  const createSession = react.useCallback(async (option) => {
-    if (!merchantAuthorization) return;
-    setLoading(true);
-    setError(null);
-    try {
-      if (mock) {
-        const mockSession = {
-          sessionId: `mock-${Date.now()}`,
-          idempotencyKey: idempotencyKey ?? `mock-idem-${Date.now()}`,
-          merchantId: "mock-merchant",
-          destination,
-          source: {
-            chainId: option.chainId,
-            tokenAddress: option.tokenAddress,
-            tokenSymbol: option.tokenSymbol
-          },
-          refundTo: null,
-          depositAddress: "0x" + "a1b2c3d4e5f6".repeat(3).slice(0, 40),
-          requestId: `mock-req-${Date.now()}`,
-          status: "awaiting_deposit",
-          minAmountUsd: option.minAmountUsd,
-          quoteValidUntil: new Date(Date.now() + 36e5).toISOString(),
-          depositTxHashes: [],
-          destinationTxHash: null,
-          refundTxHashes: [],
-          deliveredAmountUsd: null,
-          errorCode: null,
-          errorMessage: null,
-          slippage: null,
-          createDate: (/* @__PURE__ */ new Date()).toISOString(),
-          updateDate: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        setSession(mockSession);
-      } else {
-        const created = await createManualTransfer(apiBaseUrl, {
-          merchantAuthorization,
-          destination,
-          idempotencyKey,
-          source: {
-            chainId: option.chainId,
-            tokenAddress: option.tokenAddress
-          }
-        });
-        setSession(created);
-      }
-    } catch (err) {
-      setError(err instanceof Error ? err.message : String(err));
-    } finally {
-      setLoading(false);
-    }
-  }, [apiBaseUrl, destination, idempotencyKey, merchantAuthorization, mock]);
-  const resetSessionForNewSelection = react.useCallback(() => {
-    setSession(null);
-    lastCreatedOptionRef.current = null;
-  }, []);
-  const selectToken = react.useCallback((value) => {
-    setSelectedToken(value);
-    resetSessionForNewSelection();
-    const pairValid = (sourceOptions ?? []).some(
-      (opt) => opt.tokenSymbol === value && String(opt.chainId) === selectedChainId
-    );
-    if (!pairValid) {
-      const firstChain = (sourceOptions ?? []).find(
-        (opt) => opt.tokenSymbol === value
-      );
-      setSelectedChainId(
-        firstChain ? String(firstChain.chainId) : ""
-      );
-    }
-  }, [resetSessionForNewSelection, selectedChainId, sourceOptions]);
-  const selectChainId = react.useCallback((value) => {
-    setSelectedChainId(value);
-    resetSessionForNewSelection();
-    const pairValid = (sourceOptions ?? []).some(
-      (opt) => opt.tokenSymbol === selectedToken && String(opt.chainId) === value
-    );
-    if (!pairValid) {
-      const firstToken = (sourceOptions ?? []).find(
-        (opt) => String(opt.chainId) === value
-      );
-      setSelectedToken(
-        firstToken ? firstToken.tokenSymbol : ""
-      );
-    }
-  }, [resetSessionForNewSelection, selectedToken, sourceOptions]);
-  react.useEffect(() => {
-    if (!selectedOption) return;
-    const optionKey = `${selectedOption.chainId}:${selectedOption.tokenAddress}`;
-    if (lastCreatedOptionRef.current === optionKey) return;
-    lastCreatedOptionRef.current = optionKey;
-    void createSession(selectedOption);
-  }, [selectedOption, createSession]);
-  const screen = screenForSession(session);
-  const copyDepositAddress = react.useCallback(async (address) => {
-    try {
-      await navigator.clipboard.writeText(address);
-    } catch {
-      const textarea = document.createElement("textarea");
-      textarea.value = address;
-      textarea.setAttribute("readonly", "");
-      textarea.style.position = "absolute";
-      textarea.style.opacity = "0";
-      document.body.appendChild(textarea);
-      textarea.select();
-      try {
-        document.execCommand("copy");
-      } finally {
-        document.body.removeChild(textarea);
+      };
+    case "SYNC_PRIVY_SESSION":
+      if (action.ready && !action.authenticated) {
+        return {
+          ...clearAuthenticatedSessionState(state),
+          privyReady: true,
+          privyAuthenticated: false
+        };
       }
+      return {
+        ...state,
+        privyReady: action.ready,
+        privyAuthenticated: action.authenticated,
+        ...action.authenticated ? { loginRequested: false } : {}
+      };
+    case "SYNC_AMOUNT":
+      return {
+        ...state,
+        amount: action.amount,
+        requireAmountEntry: action.amount === "" ? state.requireAmountEntry : false
+      };
+    case "SET_AMOUNT_INPUT":
+      return { ...state, amount: action.value };
+    case "FINALIZE_AMOUNT":
+      return { ...state, requireAmountEntry: false };
+    case "PAGE_RESUMED":
+      return { ...state, lastResumedAt: Date.now() };
+    // ── Setup deposit (combined first-time flow) ────────────────
+    case "SET_SETUP_DEPOSIT_AMOUNT":
+      return { ...state, setupDepositAmount: action.amount };
+    case "SET_SETUP_DEPOSIT_TOKEN":
+      return {
+        ...state,
+        setupDepositToken: {
+          symbol: action.symbol,
+          chainName: action.chainName,
+          ...action.walletId ? { walletId: action.walletId } : {},
+          ...action.tokenAddress ? { tokenAddress: action.tokenAddress } : {},
+          ...action.chainId != null ? { chainId: action.chainId } : {}
+        }
+      };
+    case "CLEAR_SETUP_DEPOSIT_TOKEN":
+      return { ...state, setupDepositToken: null };
+    case "CONFIRM_SETUP_DEPOSIT":
+      return { ...state, setupDepositConfirmed: true };
+    default:
+      return state;
+  }
+}
+
+// src/setupDepositConfirmation.ts
+function deriveEffectiveSetupSource(setupDepositToken, setupSelectedSourceOption) {
+  if (setupDepositToken) return setupDepositToken;
+  if (setupSelectedSourceOption) {
+    return {
+      symbol: setupSelectedSourceOption.tokenSymbol,
+      chainName: setupSelectedSourceOption.chainName,
+      walletId: setupSelectedSourceOption.walletId,
+      tokenAddress: setupSelectedSourceOption.tokenAddress,
+      chainId: setupSelectedSourceOption.chainId != null ? Number(setupSelectedSourceOption.chainId) : void 0
+    };
+  }
+  return null;
+}
+function planConfirmSetupDeposit(input) {
+  const effective = deriveEffectiveSetupSource(
+    input.setupDepositToken,
+    input.setupSelectedSourceOption
+  );
+  if (!effective) {
+    return { kind: "error", error: "Select a source token before continuing." };
+  }
+  if (!effective.walletId) {
+    return {
+      kind: "error",
+      error: "Selected source is not ready yet. Wait for wallet discovery to finish."
+    };
+  }
+  const actions = [
+    { type: "SET_ERROR", error: null },
+    {
+      type: "SET_SETUP_DEPOSIT_TOKEN",
+      symbol: effective.symbol,
+      chainName: effective.chainName,
+      walletId: effective.walletId,
+      tokenAddress: effective.tokenAddress,
+      chainId: effective.chainId
     }
-    setCopiedAddress(address);
-    window.setTimeout(() => setCopiedAddress((cur) => cur === address ? null : cur), 1500);
-  }, []);
-  const backToSourceSelector = react.useCallback(() => {
-    setSession(null);
-    setCopiedAddress(null);
-    setError(null);
-    lastCreatedOptionRef.current = null;
-    if (selectedOption) {
-      void createSession(selectedOption);
-    }
-  }, [selectedOption, createSession]);
+  ];
+  if (input.selectedAccountId) {
+    actions.push({
+      type: "SELECT_ACCOUNT",
+      accountId: input.selectedAccountId,
+      walletId: effective.walletId
+    });
+    actions.push({
+      type: "SELECT_TOKEN",
+      walletId: effective.walletId,
+      tokenSymbol: effective.symbol
+    });
+  }
+  actions.push({ type: "SET_SETUP_FLOW_SCREEN", screen: "one-tap-setup" });
+  actions.push({ type: "CONFIRM_SETUP_DEPOSIT" });
   return {
-    sourceOptions,
-    loadingSources,
-    selectedToken,
-    selectedChainId,
-    session,
-    loading,
-    error,
-    qrReady,
-    copiedAddress,
-    tokenChoices,
-    chainChoices,
-    tokenLogoUriBySymbol,
-    selectedOption,
-    tokensForSelectedChain,
-    chainsForSelectedToken,
-    screen,
-    sessionFeeCopy,
-    depositAddress,
-    createSession,
-    copyDepositAddress,
-    backToSourceSelector,
-    resetSessionForNewSelection,
-    advanceMockStatus,
-    selectToken,
-    selectChainId
+    kind: "proceed",
+    actions,
+    resolveSource: {
+      chainName: effective.chainName,
+      tokenSymbol: effective.symbol
+    }
   };
 }
-var MOCK_STATUSES = [
-  "awaiting_deposit",
-  "deposit_received",
-  "routing",
-  "completed",
-  "failed"
-];
-function DevMockPanel({
-  status,
-  onSetStatus,
-  hasSession
-}) {
-  const [collapsed, setCollapsed] = react.useState(true);
-  return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: devPanelContainerStyle, children: [
-    /* @__PURE__ */ jsxRuntime.jsx(
-      "button",
-      {
-        type: "button",
-        onClick: () => setCollapsed((c) => !c),
-        style: devPanelToggleStyle,
-        children: collapsed ? "DEV" : "\u2715"
-      }
-    ),
-    !collapsed && /* @__PURE__ */ jsxRuntime.jsxs("div", { style: devPanelBodyStyle, children: [
-      /* @__PURE__ */ jsxRuntime.jsx("span", { style: devPanelLabelStyle, children: hasSession ? `Status: ${status}` : "No session" }),
-      MOCK_STATUSES.map((s) => /* @__PURE__ */ jsxRuntime.jsx(
-        "button",
-        {
-          type: "button",
-          disabled: !hasSession || status === s,
-          onClick: () => onSetStatus(s),
-          style: devPanelButtonStyle(status === s),
-          children: s.replace(/_/g, " ")
-        },
-        s
-      ))
-    ] })
-  ] });
-}
-var devPanelContainerStyle = {
-  position: "fixed",
-  bottom: 16,
-  right: 16,
-  zIndex: 99999,
-  display: "flex",
-  flexDirection: "column",
-  alignItems: "flex-end",
-  gap: 8,
-  fontFamily: "monospace",
-  fontSize: 12
-};
-var devPanelToggleStyle = {
-  background: "#1a1a1a",
-  border: "1px solid #333",
-  borderRadius: 8,
-  color: "#0f0",
-  cursor: "pointer",
-  fontSize: 11,
-  fontFamily: "monospace",
-  fontWeight: 700,
-  height: 36,
-  width: 36,
-  display: "flex",
-  alignItems: "center",
-  justifyContent: "center"
-};
-var devPanelBodyStyle = {
-  background: "#1a1a1a",
-  border: "1px solid #333",
-  borderRadius: 10,
-  display: "flex",
-  flexDirection: "column",
-  gap: 4,
-  padding: 10,
-  minWidth: 160
-};
-var devPanelLabelStyle = {
-  color: "#888",
-  fontSize: 10,
-  marginBottom: 4,
-  textTransform: "uppercase",
-  letterSpacing: "0.05em"
-};
-var devPanelButtonStyle = (active) => ({
-  background: active ? "#0f0" : "#2a2a2a",
-  border: "1px solid #444",
-  borderRadius: 6,
-  color: active ? "#000" : "#ccc",
-  cursor: active ? "default" : "pointer",
-  fontFamily: "monospace",
-  fontSize: 11,
-  fontWeight: active ? 700 : 400,
-  padding: "6px 10px",
-  textAlign: "left",
-  textTransform: "capitalize"
-});
 function ScreenLayout({ children, footer }) {
   const { tokens, theme, isMobileApp } = useBlinkConfig();
   const isRedesign = theme.endsWith("New");
@@ -10355,16 +10528,21 @@ function DepositQrCodeImpl({
   depToken
 }) {
   const { tokens } = useBlinkConfig();
-  const [dataUrl, setDataUrl] = react.useState(null);
   const uri = formatDepositUri(address, chainId, depToken);
+  const dark = tokens.text;
+  const light = tokens.bg;
+  const [dataUrl, setDataUrl] = react.useState(
+    () => getCachedQrDataUrl(uri, { dark, light })
+  );
   react.useEffect(() => {
+    const cached = getCachedQrDataUrl(uri, { dark, light });
+    if (cached) {
+      setDataUrl(cached);
+      return;
+    }
     let cancelled = false;
-    QRCode__namespace.toDataURL(uri, {
-      errorCorrectionLevel: "H",
-      margin: 1,
-      width: 203,
-      color: { dark: tokens.text, light: tokens.bg }
-    }).then((url) => {
+    setDataUrl(null);
+    getOrRenderQrDataUrl(uri, { dark, light }).then((url) => {
       if (!cancelled) setDataUrl(url);
     }).catch(() => {
       if (!cancelled) setDataUrl(null);
@@ -10372,7 +10550,7 @@ function DepositQrCodeImpl({
     return () => {
       cancelled = true;
     };
-  }, [uri]);
+  }, [uri, dark, light]);
   return /* @__PURE__ */ jsxRuntime.jsx("div", { style: qrFrameStyle(tokens.bgCardTranslucent), children: dataUrl ? /* @__PURE__ */ jsxRuntime.jsxs("div", { style: qrContainerStyle, children: [
     /* @__PURE__ */ jsxRuntime.jsx("img", { src: dataUrl, alt: "Deposit QR code", style: qrImageStyle }),
     /* @__PURE__ */ jsxRuntime.jsx("img", { src: BLINK_QR_LOGO, alt: "", style: qrLogoStyle })
@@ -11460,7 +11638,7 @@ function EnterAmountScreen({
         )
       ] }),
       children: [
-        /* @__PURE__ */ jsxRuntime.jsx(ScreenHeader, { right: headerRight }),
+        /* @__PURE__ */ jsxRuntime.jsx(ScreenHeader, { title: "Deposit", right: headerRight }),
         /* @__PURE__ */ jsxRuntime.jsxs("div", { style: contentStyle4(isDesktop), children: [
           isDesktop ? /* @__PURE__ */ jsxRuntime.jsxs("div", { style: desktopHeroRowStyle(heroColor, getDesktopHeroFontSize(value)), children: [
             /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-hidden": "true", style: dollarStyle2(isZero), children: "$" }),
@@ -12801,7 +12979,8 @@ function SetupScreen({
   onLogout,
   loading,
   loadingShimmersEnabled = false,
-  error
+  error,
+  selectedTokenSymbol
 }) {
   const { tokens } = useBlinkConfig();
   const [selectedPreset, setSelectedPreset] = react.useState(DEFAULT_MAX);
@@ -12910,7 +13089,8 @@ function SetupScreen({
               style: illustrationStyle3
             }
           ),
-          /* @__PURE__ */ jsxRuntime.jsx("h2", { style: headingStyle7(tokens.text), children: "Next time deposit\nUSDC in one tap" }),
+          /* @__PURE__ */ jsxRuntime.jsx("h2", { style: headingStyle7(tokens.text), children: `Next time deposit
+${selectedTokenSymbol ?? "USDC"} in one tap` }),
           /* @__PURE__ */ jsxRuntime.jsx("p", { style: subtitleStyle5(tokens.textSecondary), children: "Set a cap for passkey deposits.\nYou always stay in control." }),
           error && /* @__PURE__ */ jsxRuntime.jsx("div", { style: errorBannerStyle5(tokens), children: error }),
           /* @__PURE__ */ jsxRuntime.jsx("div", { style: chipsRowStyle, children: PRESETS.map(({ label, value }) => {
@@ -12938,8 +13118,8 @@ var contentStyle9 = {
   alignItems: "center",
   justifyContent: "center",
   textAlign: "center",
-  gap: 16,
-  padding: "48px 8px 8px"
+  gap: 12,
+  padding: "8px 0"
 };
 var shimmerContentStyle = {
   display: "flex",
@@ -13310,7 +13490,7 @@ function SetupDepositScreen({
           NotificationBanner,
           {
             variant: "negative",
-            title: "Deposit amount exceeds balance",
+            title: "Deposit amount exceeds stablecoin balance",
             description: "Pick another asset or add more funds to your wallet"
           }
         ) : /* @__PURE__ */ jsxRuntime.jsx(NotificationBanner, { title: "Something went wrong", description: error }) })
@@ -13928,7 +14108,7 @@ function DepositScreen({
       NotificationBanner,
       {
         variant: "negative",
-        title: "Deposit amount exceeds balance",
+        title: "Deposit amount exceeds stablecoin balance",
         description: "Pick another asset or add more funds to your wallet"
       }
     ) : needsAuthorization ? /* @__PURE__ */ jsxRuntime.jsx(
@@ -14850,12 +15030,12 @@ function DepositAddressScreen({
     ),
     /* @__PURE__ */ jsxRuntime.jsxs("div", { style: contentStyle16, children: [
       /* @__PURE__ */ jsxRuntime.jsx("h2", { style: depositTitleStyle(tokens.text), children: "Deposit Address" }),
-      qrReady && session ? /* @__PURE__ */ jsxRuntime.jsx(
+      qrReady && session && selectedOption ? /* @__PURE__ */ jsxRuntime.jsx(
         DepositQrCode,
         {
           address: session.depositAddress,
-          chainId: session.source.chainId,
-          depToken: session.source.tokenAddress
+          chainId: selectedOption.chainId,
+          depToken: selectedOption.tokenAddress
         }
       ) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
         /* @__PURE__ */ jsxRuntime.jsx("style", { children: `
@@ -15874,12 +16054,7 @@ var errorBannerStyle8 = (themeTokens) => ({
   textAlign: "left"
 });
 function ManualTransferFlow({
-  destination,
-  merchantAuthorization,
-  idempotencyKey,
-  mock = false,
-  onComplete,
-  onError,
+  hasMerchantAuthorization,
   onCreatePasskey,
   createPasskeyLoading = false,
   createPasskeyError = null,
@@ -15908,17 +16083,9 @@ function ManualTransferFlow({
     depositAddress,
     copyDepositAddress,
     backToSourceSelector,
-    advanceMockStatus,
     selectToken,
     selectChainId
-  } = useManualTransferSession({
-    destination,
-    merchantAuthorization,
-    idempotencyKey,
-    mock,
-    onComplete,
-    onError
-  });
+  } = useManualTransferSessionContext();
   const [passkeyCreated, setPasskeyCreated] = react.useState(false);
   const prevPasskeyLoadingRef = react.useRef(false);
   react.useEffect(() => {
@@ -15927,9 +16094,8 @@ function ManualTransferFlow({
     }
     prevPasskeyLoadingRef.current = createPasskeyLoading;
   }, [createPasskeyLoading, createPasskeyError]);
-  const DEV_MOCK_STATUS = mock;
   let screenContent = null;
-  if (!merchantAuthorization) {
+  if (!hasMerchantAuthorization) {
     screenContent = /* @__PURE__ */ jsxRuntime.jsxs(ScreenLayout, { footer: /* @__PURE__ */ jsxRuntime.jsx(PrimaryButton, { onClick: onBack, children: "Back" }), children: [
       /* @__PURE__ */ jsxRuntime.jsx(ScreenHeader, { onBack }),
       /* @__PURE__ */ jsxRuntime.jsxs("div", { style: contentStyle20, children: [
@@ -15999,17 +16165,7 @@ function ManualTransferFlow({
   if (!screenContent) {
     return null;
   }
-  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-    screenContent,
-    DEV_MOCK_STATUS && merchantAuthorization && /* @__PURE__ */ jsxRuntime.jsx(
-      DevMockPanel,
-      {
-        status: session?.status ?? null,
-        onSetStatus: advanceMockStatus,
-        hasSession: !!session
-      }
-    )
-  ] });
+  return screenContent;
 }
 var contentStyle20 = {
   alignItems: "center",
@@ -16309,6 +16465,7 @@ function buildSetupDepositScreenProps({
 function buildSetupScreenProps({
   flow,
   remote,
+  derived,
   forms,
   handlers
 }) {
@@ -16317,11 +16474,12 @@ function buildSetupScreenProps({
   const waitingForDesktopWalletConnection = flow.isDesktop && remote.authExecutorExecuting && remote.pendingOneTapSetup == null && (remote.authExecutorCurrentAction == null || remote.authExecutorCurrentAction.type === "OPEN_PROVIDER");
   return {
     onSetupOneTap: handlers.onSetupOneTap,
-    onBack: handlers.onBackFromSubflow,
-    onLogout: handlers.onLogout,
+    onBack: flow.isDesktop ? handlers.onBackFromSubflow : void 0,
+    onLogout: flow.isDesktop ? handlers.onLogout : void 0,
     loading: savingOneTapLimit,
     loadingShimmersEnabled: waitingForDesktopWalletConnection,
-    error: state.error
+    error: state.error,
+    selectedTokenSymbol: derived.selectedSource?.token.symbol
   };
 }
 function buildConfirmSignScreenProps({
@@ -16598,12 +16756,7 @@ function StepRendererContent({
       return /* @__PURE__ */ jsxRuntime.jsx(
         ManualTransferFlow,
         {
-          destination: flow.destination,
-          merchantAuthorization: flow.merchantAuthorization,
-          idempotencyKey: flow.idempotencyKey,
-          mock: flow.mock,
-          onComplete: flow.onComplete,
-          onError: flow.onError,
+          hasMerchantAuthorization: flow.merchantAuthorization != null,
           onCreatePasskey: handlers.onSignupWithPasskey,
           createPasskeyLoading: flow.passkeyLoading,
           createPasskeyError: flow.state.error,
@@ -18821,8 +18974,11 @@ function usePasskeyCheckEffect(deps) {
     setupAccountIdRef,
     reauthSessionIdRef,
     reauthTokenRef,
-    pollingTransferIdRef
+    pollingTransferIdRef,
+    reloadAccounts
   } = deps;
+  const reloadAccountsRef = react.useRef(reloadAccounts);
+  reloadAccountsRef.current = reloadAccounts;
   const { getAccessToken: privyGetAccessToken, user } = reactAuth.usePrivy();
   const effectiveGetAccessToken = deps.getAccessToken ?? privyGetAccessToken;
   const onCompleteRef = react.useRef(deps.onComplete);
@@ -18952,6 +19108,11 @@ function usePasskeyCheckEffect(deps) {
           mobileSetupFlowRef.current = false;
           setupAccountIdRef.current = null;
           clearMobileFlowState();
+          try {
+            await reloadAccountsRef.current();
+          } catch {
+          }
+          dispatch({ type: "MOBILE_SETUP_COMPLETE" });
           return;
         }
         if (persisted.accountId && !persisted.transferId) {
@@ -18960,7 +19121,14 @@ function usePasskeyCheckEffect(deps) {
               const session = await fetchAuthorizationSession(apiBaseUrl, persisted.sessionId);
               if (cancelled) return;
               if (session.status === "AUTHORIZED") {
+                mobileSetupFlowRef.current = false;
+                setupAccountIdRef.current = null;
                 clearMobileFlowState();
+                try {
+                  await reloadAccountsRef.current();
+                } catch {
+                }
+                dispatch({ type: "MOBILE_SETUP_COMPLETE" });
                 return;
               }
             } catch {
@@ -19425,25 +19593,24 @@ function useMobilePollingEffect(deps) {
       dispatch({ type: "MOBILE_SETUP_COMPLETE" });
     };
     const pollWalletActive = async () => {
+      if (setupSessionId) {
+        try {
+          const session = await fetchAuthorizationSession(apiBaseUrl, setupSessionId);
+          if (cancelled) return;
+          if (session.status === "AUTHORIZED") {
+            await completeSetup();
+            return;
+          }
+        } catch {
+        }
+      }
       try {
         const token = await getAccessTokenRef.current();
         if (!token || cancelled) return;
         const acct = await fetchAccount(apiBaseUrl, token, accountId, credentialId);
         if (cancelled) return;
-        const hasActive = acct.wallets.some((w) => w.status === "ACTIVE");
-        if (hasActive) {
+        if (acct.wallets.some((w) => w.status === "ACTIVE")) {
           await completeSetup();
-          return;
-        }
-        if (setupSessionId) {
-          try {
-            const session = await fetchAuthorizationSession(apiBaseUrl, setupSessionId);
-            if (cancelled) return;
-            if (session.status === "AUTHORIZED") {
-              await completeSetup();
-            }
-          } catch {
-          }
         }
       } catch {
       }
@@ -19878,7 +20045,6 @@ function BlinkPayment(props) {
 function BlinkPaymentInner({
   destination,
   initialScreen,
-  mock,
   onComplete,
   onError,
   useWalletConnector: useWalletConnectorProp,
@@ -19967,6 +20133,7 @@ function BlinkPaymentInner({
     minTransferAmountUsd: effectiveMinDepositAmountUsd
   });
   const feeEstimateEnabled = effectiveAuthenticated && (state.phase.step === "deposit" || state.phase.step === "wallet-setup" || state.phase.step === "one-tap-setup");
+  const manualTransferActive = screenForPhase(state.phase) === "manual-transfer";
   const setupSelectedSourceOption = react.useMemo(() => {
     const options = sourceSelection.pendingSelectSourceAction?.metadata?.options ?? [];
     return resolveSelectSourceOption(
@@ -20113,13 +20280,14 @@ function BlinkPaymentInner({
     idempotencyKey
   });
   const accountSwitchSessionId = state.setupAuthorizationSessionId;
+  const accountSwitchListenerArmed = accountSwitchSessionId != null && state.desktopWait == null;
   const handleProviderWalletAccountSwitch = provider.handleWalletAccountSwitch;
   const onWalletAccountChanged = react.useCallback(async (change) => {
     if (!accountSwitchSessionId) return;
     await handleProviderWalletAccountSwitch(change, accountSwitchSessionId);
   }, [handleProviderWalletAccountSwitch, accountSwitchSessionId]);
   useWalletAccountSwitchEffect({
-    enabled: accountSwitchSessionId != null,
+    enabled: accountSwitchListenerArmed,
     isDesktop,
     onAccountChanged: onWalletAccountChanged
   });
@@ -20215,6 +20383,7 @@ function BlinkPaymentInner({
     reauthTokenRef: mobileFlowRefs.reauthTokenRef,
     pollingTransferIdRef: transfer.pollingTransferIdRef,
     handleAuthorizedMobileReturn: mobileFlow.handleAuthorizedMobileReturn,
+    reloadAccounts: transfer.reloadAccounts,
     onComplete,
     getAccessToken: effectiveGetAccessToken,
     pendingTransferFlowKey
@@ -20381,15 +20550,18 @@ function BlinkPaymentInner({
     dispatch,
     orchestrator
   ]);
-  const handleBackFromSetupDeposit = react.useCallback(() => {
+  const handleBackFromSetupDeposit = react.useCallback(async () => {
     orchestrator.cancelPendingFlow();
     authExecutor.cancelPendingExecution();
     clearScreenErrors();
+    if (isDesktop) {
+      await revokeAndDisconnectActiveWagmiConnector(wagmiConfig);
+    }
     dispatch({ type: "RESTORE_SELECTION" });
     dispatch({ type: "CLEAR_SETUP_DEPOSIT_TOKEN" });
     dispatch({ type: "SET_SETUP_FLOW_SCREEN", screen: null });
     dispatch({ type: "SET_USER_INTENT", intent: { step: "wallet-picker", reason: "switch" } });
-  }, [authExecutor, clearScreenErrors, orchestrator, dispatch]);
+  }, [authExecutor, clearScreenErrors, orchestrator, dispatch, isDesktop, wagmiConfig]);
   const handleAuthorizationRetry = react.useCallback(() => {
     void (async () => {
       try {
@@ -20429,6 +20601,11 @@ function BlinkPaymentInner({
       clearScreenErrors();
       dispatch({ type: "SET_SETUP_DEPOSIT_AMOUNT", amount });
       dispatch({ type: "SET_USER_INTENT", intent: { step: "wallet-picker", reason: "switch" } });
+      void (async () => {
+        await revokeAndDisconnectActiveWagmiConnector(wagmiConfig);
+        await authExecutor.resetWalletConnect().catch(() => {
+        });
+      })();
     },
     onBackFromSetupDeposit: handleBackFromSetupDeposit,
     onBackFromSubflow: () => {
@@ -20477,65 +20654,76 @@ function BlinkPaymentInner({
     handleSetDepositToken,
     handleConfirmSetupDeposit,
     handleBackFromSetupDeposit,
-    handleAuthorizationRetry
+    handleAuthorizationRetry,
+    wagmiConfig
   ]);
   return /* @__PURE__ */ jsxRuntime.jsx(EffectiveDepositAmountProvider, { value: effectiveDepositAmount, children: /* @__PURE__ */ jsxRuntime.jsx(
-    StepRenderer,
+    ManualTransferSessionProvider,
     {
-      flow: {
-        state,
-        authenticated: effectiveAuthenticated,
-        passkeyLoading: auth.passkeyLoginStatus !== "initial" && auth.passkeyLoginStatus !== "done" && auth.passkeyLoginStatus !== "error" || auth.passkeySignupStatus !== "initial" && auth.passkeySignupStatus !== "done" && auth.passkeySignupStatus !== "error" || auth.passkeySignupPopupActive,
-        isDesktop,
-        isMobileApp: isMobileApp ?? false,
-        merchantName,
-        onBack,
-        onDismiss,
-        depositAmount,
-        effectiveDepositAmount,
-        minTransferAmountUsd,
-        destination,
-        merchantAuthorization,
-        idempotencyKey,
-        mock,
-        onComplete,
-        onError
-      },
-      remote: {
-        pollingTransfer: polling.transfer,
-        pollingError: polling.error,
-        authExecutorError: authExecutor.error,
-        authExecutorExecuting: authExecutor.executing,
-        authExecutorCurrentAction: authExecutor.currentAction,
-        pendingOneTapSetup: orchestrator.pendingOneTapAction,
-        setupAuthorizationComplete,
-        transferSigningSigning: transferSigning.signing,
-        transferSigningError: transferSigning.error,
-        transferSigningPasskeyDismissed: transferSigning.passkeyDismissed,
-        pendingSelectSource: orchestrator.pendingSelectSourceAction
-      },
-      derived: {
-        pendingConnections: derived.pendingConnections,
-        depositEligibleAccounts: derived.depositEligibleAccounts,
-        sourceName: derived.sourceName,
-        maxSourceBalance: derived.maxSourceBalance,
-        tokenCount: derived.tokenCount,
-        selectedAccount: derived.selectedAccount,
-        selectedSource: derived.selectedSource,
-        selectSourceChoices: sourceSelection.selectSourceChoices,
-        selectSourceRecommended: sourceSelection.selectSourceRecommended,
-        selectSourceAvailableBalance: sourceSelection.selectSourceAvailableBalance
-      },
-      forms: {
-        selectSourceChainName: sourceSelection.selectSourceChainName,
-        selectSourceTokenSymbol: sourceSelection.selectSourceTokenSymbol,
-        savingOneTapLimit: oneTapSetup.savingOneTapLimit,
-        depositQuoteId: depositFee.quoteId,
-        depositQuoteFee: depositFee.quoteFee,
-        depositQuoteLoading: depositFee.quoteLoading,
-        depositQuoteError: depositFee.quoteError
-      },
-      handlers
+      destination,
+      merchantAuthorization,
+      idempotencyKey,
+      onComplete,
+      onError,
+      pollEnabled: manualTransferActive,
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        StepRenderer,
+        {
+          flow: {
+            state,
+            authenticated: effectiveAuthenticated,
+            passkeyLoading: auth.passkeyLoginStatus !== "initial" && auth.passkeyLoginStatus !== "done" && auth.passkeyLoginStatus !== "error" || auth.passkeySignupStatus !== "initial" && auth.passkeySignupStatus !== "done" && auth.passkeySignupStatus !== "error" || auth.passkeySignupPopupActive,
+            isDesktop,
+            isMobileApp: isMobileApp ?? false,
+            merchantName,
+            onBack,
+            onDismiss,
+            depositAmount,
+            effectiveDepositAmount,
+            minTransferAmountUsd,
+            destination,
+            merchantAuthorization,
+            idempotencyKey,
+            onComplete,
+            onError
+          },
+          remote: {
+            pollingTransfer: polling.transfer,
+            pollingError: polling.error,
+            authExecutorError: authExecutor.error,
+            authExecutorExecuting: authExecutor.executing,
+            authExecutorCurrentAction: authExecutor.currentAction,
+            pendingOneTapSetup: orchestrator.pendingOneTapAction,
+            setupAuthorizationComplete,
+            transferSigningSigning: transferSigning.signing,
+            transferSigningError: transferSigning.error,
+            transferSigningPasskeyDismissed: transferSigning.passkeyDismissed,
+            pendingSelectSource: orchestrator.pendingSelectSourceAction
+          },
+          derived: {
+            pendingConnections: derived.pendingConnections,
+            depositEligibleAccounts: derived.depositEligibleAccounts,
+            sourceName: derived.sourceName,
+            maxSourceBalance: derived.maxSourceBalance,
+            tokenCount: derived.tokenCount,
+            selectedAccount: derived.selectedAccount,
+            selectedSource: derived.selectedSource,
+            selectSourceChoices: sourceSelection.selectSourceChoices,
+            selectSourceRecommended: sourceSelection.selectSourceRecommended,
+            selectSourceAvailableBalance: sourceSelection.selectSourceAvailableBalance
+          },
+          forms: {
+            selectSourceChainName: sourceSelection.selectSourceChainName,
+            selectSourceTokenSymbol: sourceSelection.selectSourceTokenSymbol,
+            savingOneTapLimit: oneTapSetup.savingOneTapLimit,
+            depositQuoteId: depositFee.quoteId,
+            depositQuoteFee: depositFee.quoteFee,
+            depositQuoteLoading: depositFee.quoteLoading,
+            depositQuoteError: depositFee.quoteError
+          },
+          handlers
+        }
+      )
     }
   ) });
 }