@swype-org/react-sdk 0.1.218 → 0.1.219

package/dist/index.js

@@ -5,8 +5,9 @@ import { mainnet, arbitrum, base, polygon, bsc } from 'wagmi/chains';
 import { injected } from 'wagmi/connectors';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
-import { recoverTypedDataAddress, decodeAbiParameters, walletActions, createClient, custom } from 'viem';
+import { recoverTypedDataAddress, decodeAbiParameters, walletActions, hexToString, createClient, custom } from 'viem';
 import { parseErc6492Signature, parseAccount, getAddress } from 'viem/utils';
+import { waitForTransactionReceipt as waitForTransactionReceipt$1, getTransaction, call } from 'viem/actions';
 
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -154,6 +155,17 @@ function useBlinkDepositAmount() {
   };
 }
 
+// node_modules/@wagmi/core/dist/esm/utils/getAction.js
+function getAction(client, actionFn, name) {
+  const action_implicit = client[actionFn.name];
+  if (typeof action_implicit === "function")
+    return action_implicit;
+  const action_explicit = client[name];
+  if (typeof action_explicit === "function")
+    return action_explicit;
+  return (params) => actionFn(client, params);
+}
+
 // node_modules/@wagmi/core/dist/esm/version.js
 var version = "2.22.1";
 
@@ -413,24 +425,57 @@ async function getWalletClient(config, parameters = {}) {
   const client = await getConnectorClient(config, parameters);
   return client.extend(walletActions);
 }
+async function waitForTransactionReceipt(config, parameters) {
+  const { chainId, timeout = 0, ...rest } = parameters;
+  const client = config.getClient({ chainId });
+  const action = getAction(client, waitForTransactionReceipt$1, "waitForTransactionReceipt");
+  const receipt = await action({ ...rest, timeout });
+  if (receipt.status === "reverted") {
+    const action_getTransaction = getAction(client, getTransaction, "getTransaction");
+    const { from: account, ...txn } = await action_getTransaction({
+      hash: receipt.transactionHash
+    });
+    const action_call = getAction(client, call, "call");
+    const code = await action_call({
+      ...txn,
+      account,
+      data: txn.input,
+      gasPrice: txn.type !== "eip1559" ? txn.gasPrice : void 0,
+      maxFeePerGas: txn.type === "eip1559" ? txn.maxFeePerGas : void 0,
+      maxPriorityFeePerGas: txn.type === "eip1559" ? txn.maxPriorityFeePerGas : void 0
+    });
+    const reason = code?.data ? hexToString(`0x${code.data.substring(138)}`) : "unknown reason";
+    throw new Error(reason);
+  }
+  return {
+    ...receipt,
+    chainId: client.chain.id
+  };
+}
 
 // src/api.ts
 var api_exports = {};
 __export(api_exports, {
   createAccount: () => createAccount,
   createAccountAuthorizationSession: () => createAccountAuthorizationSession,
+  createGuestTransfer: () => createGuestTransfer,
   createTransfer: () => createTransfer,
   fetchAccount: () => fetchAccount,
   fetchAccounts: () => fetchAccounts,
   fetchAuthorizationSession: () => fetchAuthorizationSession,
   fetchChains: () => fetchChains,
+  fetchGuestTransferBalances: () => fetchGuestTransferBalances,
   fetchMerchantPublicKey: () => fetchMerchantPublicKey,
   fetchProviders: () => fetchProviders,
   fetchTransfer: () => fetchTransfer,
   fetchUserConfig: () => fetchUserConfig,
+  getGuestTransfer: () => getGuestTransfer,
+  getTransferByGuestToken: () => getTransferByGuestToken,
   registerPasskey: () => registerPasskey,
   reportActionCompletion: () => reportActionCompletion,
   reportPasskeyActivity: () => reportPasskeyActivity,
+  setTransferSender: () => setTransferSender,
+  signGuestTransfer: () => signGuestTransfer,
   signTransfer: () => signTransfer,
   updateUserConfig: () => updateUserConfig,
   updateUserConfigBySession: () => updateUserConfigBySession
@@ -643,6 +688,79 @@ async function updateUserConfigBySession(apiBaseUrl, sessionId, config) {
   );
   if (!res.ok) await throwApiError(res);
 }
+async function createGuestTransfer(apiBaseUrl, params) {
+  const body = {
+    id: params.id ?? crypto.randomUUID(),
+    type: "guest",
+    merchantAuthorization: params.merchantAuthorization,
+    destinations: params.destinations,
+    amount: {
+      amount: params.amount,
+      currency: params.currency ?? "USD"
+    },
+    providerId: params.providerId
+  };
+  const res = await fetch(`${apiBaseUrl}/v1/transfers`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) await throwApiError(res);
+  return await res.json();
+}
+async function getTransferByGuestToken(apiBaseUrl, guestToken) {
+  const params = new URLSearchParams({ guestToken });
+  const res = await fetch(`${apiBaseUrl}/v1/transfers?${params.toString()}`);
+  if (!res.ok) await throwApiError(res);
+  return await res.json();
+}
+async function setTransferSender(apiBaseUrl, transferId, guestSessionToken, senderAddress, sourceChainId, sourceToken) {
+  const res = await fetch(`${apiBaseUrl}/v1/transfers/${transferId}/sender`, {
+    method: "PUT",
+    headers: {
+      "Content-Type": "application/json",
+      "x-guest-session-token": guestSessionToken
+    },
+    body: JSON.stringify({ senderAddress, sourceChainId, sourceToken })
+  });
+  if (!res.ok) await throwApiError(res);
+  return await res.json();
+}
+async function signGuestTransfer(apiBaseUrl, transferId, guestSessionToken, originTxHash) {
+  const res = await fetch(`${apiBaseUrl}/v1/transfers/${transferId}`, {
+    method: "PATCH",
+    headers: {
+      "Content-Type": "application/json",
+      "x-guest-session-token": guestSessionToken
+    },
+    body: JSON.stringify({ originTxHash })
+  });
+  if (!res.ok) await throwApiError(res);
+  return await res.json();
+}
+async function getGuestTransfer(apiBaseUrl, transferId, guestSessionToken) {
+  const res = await fetch(`${apiBaseUrl}/v1/transfers/${transferId}`, {
+    headers: {
+      "x-guest-session-token": guestSessionToken
+    }
+  });
+  if (!res.ok) await throwApiError(res);
+  return await res.json();
+}
+async function fetchGuestTransferBalances(apiBaseUrl, transferId, guestSessionToken, walletAddress) {
+  const params = new URLSearchParams({ walletAddress });
+  const res = await fetch(
+    `${apiBaseUrl}/v1/transfers/${transferId}/balances?${params.toString()}`,
+    {
+      headers: {
+        "x-guest-session-token": guestSessionToken
+      }
+    }
+  );
+  if (!res.ok) await throwApiError(res);
+  const data = await res.json();
+  return data.items;
+}
 async function reportActionCompletion(apiBaseUrl, actionId, result) {
   const res = await fetch(
     `${apiBaseUrl}/v1/authorization-actions/${actionId}`,
@@ -1789,8 +1907,9 @@ function deriveSourceTypeAndId(state) {
   return { sourceType: "accountId", sourceId: "" };
 }
 function createInitialState(config) {
+  const isReturningUser = config.activeCredentialId != null;
   return {
-    step: "login",
+    step: isReturningUser ? "login" : "wallet-picker",
     error: null,
     providers: [],
     accounts: [],
@@ -1813,7 +1932,10 @@ function createInitialState(config) {
     mobileFlow: false,
     deeplinkUri: null,
     increasingLimit: false,
-    previousStep: null
+    previousStep: null,
+    isGuestFlow: false,
+    guestTransferId: null,
+    guestSessionToken: null
   };
 }
 function paymentReducer(state, action) {
@@ -2036,6 +2158,27 @@ function paymentReducer(state, action) {
         mobileFlow: true,
         deeplinkUri: action.deeplinkUri
       };
+    // ── Guest checkout ────────────────────────────────────────────
+    case "GUEST_PROVIDER_SELECTED":
+      return {
+        ...state,
+        isGuestFlow: true,
+        selectedProviderId: action.providerId,
+        guestTransferId: action.transferId,
+        guestSessionToken: action.guestSessionToken,
+        selectedAccountId: null,
+        selectedWalletId: null,
+        selectedTokenSymbol: null,
+        step: "token-picker"
+      };
+    case "GUEST_TRANSFER_COMPLETED":
+      return {
+        ...state,
+        transfer: action.transfer,
+        step: "success",
+        mobileFlow: false,
+        deeplinkUri: null
+      };
     // ── Navigation & error ───────────────────────────────────────
     case "NAVIGATE":
       return { ...state, step: action.step, previousStep: state.step, error: null };
@@ -2045,7 +2188,7 @@ function paymentReducer(state, action) {
     case "NEW_PAYMENT":
       return {
         ...state,
-        step: "deposit",
+        step: state.isGuestFlow ? "wallet-picker" : "deposit",
         transfer: null,
         error: null,
         amount: action.depositAmount != null ? action.depositAmount.toString() : "",
@@ -2053,7 +2196,10 @@ function paymentReducer(state, action) {
         deeplinkUri: null,
         selectedProviderId: null,
         selectedWalletId: null,
-        selectedAccountId: action.firstAccountId
+        selectedAccountId: action.firstAccountId,
+        isGuestFlow: false,
+        guestTransferId: null,
+        guestSessionToken: null
       };
     case "LOGOUT":
       return {
@@ -3236,7 +3382,9 @@ function WalletPickerScreen({
   onSelectProvider,
   onContinueConnection,
   onBack,
-  onLogout
+  onLogout,
+  onLogin,
+  showLoginOption
 }) {
   const { tokens } = useBlinkConfig();
   const [hoveredId, setHoveredId] = useState(null);
@@ -3391,6 +3539,18 @@ function WalletPickerScreen({
         /* @__PURE__ */ jsxs("div", { style: categoryRowStyle(tokens, false, true), children: [
           /* @__PURE__ */ jsx("span", { style: categoryLabelStyle, children: "Bank Account" }),
           /* @__PURE__ */ jsx("span", { style: comingSoonBadgeStyle(tokens), children: "Coming Soon" })
+        ] }),
+        showLoginOption && onLogin && /* @__PURE__ */ jsxs("div", { style: loginOptionStyle, children: [
+          /* @__PURE__ */ jsx("span", { style: loginTextStyle(tokens.textSecondary), children: "Already have an account?" }),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              onClick: onLogin,
+              style: loginButtonStyle(tokens.accent),
+              children: "Log in"
+            }
+          )
         ] })
       ]
     }
@@ -3557,6 +3717,28 @@ var dividerTextStyle = (color) => ({
   color,
   whiteSpace: "nowrap"
 });
+var loginOptionStyle = {
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "center",
+  gap: 6,
+  padding: "12px 0 4px"
+};
+var loginTextStyle = (color) => ({
+  fontSize: "0.85rem",
+  color
+});
+var loginButtonStyle = (accentColor) => ({
+  fontSize: "0.85rem",
+  fontWeight: 600,
+  color: accentColor,
+  background: "none",
+  border: "none",
+  cursor: "pointer",
+  padding: 0,
+  fontFamily: "inherit",
+  textDecoration: "underline"
+});
 var DEFAULT_MAX = 1e7;
 var ABSOLUTE_MIN = 0.01;
 var PRESETS = [100, 250, 1e3];
@@ -5394,6 +5576,179 @@ var selectCircleSelectedStyle = (color) => ({
   justifyContent: "center",
   flexShrink: 0
 });
+function GuestTokenPickerScreen({
+  entries,
+  loading,
+  setting,
+  depositAmount,
+  error,
+  onSelect,
+  onBack
+}) {
+  const { tokens: t } = useBlinkConfig();
+  if (loading) {
+    return /* @__PURE__ */ jsxs(ScreenLayout, { children: [
+      /* @__PURE__ */ jsx(ScreenHeader, { title: "Select Token", onBack }),
+      /* @__PURE__ */ jsx("div", { style: loadingWrapStyle, children: /* @__PURE__ */ jsx(Spinner, { label: "Loading balances..." }) })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs(ScreenLayout, { footer: /* @__PURE__ */ jsx(PoweredByFooter, {}), children: [
+    /* @__PURE__ */ jsx(ScreenHeader, { title: "Select Token", onBack }),
+    depositAmount != null && /* @__PURE__ */ jsxs("div", { style: depositHeaderStyle, children: [
+      /* @__PURE__ */ jsx("div", { style: depositLabelStyle3(t.textMuted), children: "Depositing" }),
+      /* @__PURE__ */ jsxs("div", { style: depositAmountStyle2(t.text), children: [
+        "$",
+        depositAmount.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })
+      ] })
+    ] }),
+    error && /* @__PURE__ */ jsx("p", { style: errorStyle3(t.error), children: error }),
+    /* @__PURE__ */ jsx("div", { style: sectionLabelStyle2(t.textMuted), children: "Choose token to pay with" }),
+    /* @__PURE__ */ jsx("div", { style: tokenListStyle3, children: entries.map((entry) => /* @__PURE__ */ jsxs(
+      "button",
+      {
+        type: "button",
+        onClick: () => onSelect(entry),
+        disabled: setting,
+        style: tokenRowStyle3(t, setting),
+        children: [
+          /* @__PURE__ */ jsx("div", { style: tokenIconCircleStyle3(t, !!TOKEN_LOGOS[entry.tokenSymbol]), children: TOKEN_LOGOS[entry.tokenSymbol] ? /* @__PURE__ */ jsx("img", { src: TOKEN_LOGOS[entry.tokenSymbol], alt: entry.tokenSymbol, style: tokenLogoImgStyle3 }) : /* @__PURE__ */ jsx("span", { style: tokenIconTextStyle3(t.textMuted), children: "$" }) }),
+          /* @__PURE__ */ jsxs("div", { style: tokenInfoStyle3, children: [
+            /* @__PURE__ */ jsxs("div", { style: tokenNameRowStyle2, children: [
+              /* @__PURE__ */ jsx("span", { style: tokenSymbolTextStyle2(t.text), children: entry.tokenSymbol }),
+              /* @__PURE__ */ jsx("span", { style: tokenChainDotStyle2(t.textMuted), children: "\xB7" }),
+              /* @__PURE__ */ jsx("span", { style: tokenChainTextStyle2(t.textMuted), children: entry.chainName })
+            ] }),
+            /* @__PURE__ */ jsxs("span", { style: tokenBalanceStyle2(t.textMuted), children: [
+              "$",
+              entry.balance.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })
+            ] })
+          ] }),
+          /* @__PURE__ */ jsx("svg", { width: "16", height: "16", viewBox: "0 0 24 24", fill: "none", style: chevronStyle, children: /* @__PURE__ */ jsx("path", { d: "M8.59 16.59L13.17 12 8.59 7.41 10 6l6 6-6 6-1.41-1.41z", fill: t.textMuted }) })
+        ]
+      },
+      `${entry.chainId}-${entry.tokenAddress}`
+    )) }),
+    entries.length === 0 && /* @__PURE__ */ jsx("p", { style: emptyStyle(t.textMuted), children: "No supported tokens found in your wallet. Please ensure you have USDC or USDT." })
+  ] });
+}
+var loadingWrapStyle = {
+  textAlign: "center",
+  padding: "48px 0",
+  flex: 1,
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "center"
+};
+var depositHeaderStyle = {
+  marginBottom: 20
+};
+var depositLabelStyle3 = (color) => ({
+  fontSize: "0.75rem",
+  fontWeight: 500,
+  color,
+  marginBottom: 4
+});
+var depositAmountStyle2 = (color) => ({
+  fontSize: "2.4rem",
+  fontWeight: 700,
+  letterSpacing: "-0.02em",
+  color
+});
+var errorStyle3 = (color) => ({
+  fontSize: "0.84rem",
+  color,
+  margin: "0 0 12px",
+  lineHeight: 1.5
+});
+var sectionLabelStyle2 = (color) => ({
+  fontSize: "0.84rem",
+  fontWeight: 500,
+  color,
+  marginBottom: 12
+});
+var tokenListStyle3 = {
+  display: "flex",
+  flexDirection: "column",
+  gap: 10
+};
+var tokenRowStyle3 = (tokens, disabled) => ({
+  display: "flex",
+  alignItems: "center",
+  gap: 14,
+  padding: "14px 16px",
+  background: tokens.bgInput,
+  border: `1px solid ${tokens.border}`,
+  borderRadius: 16,
+  cursor: disabled ? "default" : "pointer",
+  fontFamily: "inherit",
+  textAlign: "left",
+  width: "100%",
+  opacity: disabled ? 0.6 : 1,
+  transition: "opacity 0.15s ease"
+});
+var tokenIconCircleStyle3 = (tokens, hasLogo) => ({
+  width: 36,
+  height: 36,
+  borderRadius: "50%",
+  border: hasLogo ? "none" : `1.5px solid ${tokens.border}`,
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "center",
+  flexShrink: 0,
+  overflow: "hidden"
+});
+var tokenLogoImgStyle3 = {
+  width: 36,
+  height: 36,
+  borderRadius: "50%",
+  objectFit: "cover"
+};
+var tokenIconTextStyle3 = (color) => ({
+  fontSize: "1rem",
+  fontWeight: 700,
+  color
+});
+var tokenInfoStyle3 = {
+  display: "flex",
+  flexDirection: "column",
+  gap: 2,
+  flex: 1,
+  minWidth: 0
+};
+var tokenNameRowStyle2 = {
+  display: "flex",
+  alignItems: "center",
+  gap: 4
+};
+var tokenSymbolTextStyle2 = (color) => ({
+  fontSize: "0.92rem",
+  fontWeight: 600,
+  color
+});
+var tokenChainDotStyle2 = (color) => ({
+  fontSize: "0.8rem",
+  color
+});
+var tokenChainTextStyle2 = (color) => ({
+  fontSize: "0.84rem",
+  fontWeight: 400,
+  color
+});
+var tokenBalanceStyle2 = (color) => ({
+  fontSize: "0.78rem",
+  color
+});
+var chevronStyle = {
+  flexShrink: 0,
+  opacity: 0.4
+};
+var emptyStyle = (color) => ({
+  fontSize: "0.88rem",
+  color,
+  textAlign: "center",
+  padding: "32px 0",
+  lineHeight: 1.5
+});
 var LINK_STEPS = /* @__PURE__ */ new Set([
   "create-passkey",
   "verify-passkey",
@@ -5441,6 +5796,9 @@ function StepRendererContent({
   selectSourceChoices,
   selectSourceRecommended,
   selectSourceAvailableBalance,
+  guestTokenEntries,
+  guestLoadingBalances,
+  guestSettingSender,
   authInput,
   otpCode,
   selectSourceChainName,
@@ -5522,6 +5880,7 @@ function StepRendererContent({
     );
   }
   if (step === "wallet-picker") {
+    const isEntryPoint = !state.isGuestFlow && !authenticated;
     return /* @__PURE__ */ jsx(
       WalletPickerScreen,
       {
@@ -5534,8 +5893,10 @@ function StepRendererContent({
         onPrepareProvider: handlers.onPrepareProvider,
         onSelectProvider: handlers.onSelectProvider,
         onContinueConnection: handlers.onContinueConnection,
-        onBack: () => handlers.onNavigate(state.activeCredentialId ? "deposit" : "create-passkey"),
-        onLogout: handlers.onLogout
+        onBack: isEntryPoint ? onBack : () => handlers.onNavigate(state.activeCredentialId ? "deposit" : "create-passkey"),
+        onLogout: authenticated ? handlers.onLogout : void 0,
+        onLogin: handlers.onLogin,
+        showLoginOption: isEntryPoint
       }
     );
   }
@@ -5642,6 +6003,20 @@ function StepRendererContent({
     );
   }
   if (step === "token-picker") {
+    if (state.isGuestFlow) {
+      return /* @__PURE__ */ jsx(
+        GuestTokenPickerScreen,
+        {
+          entries: guestTokenEntries,
+          loading: guestLoadingBalances,
+          setting: guestSettingSender,
+          depositAmount: depositAmount ?? void 0,
+          error: state.error,
+          onSelect: handlers.onSelectGuestToken,
+          onBack: () => handlers.onNavigate("wallet-picker")
+        }
+      );
+    }
     if (!selectedAccount) {
       return /* @__PURE__ */ jsx(BlinkLoadingScreen, {});
     }
@@ -6397,12 +6772,68 @@ function useSourceSelectionHandlers(dispatch, authExecutor) {
     preSelectSourceStepRef
   };
 }
-function useMobileFlowHandlers(dispatch, polling, reloadAccounts, pollingTransferIdRef, stateTransfer, refs) {
+function useMobileFlowHandlers(dispatch, polling, reloadAccounts, pollingTransferIdRef, stateTransfer, refs, onComplete) {
   const {
     mobileSetupFlowRef,
     handlingMobileReturnRef,
     loadingDataRef
   } = refs;
+  const { apiBaseUrl } = useBlinkConfig();
+  const onCompleteRef = useRef(onComplete);
+  onCompleteRef.current = onComplete;
+  const guestPollingActiveRef = useRef(false);
+  useEffect(() => {
+    const persisted = loadMobileFlowState();
+    if (!persisted?.isGuestCheckout || !persisted.transferId || !persisted.guestSessionToken) return;
+    if (guestPollingActiveRef.current) return;
+    guestPollingActiveRef.current = true;
+    const transferId = persisted.transferId;
+    const guestSessionToken = persisted.guestSessionToken;
+    let cancelled = false;
+    const POLL_INTERVAL_MS = 3e3;
+    dispatch({ type: "NAVIGATE", step: "processing" });
+    const poll = async () => {
+      if (cancelled) return;
+      try {
+        const transfer = await getGuestTransfer(apiBaseUrl, transferId, guestSessionToken);
+        if (cancelled) return;
+        if (transfer.status === "COMPLETED") {
+          cancelled = true;
+          guestPollingActiveRef.current = false;
+          clearMobileFlowState();
+          dispatch({ type: "GUEST_TRANSFER_COMPLETED", transfer });
+          onCompleteRef.current?.(transfer);
+        } else if (transfer.status === "FAILED") {
+          cancelled = true;
+          guestPollingActiveRef.current = false;
+          clearMobileFlowState();
+          dispatch({ type: "TRANSFER_FAILED", transfer, error: "Transfer failed." });
+        }
+      } catch {
+      }
+    };
+    poll();
+    const intervalId = window.setInterval(poll, POLL_INTERVAL_MS);
+    const handleVisibility = () => {
+      if (document.visibilityState === "visible" && !cancelled) {
+        poll();
+      }
+    };
+    const handlePageShow = (e) => {
+      if (e.persisted && !cancelled) {
+        poll();
+      }
+    };
+    document.addEventListener("visibilitychange", handleVisibility);
+    window.addEventListener("pageshow", handlePageShow);
+    return () => {
+      cancelled = true;
+      guestPollingActiveRef.current = false;
+      window.clearInterval(intervalId);
+      document.removeEventListener("visibilitychange", handleVisibility);
+      window.removeEventListener("pageshow", handlePageShow);
+    };
+  }, [apiBaseUrl, dispatch]);
   const handleAuthorizedMobileReturn = useCallback(async (authorizedTransfer, isSetup) => {
     if (handlingMobileReturnRef.current) return;
     handlingMobileReturnRef.current = true;
@@ -6461,9 +6892,17 @@ function useProviderHandlers(deps) {
     handlingMobileReturnRef,
     setupAccountIdRef,
     reauthSessionIdRef,
-    reauthTokenRef
+    reauthTokenRef,
+    authenticated,
+    merchantAuthorization,
+    destination
   } = deps;
+  const wagmiConfig2 = useConfig();
+  const { connectAsync, connectors } = useConnect();
   const handlePrepareProvider = useCallback(async (providerId) => {
+    if (!authenticated) {
+      return null;
+    }
     if (!activeCredentialId) {
       dispatch({ type: "SET_ERROR", error: "Create or verify a passkey on this device before continuing." });
       dispatch({ type: "NAVIGATE", step: "create-passkey" });
@@ -6491,8 +6930,85 @@ function useProviderHandlers(deps) {
       onError?.(msg);
       return null;
     }
-  }, [activeCredentialId, providers, apiBaseUrl, getAccessToken, onError, dispatch]);
+  }, [authenticated, activeCredentialId, providers, apiBaseUrl, getAccessToken, onError, dispatch]);
+  const handleGuestSelectProvider = useCallback(async (providerId) => {
+    if (!merchantAuthorization || !destination) {
+      const msg = "Missing payment configuration for guest checkout.";
+      dispatch({ type: "PAY_ERROR", error: msg, fallbackStep: "wallet-picker" });
+      onError?.(msg);
+      return;
+    }
+    const isMobile = !shouldUseWalletConnector({
+      useWalletConnector: useWalletConnectorProp,
+      userAgent: typeof navigator === "undefined" ? void 0 : navigator.userAgent
+    });
+    dispatch({ type: "SELECT_PROVIDER", providerId });
+    try {
+      const result = await createGuestTransfer(apiBaseUrl, {
+        merchantAuthorization,
+        destinations: [{
+          chainId: destination.chainId,
+          token: { address: destination.token.address },
+          address: destination.address
+        }],
+        amount: depositAmount ?? 0,
+        providerId
+      });
+      if (isMobile) {
+        if (!result.uri) {
+          dispatch({ type: "PAY_ERROR", error: "This wallet is not available on mobile.", fallbackStep: "wallet-picker" });
+          return;
+        }
+        persistMobileFlowState({
+          transferId: result.id,
+          guestSessionToken: result.guestSessionToken,
+          isGuestCheckout: true,
+          deeplinkUri: result.uri,
+          providerId,
+          isSetup: false
+        });
+        triggerDeeplink(result.uri);
+        dispatch({ type: "MOBILE_DEEPLINK_READY", deeplinkUri: result.uri });
+      } else {
+        const account = getAccount(wagmiConfig2);
+        if (!account.isConnected) {
+          const connector = connectors.find((c) => c.type === "injected") ?? connectors[0];
+          if (!connector) {
+            dispatch({ type: "PAY_ERROR", error: "No wallet extension found. Please install a supported wallet.", fallbackStep: "wallet-picker" });
+            return;
+          }
+          await connectAsync({ connector });
+        }
+        dispatch({
+          type: "GUEST_PROVIDER_SELECTED",
+          providerId,
+          transferId: result.id,
+          guestSessionToken: result.guestSessionToken
+        });
+      }
+    } catch (err) {
+      captureException(err);
+      const msg = err instanceof Error ? err.message : "Failed to start guest checkout";
+      dispatch({ type: "PAY_ERROR", error: msg, fallbackStep: "wallet-picker" });
+      onError?.(msg);
+    }
+  }, [
+    merchantAuthorization,
+    destination,
+    apiBaseUrl,
+    depositAmount,
+    useWalletConnectorProp,
+    wagmiConfig2,
+    connectors,
+    connectAsync,
+    onError,
+    dispatch
+  ]);
   const handleSelectProvider = useCallback(async (providerId, preparedSession) => {
+    if (!authenticated) {
+      await handleGuestSelectProvider(providerId);
+      return;
+    }
     dispatch({ type: "SELECT_PROVIDER", providerId });
     if (!activeCredentialId) {
       dispatch({ type: "SET_ERROR", error: "Create or verify a passkey on this device before continuing." });
@@ -6562,6 +7078,8 @@ function useProviderHandlers(deps) {
       }
     }
   }, [
+    authenticated,
+    handleGuestSelectProvider,
     activeCredentialId,
     providers,
     apiBaseUrl,
@@ -6797,6 +7315,217 @@ function useProviderHandlers(deps) {
     handleAuthorizeToken
   };
 }
+
+// src/guestTokens.ts
+function mapBalancesToGuestTokenEntries(options) {
+  return options.map((opt) => ({
+    chainId: opt.chainId,
+    sourceChainId: opt.sourceChainId,
+    chainName: opt.chainName,
+    tokenSymbol: opt.tokenSymbol,
+    tokenAddress: opt.tokenAddress,
+    decimals: opt.decimals,
+    rawBalance: opt.rawBalance,
+    balance: Number(opt.rawBalance) / 10 ** opt.decimals
+  })).filter((entry) => entry.balance > 0).sort((a, b) => b.balance - a.balance);
+}
+
+// src/hooks/useGuestTransferHandlers.ts
+var GUEST_SIGN_POLL_MS = 2e3;
+var GUEST_SIGN_MAX_POLLS = 90;
+var GUEST_COMPLETION_POLL_MS = 3e3;
+var GUEST_COMPLETION_MAX_POLLS = 120;
+function isUserRejection2(msg) {
+  const lower = msg.toLowerCase();
+  return lower.includes("rejected") || lower.includes("denied") || lower.includes("cancelled");
+}
+function useGuestTransferHandlers(deps) {
+  const {
+    dispatch,
+    isGuestFlow,
+    guestTransferId,
+    guestSessionToken,
+    step,
+    onComplete,
+    onError
+  } = deps;
+  const { apiBaseUrl } = useBlinkConfig();
+  const wagmiConfig2 = useConfig();
+  const { switchChainAsync } = useSwitchChain();
+  const [guestTokenEntries, setGuestTokenEntries] = useState([]);
+  const [loadingBalances, setLoadingBalances] = useState(false);
+  const [settingSender, setSettingSender] = useState(false);
+  const executingBridgeRef = useRef(false);
+  const fetchedRef = useRef(false);
+  const selectedGuestTokenRef = useRef(null);
+  useEffect(() => {
+    if (!isGuestFlow || step !== "token-picker" || fetchedRef.current) return;
+    if (!guestTransferId || !guestSessionToken) return;
+    const account = getAccount(wagmiConfig2);
+    if (!account.address) return;
+    fetchedRef.current = true;
+    setLoadingBalances(true);
+    fetchGuestTransferBalances(apiBaseUrl, guestTransferId, guestSessionToken, account.address).then((options) => mapBalancesToGuestTokenEntries(options)).then((entries) => {
+      setGuestTokenEntries(entries);
+      if (entries.length === 0) {
+        dispatch({ type: "SET_ERROR", error: "No supported tokens found in your wallet." });
+      }
+    }).catch((err) => {
+      captureException(err);
+      dispatch({ type: "SET_ERROR", error: "Failed to fetch token balances." });
+    }).finally(() => setLoadingBalances(false));
+  }, [isGuestFlow, step, guestTransferId, guestSessionToken, apiBaseUrl, wagmiConfig2, dispatch]);
+  useEffect(() => {
+    if (!isGuestFlow) {
+      fetchedRef.current = false;
+      selectedGuestTokenRef.current = null;
+      setGuestTokenEntries([]);
+    }
+  }, [isGuestFlow]);
+  const handleSelectGuestToken = useCallback(async (entry) => {
+    if (!guestTransferId || !guestSessionToken) return;
+    const account = getAccount(wagmiConfig2);
+    if (!account.address) {
+      dispatch({ type: "SET_ERROR", error: "Wallet not connected." });
+      return;
+    }
+    setSettingSender(true);
+    try {
+      console.info(
+        `[blink-sdk] type=guest Setting sender: address=${account.address}, chain=${entry.sourceChainId}, token=${entry.tokenSymbol}`
+      );
+      await setTransferSender(
+        apiBaseUrl,
+        guestTransferId,
+        guestSessionToken,
+        account.address,
+        entry.sourceChainId,
+        entry.tokenAddress
+      );
+      selectedGuestTokenRef.current = entry;
+      dispatch({ type: "NAVIGATE", step: "processing" });
+    } catch (err) {
+      captureException(err);
+      const msg = err instanceof Error ? err.message : "Failed to set transfer sender";
+      dispatch({ type: "SET_ERROR", error: msg });
+      onError?.(msg);
+    } finally {
+      setSettingSender(false);
+    }
+  }, [guestTransferId, guestSessionToken, wagmiConfig2, apiBaseUrl, dispatch, onError]);
+  useEffect(() => {
+    if (!isGuestFlow || step !== "processing" || !guestTransferId || !guestSessionToken) return;
+    if (executingBridgeRef.current) return;
+    executingBridgeRef.current = true;
+    const execute = async () => {
+      try {
+        let signPayload = null;
+        for (let i = 0; i < GUEST_SIGN_MAX_POLLS; i++) {
+          const transfer = await getGuestTransfer(apiBaseUrl, guestTransferId, guestSessionToken);
+          const payload = transfer.signPayload;
+          if (payload?.bridgeSteps && payload.bridgeSteps.length > 0) {
+            signPayload = payload;
+            break;
+          }
+          if (transfer.status === "FAILED") {
+            dispatch({ type: "PAY_ERROR", error: "Transfer failed.", fallbackStep: "wallet-picker" });
+            return;
+          }
+          await new Promise((r) => setTimeout(r, GUEST_SIGN_POLL_MS));
+        }
+        if (!signPayload) {
+          dispatch({
+            type: "PAY_ERROR",
+            error: "Timed out waiting for bridge quote. Please try again.",
+            fallbackStep: "wallet-picker"
+          });
+          return;
+        }
+        console.info(
+          `[blink-sdk] type=guest Bridge quote ready: ${signPayload.bridgeSteps.length} step(s), token=${signPayload.tokenSymbol}, chain=${signPayload.chainName}`
+        );
+        const selectedToken = selectedGuestTokenRef.current;
+        const account = getAccount(wagmiConfig2);
+        const targetChainId = selectedToken?.chainId;
+        if (targetChainId) {
+          const numericChainId = Number(targetChainId);
+          if (!isNaN(numericChainId) && account.chainId !== numericChainId) {
+            console.info(`[blink-sdk] type=guest Switching chain to ${numericChainId}`);
+            await switchChainAsync({ chainId: numericChainId });
+          }
+        }
+        const walletClient = await getWalletClient(wagmiConfig2);
+        const sender = account.address;
+        if (!sender) {
+          dispatch({ type: "PAY_ERROR", error: "Wallet not connected.", fallbackStep: "wallet-picker" });
+          return;
+        }
+        let lastTxHash = null;
+        for (let stepIdx = 0; stepIdx < signPayload.bridgeSteps.length; stepIdx++) {
+          const bridgeStep = signPayload.bridgeSteps[stepIdx];
+          console.info(
+            `[blink-sdk] type=guest Executing bridge step ${stepIdx + 1}/${signPayload.bridgeSteps.length} to=${bridgeStep.to}`
+          );
+          const txHash = await walletClient.request({
+            method: "eth_sendTransaction",
+            params: [{
+              from: sender,
+              to: bridgeStep.to,
+              data: bridgeStep.data,
+              value: bridgeStep.value
+            }]
+          });
+          console.info(`[blink-sdk] type=guest Bridge step ${stepIdx + 1} tx sent: ${txHash}`);
+          await waitForTransactionReceipt(wagmiConfig2, {
+            hash: txHash
+          });
+          lastTxHash = txHash;
+        }
+        if (!lastTxHash) {
+          dispatch({ type: "PAY_ERROR", error: "No bridge transactions were executed.", fallbackStep: "wallet-picker" });
+          return;
+        }
+        console.info(`[blink-sdk] type=guest Submitting originTxHash: ${lastTxHash}`);
+        await signGuestTransfer(apiBaseUrl, guestTransferId, guestSessionToken, lastTxHash);
+        for (let i = 0; i < GUEST_COMPLETION_MAX_POLLS; i++) {
+          const transfer = await getGuestTransfer(apiBaseUrl, guestTransferId, guestSessionToken);
+          if (transfer.status === "COMPLETED") {
+            console.info(`[blink-sdk] type=guest Transfer completed`);
+            dispatch({ type: "GUEST_TRANSFER_COMPLETED", transfer });
+            onComplete?.(transfer);
+            return;
+          }
+          if (transfer.status === "FAILED") {
+            dispatch({ type: "TRANSFER_FAILED", transfer, error: "Transfer failed." });
+            return;
+          }
+          await new Promise((r) => setTimeout(r, GUEST_COMPLETION_POLL_MS));
+        }
+        dispatch({
+          type: "PAY_ERROR",
+          error: "Transfer is taking longer than expected. It may still complete.",
+          fallbackStep: "wallet-picker"
+        });
+      } catch (err) {
+        captureException(err);
+        const msg = err instanceof Error ? err.message : "Bridge execution failed";
+        console.error("[blink-sdk] type=guest Bridge execution error:", err);
+        const displayMsg = isUserRejection2(msg) ? "You rejected the transaction. Please approve in your wallet to continue." : msg;
+        dispatch({ type: "PAY_ERROR", error: displayMsg, fallbackStep: "wallet-picker" });
+        onError?.(displayMsg);
+      } finally {
+        executingBridgeRef.current = false;
+      }
+    };
+    execute();
+  }, [isGuestFlow, step, guestTransferId, guestSessionToken, apiBaseUrl, wagmiConfig2, switchChainAsync, dispatch, onComplete, onError]);
+  return {
+    guestTokenEntries,
+    loadingBalances,
+    settingSender,
+    handleSelectGuestToken
+  };
+}
 function useOneTapSetupHandlers(deps) {
   const {
     dispatch,
@@ -7592,7 +8321,8 @@ function BlinkPaymentInner({
     transfer.reloadAccounts,
     transfer.pollingTransferIdRef,
     state.transfer,
-    mobileFlowRefs
+    mobileFlowRefs,
+    onComplete
   );
   const sourceSelection = useSourceSelectionHandlers(dispatch, authExecutor);
   const provider = useProviderHandlers({
@@ -7615,7 +8345,10 @@ function BlinkPaymentInner({
     handlingMobileReturnRef: mobileFlowRefs.handlingMobileReturnRef,
     setupAccountIdRef: mobileFlowRefs.setupAccountIdRef,
     reauthSessionIdRef: mobileFlowRefs.reauthSessionIdRef,
-    reauthTokenRef: mobileFlowRefs.reauthTokenRef
+    reauthTokenRef: mobileFlowRefs.reauthTokenRef,
+    authenticated,
+    merchantAuthorization,
+    destination
   });
   const oneTapSetup = useOneTapSetupHandlers({
     dispatch,
@@ -7625,6 +8358,15 @@ function BlinkPaymentInner({
     selectSourceChainName: sourceSelection.selectSourceChainName,
     selectSourceTokenSymbol: sourceSelection.selectSourceTokenSymbol
   });
+  const guestTransfer = useGuestTransferHandlers({
+    dispatch,
+    isGuestFlow: state.isGuestFlow,
+    guestTransferId: state.guestTransferId,
+    guestSessionToken: state.guestSessionToken,
+    step: state.step,
+    onComplete,
+    onError
+  });
   const handleNewPayment = useCallback(() => {
     clearMobileFlowState();
     transfer.processingStartedAtRef.current = null;
@@ -7725,7 +8467,9 @@ function BlinkPaymentInner({
     onSetupOneTap: oneTapSetup.handleSetupOneTap,
     onSelectToken: provider.handleNavigateToTokenPicker,
     onSelectAuthorizedToken: provider.handleSelectAuthorizedToken,
-    onAuthorizeToken: provider.handleAuthorizeToken
+    onAuthorizeToken: provider.handleAuthorizeToken,
+    onSelectGuestToken: guestTransfer.handleSelectGuestToken,
+    onLogin: () => dispatch({ type: "NAVIGATE", step: "login" })
   }), [
     auth,
     passkey,
@@ -7734,6 +8478,7 @@ function BlinkPaymentInner({
     mobileFlow,
     sourceSelection,
     oneTapSetup,
+    guestTransfer,
     handleLogout,
     handleNewPayment
   ]);
@@ -7759,6 +8504,9 @@ function BlinkPaymentInner({
       selectSourceChoices: sourceSelection.selectSourceChoices,
       selectSourceRecommended: sourceSelection.selectSourceRecommended,
       selectSourceAvailableBalance: sourceSelection.selectSourceAvailableBalance,
+      guestTokenEntries: guestTransfer.guestTokenEntries,
+      guestLoadingBalances: guestTransfer.loadingBalances,
+      guestSettingSender: guestTransfer.settingSender,
       authInput: auth.authInput,
       otpCode: auth.otpCode,
       selectSourceChainName: sourceSelection.selectSourceChainName,