@swype-org/react-sdk 0.1.271 → 0.1.277

package/dist/index.cjs

@@ -1856,6 +1856,17 @@ function effectiveMinTransferAmountUsd(depositAmount) {
 }
 function persistMobileFlowState(data) {
   try {
+    console.info("[blink-sdk] persistMobileFlowState", {
+      isGuestPreauth: data.isGuestPreauth ?? false,
+      isGuestCheckout: data.isGuestCheckout ?? false,
+      isReauthorization: data.isReauthorization ?? false,
+      isSetup: data.isSetup,
+      hasGuestSessionToken: !!data.guestSessionToken,
+      hasSessionId: !!data.sessionId,
+      hasAccountId: !!data.accountId,
+      hasTransferId: !!data.transferId,
+      caller: new Error().stack?.split("\n")[2]?.trim()
+    });
     sessionStorage.setItem(MOBILE_FLOW_STORAGE_KEY, JSON.stringify(data));
   } catch {
   }
@@ -1871,6 +1882,10 @@ function loadMobileFlowState() {
 }
 function clearMobileFlowState() {
   try {
+    console.info("[blink-sdk] clearMobileFlowState", {
+      hadState: sessionStorage.getItem(MOBILE_FLOW_STORAGE_KEY) != null,
+      caller: new Error().stack?.split("\n")[2]?.trim()
+    });
     sessionStorage.removeItem(MOBILE_FLOW_STORAGE_KEY);
   } catch {
   }
@@ -2196,6 +2211,25 @@ function resolvePhase(state) {
   } else {
     nextPhase = { step: "wallet-picker", reason: "entry" };
   }
+  if (state.guestPreauthSessionId != null) {
+    console.info("[blink-sdk] resolvePhase (guest preauth context)", {
+      resolvedStep: nextPhase.step,
+      currentStep: currentPhase.step,
+      branchGuestPostPayLogin,
+      branchMobileWalletSetup,
+      branchLoginRequested,
+      branchCompleted,
+      branchKeepGuestPreauthPin,
+      branchGuestSetupComplete,
+      transferStatus: state.transfer?.status ?? null,
+      mobileFlow: state.mobileFlow,
+      deeplinkUri: state.deeplinkUri != null,
+      loginRequested: state.loginRequested,
+      guestPreauthorizing: state.guestPreauthorizing,
+      privyAuthenticated: state.privyAuthenticated,
+      isGuestFlow: state.isGuestFlow
+    });
+  }
   return nextPhase;
 }
 
@@ -2263,6 +2297,30 @@ function paymentReducer(state, action) {
       loginRequested: next.loginRequested
     });
   }
+  if (action.type === "REQUEST_LOGIN") {
+    console.info("[blink-sdk] reducer REQUEST_LOGIN", {
+      resolvedPhase: phase.step,
+      mobileFlow: next.mobileFlow,
+      loginRequested: next.loginRequested,
+      guestPreauthSessionId: next.guestPreauthSessionId,
+      guestPreauthAccountId: next.guestPreauthAccountId,
+      transferStatus: next.transfer?.status ?? null,
+      isGuestFlow: next.isGuestFlow,
+      privyReady: next.privyReady,
+      privyAuthenticated: next.privyAuthenticated
+    });
+  }
+  if (action.type === "MOBILE_SETUP_COMPLETE") {
+    console.info("[blink-sdk] reducer MOBILE_SETUP_COMPLETE", {
+      resolvedPhase: phase.step,
+      mobileFlow: next.mobileFlow,
+      deeplinkUri: next.deeplinkUri,
+      loginRequested: next.loginRequested,
+      guestPreauthSessionId: next.guestPreauthSessionId,
+      transferStatus: next.transfer?.status ?? null,
+      isGuestFlow: next.isGuestFlow
+    });
+  }
   return { ...next, phase };
 }
 function applyAction(state, action) {
@@ -2413,7 +2471,12 @@ function applyAction(state, action) {
       return {
         ...state,
         mobileFlow: true,
-        deeplinkUri: action.deeplinkUri
+        deeplinkUri: action.deeplinkUri,
+        ...action.guestTransferId != null && {
+          guestTransferId: action.guestTransferId,
+          guestSessionToken: action.guestSessionToken ?? null,
+          isGuestFlow: true
+        }
       };
     case "MOBILE_SETUP_COMPLETE":
       return {
@@ -2531,6 +2594,7 @@ function applyAction(state, action) {
         mobileFlow: false,
         deeplinkUri: null,
         isGuestFlow: true,
+        guestTransferId: null,
         guestSessionToken: action.guestSessionToken ?? state.guestSessionToken
       };
     case "GUEST_PREAUTH_DETECTED":
@@ -7199,7 +7263,7 @@ function useSourceSelectionHandlers(dispatch, authExecutor, options) {
     initializedSelectSourceActionRef
   };
 }
-function useMobileFlowHandlers(dispatch, polling, reloadAccounts, pollingTransferIdRef, stateTransfer, refs, onComplete) {
+function useMobileFlowHandlers(dispatch, polling, reloadAccounts, pollingTransferIdRef, stateTransfer, refs, guestCheckout, onComplete) {
   const {
     mobileSetupFlowRef,
     handlingMobileReturnRef,
@@ -7210,6 +7274,10 @@ function useMobileFlowHandlers(dispatch, polling, reloadAccounts, pollingTransfe
   onCompleteRef.current = onComplete;
   const guestPollingActiveRef = react.useRef(false);
   const guestPollingCleanupRef = react.useRef(null);
+  const guestTransferIdRef = react.useRef(guestCheckout.guestTransferId);
+  guestTransferIdRef.current = guestCheckout.guestTransferId;
+  const guestSessionTokenRef = react.useRef(guestCheckout.guestSessionToken);
+  guestSessionTokenRef.current = guestCheckout.guestSessionToken;
   const startGuestPolling = react.useCallback((transferId, guestSessionToken) => {
     if (guestPollingActiveRef.current) return;
     guestPollingActiveRef.current = true;
@@ -7225,14 +7293,12 @@ function useMobileFlowHandlers(dispatch, polling, reloadAccounts, pollingTransfe
           cancelled = true;
           guestPollingActiveRef.current = false;
           guestPollingCleanupRef.current = null;
-          clearMobileFlowState();
           dispatch({ type: "GUEST_TRANSFER_COMPLETED", transfer, guestSessionToken });
           onCompleteRef.current?.(transfer);
         } else if (transfer.status === "FAILED") {
           cancelled = true;
           guestPollingActiveRef.current = false;
           guestPollingCleanupRef.current = null;
-          clearMobileFlowState();
           dispatch({ type: "TRANSFER_FAILED", transfer, error: "Transfer failed." });
         }
       } catch {
@@ -7249,20 +7315,26 @@ function useMobileFlowHandlers(dispatch, polling, reloadAccounts, pollingTransfe
     guestPollingCleanupRef.current = cleanup;
   }, [apiBaseUrl, dispatch]);
   react.useEffect(() => {
-    const persisted = loadMobileFlowState();
-    if (persisted?.isGuestCheckout && persisted.transferId && persisted.guestSessionToken) {
-      startGuestPolling(persisted.transferId, persisted.guestSessionToken);
+    if (guestCheckout.mobileFlow && guestCheckout.isGuestFlow && guestCheckout.guestTransferId && guestCheckout.guestSessionToken) {
+      startGuestPolling(guestCheckout.guestTransferId, guestCheckout.guestSessionToken);
     }
     return () => {
       guestPollingCleanupRef.current?.();
     };
-  }, [startGuestPolling]);
+  }, [
+    guestCheckout.mobileFlow,
+    guestCheckout.isGuestFlow,
+    guestCheckout.guestTransferId,
+    guestCheckout.guestSessionToken,
+    startGuestPolling
+  ]);
   react.useEffect(() => {
     const tryStartPolling = () => {
       if (guestPollingActiveRef.current) return;
-      const persisted = loadMobileFlowState();
-      if (persisted?.isGuestCheckout && persisted.transferId && persisted.guestSessionToken) {
-        startGuestPolling(persisted.transferId, persisted.guestSessionToken);
+      const transferId = guestTransferIdRef.current;
+      const token = guestSessionTokenRef.current;
+      if (transferId && token) {
+        startGuestPolling(transferId, token);
       }
     };
     const handleVisibility = () => {
@@ -7342,7 +7414,8 @@ function useProviderHandlers(deps) {
     destination,
     guestSessionToken,
     guestTransferId,
-    selectedProviderId
+    selectedProviderId,
+    startGuestAccountPolling
   } = deps;
   const wagmiConfig2 = wagmi.useConfig();
   const { connectAsync, connectors } = wagmi.useConnect();
@@ -7405,16 +7478,13 @@ function useProviderHandlers(deps) {
           dispatch({ type: "PAY_ERROR", error: "This wallet is not available on mobile." });
           return;
         }
-        persistMobileFlowState({
-          transferId: result.id,
-          guestSessionToken: result.guestSessionToken,
-          isGuestCheckout: true,
+        triggerDeeplink(result.uri);
+        dispatch({
+          type: "MOBILE_DEEPLINK_READY",
           deeplinkUri: result.uri,
-          providerId,
-          isSetup: false
+          guestTransferId: result.id,
+          guestSessionToken: result.guestSessionToken
         });
-        triggerDeeplink(result.uri);
-        dispatch({ type: "MOBILE_DEEPLINK_READY", deeplinkUri: result.uri });
       } else {
         const account = getAccount(wagmiConfig2);
         if (!account.isConnected) {
@@ -7750,6 +7820,14 @@ function useProviderHandlers(deps) {
       useWalletConnector: useWalletConnectorProp,
       userAgent: typeof navigator === "undefined" ? void 0 : navigator.userAgent
     });
+    console.info("[blink-sdk] handlePreauthorize", {
+      isMobile,
+      useWalletConnectorProp,
+      hasGuestSessionToken: !!guestSessionToken,
+      selectedProviderId,
+      guestTransferId,
+      userAgent: typeof navigator === "undefined" ? null : navigator.userAgent
+    });
     const providerName = providers.find((p) => p.id === selectedProviderId)?.name ?? "Wallet";
     if (!isMobile) {
       dispatch({ type: "GUEST_PREAUTH_BEGIN" });
@@ -7782,6 +7860,7 @@ function useProviderHandlers(deps) {
         triggerDeeplink(created.sessionUri);
         dispatch({ type: "MOBILE_DEEPLINK_READY", deeplinkUri: created.sessionUri });
       }
+      startGuestAccountPolling(guestSessionToken, session.id);
       dispatch({
         type: "GUEST_PREAUTH_DETECTED",
         accountId: created.accountId,
@@ -7809,7 +7888,8 @@ function useProviderHandlers(deps) {
     useWalletConnectorProp,
     mobileSetupFlowRef,
     handlingMobileReturnRef,
-    setupAccountIdRef
+    setupAccountIdRef,
+    startGuestAccountPolling
   ]);
   return {
     handlePrepareProvider,
@@ -8169,7 +8249,8 @@ function usePasskeyCheckEffect(deps) {
     setupAccountIdRef,
     reauthSessionIdRef,
     reauthTokenRef,
-    pollingTransferIdRef
+    pollingTransferIdRef,
+    startGuestAccountPolling
   } = deps;
   const { getAccessToken } = reactAuth.usePrivy();
   const onCompleteRef = react.useRef(deps.onComplete);
@@ -8192,8 +8273,23 @@ function usePasskeyCheckEffect(deps) {
     dispatch({ type: "SET_ERROR", error: null });
     setAuthInput("");
     setOtpCode("");
+    const startGuestAccountPollingRef = startGuestAccountPolling;
     const restoreState = async (credId, token) => {
       const persisted = loadMobileFlowState();
+      if (persisted?.isGuestPreauth && persisted.guestSessionToken && persisted.sessionId) {
+        mobileSetupFlowRef.current = true;
+        if (persisted.accountId) {
+          setupAccountIdRef.current = persisted.accountId;
+          dispatch({
+            type: "GUEST_PREAUTH_DETECTED",
+            accountId: persisted.accountId,
+            sessionId: persisted.sessionId
+          });
+        }
+        dispatch({ type: "MOBILE_DEEPLINK_READY", deeplinkUri: persisted.deeplinkUri });
+        startGuestAccountPollingRef(persisted.guestSessionToken, persisted.sessionId);
+        return;
+      }
       let accts = [];
       try {
         accts = await fetchAccounts(apiBaseUrl, token, credId);
@@ -8694,100 +8790,6 @@ function useMobilePollingEffect(deps) {
     handlingMobileReturnRef,
     mobileSetupFlowRef
   ]);
-  react.useEffect(() => {
-    if (!state.mobileFlow || !state.isGuestFlow || !state.guestPreauthSessionId || !state.guestPreauthAccountId) {
-      return;
-    }
-    const guestToken = state.guestSessionToken ?? loadMobileFlowState()?.guestSessionToken ?? null;
-    const preauthAccountId = state.guestPreauthAccountId;
-    const preauthSessionId = state.guestPreauthSessionId;
-    let cancelled = false;
-    let completedGuestPreauth = false;
-    const POLL_INTERVAL_MS = 3e3;
-    const finishMobileAndDispatch = async () => {
-      mobileSetupFlowRef.current = false;
-      setupAccountIdRef.current = null;
-      try {
-        await reloadAccounts();
-      } catch {
-      }
-    };
-    const completeGuestPreauthWithoutToken = async () => {
-      if (completedGuestPreauth) return;
-      completedGuestPreauth = true;
-      cancelled = true;
-      await finishMobileAndDispatch();
-      clearMobileFlowState();
-      dispatch({ type: "MOBILE_SETUP_COMPLETE" });
-    };
-    const completeGuestPreauthWithAccount = async (guestLookup) => {
-      if (completedGuestPreauth) return;
-      completedGuestPreauth = true;
-      cancelled = true;
-      await finishMobileAndDispatch();
-      if (guestLookup.accountId !== preauthAccountId) {
-        dispatch({
-          type: "GUEST_PREAUTH_DETECTED",
-          accountId: guestLookup.accountId,
-          sessionId: preauthSessionId ?? void 0
-        });
-      }
-      dispatch({ type: "REQUEST_LOGIN" });
-      dispatch({ type: "MOBILE_SETUP_COMPLETE" });
-    };
-    const pollGuestAccount = async () => {
-      try {
-        if (cancelled) return;
-        if (!guestToken) {
-          await completeGuestPreauthWithoutToken();
-          return;
-        }
-        const guestLookup = await fetchGuestAccount(apiBaseUrl, guestToken);
-        if (cancelled) return;
-        if (guestLookup != null) {
-          if (preauthSessionId) {
-            try {
-              const session = await fetchAuthorizationSession(
-                apiBaseUrl,
-                preauthSessionId
-              );
-              if (cancelled) return;
-              if (session.status !== "AUTHORIZED") return;
-            } catch {
-              return;
-            }
-          }
-          await completeGuestPreauthWithAccount(guestLookup);
-        }
-      } catch {
-      }
-    };
-    pollGuestAccount();
-    const intervalId = window.setInterval(pollGuestAccount, POLL_INTERVAL_MS);
-    const handleVisibility = () => {
-      if (document.visibilityState === "visible" && !cancelled) void pollGuestAccount();
-    };
-    const handlePageShow = () => {
-      if (document.visibilityState === "visible" && !cancelled) void pollGuestAccount();
-    };
-    document.addEventListener("visibilitychange", handleVisibility);
-    window.addEventListener("pageshow", handlePageShow);
-    return () => {
-      cancelled = true;
-      window.clearInterval(intervalId);
-      document.removeEventListener("visibilitychange", handleVisibility);
-      window.removeEventListener("pageshow", handlePageShow);
-    };
-  }, [
-    state.mobileFlow,
-    state.guestPreauthSessionId,
-    state.isGuestFlow,
-    state.guestSessionToken,
-    state.guestPreauthAccountId,
-    apiBaseUrl,
-    reloadAccounts,
-    dispatch
-  ]);
   react.useEffect(() => {
     if (!state.mobileFlow || !mobileSetupFlowRef.current) return;
     if (state.isGuestFlow && state.guestPreauthSessionId != null) return;
@@ -8926,106 +8928,82 @@ function useMobilePollingEffect(deps) {
     pollingTransferIdRef
   ]);
 }
-var guestPreauthRestoreAttemptedKeys = /* @__PURE__ */ new Set();
-function guestPreauthRestoreKey(guestToken) {
-  return guestToken;
-}
 function useGuestPreauthMobileRestoreEffect(deps) {
-  const { dispatch, apiBaseUrl, privyReady, mobileSetupFlowRef, setupAccountIdRef } = deps;
-  const completedRef = react.useRef(false);
-  const pollingCleanupRef = react.useRef(null);
+  const {
+    dispatch,
+    privyReady,
+    mobileSetupFlowRef,
+    setupAccountIdRef,
+    startGuestAccountPolling
+  } = deps;
+  const startedRef = react.useRef(false);
   react.useEffect(() => {
-    if (!privyReady) return;
-    const tryStart = () => {
-      if (completedRef.current) return;
+    if (!privyReady) {
+      console.info("[blink-sdk] guestPreauthMobileRestore: skipping, privyReady=false");
+      return;
+    }
+    const tryStart = (trigger) => {
+      if (startedRef.current) {
+        console.info("[blink-sdk] guestPreauthMobileRestore.tryStart: already started", { trigger });
+        return;
+      }
       const persisted = loadMobileFlowState();
-      if (!persisted?.isGuestPreauth || !persisted.guestSessionToken) {
+      console.info("[blink-sdk] guestPreauthMobileRestore.tryStart", {
+        trigger,
+        hasPersistedState: !!persisted,
+        isGuestPreauth: persisted?.isGuestPreauth ?? false,
+        hasGuestSessionToken: !!persisted?.guestSessionToken,
+        hasSessionId: !!persisted?.sessionId,
+        accountId: persisted?.accountId ?? null
+      });
+      if (!persisted?.isGuestPreauth || !persisted.guestSessionToken || !persisted.sessionId) {
         return;
       }
-      const guestToken = persisted.guestSessionToken;
-      const key = guestPreauthRestoreKey(guestToken);
-      if (guestPreauthRestoreAttemptedKeys.has(key)) return;
-      guestPreauthRestoreAttemptedKeys.add(key);
-      let cancelled = false;
-      const POLL_INTERVAL_MS = 3e3;
+      startedRef.current = true;
       mobileSetupFlowRef.current = true;
       if (persisted.accountId) {
         setupAccountIdRef.current = persisted.accountId;
       }
-      const handleAccountFound = async (guestLookup) => {
-        if (completedRef.current) return;
-        completedRef.current = true;
-        cancelled = true;
-        clearMobileFlowState();
-        mobileSetupFlowRef.current = false;
-        setupAccountIdRef.current = null;
+      if (persisted.accountId) {
         dispatch({
           type: "GUEST_PREAUTH_DETECTED",
-          accountId: guestLookup.accountId,
-          sessionId: persisted.sessionId ?? void 0
+          accountId: persisted.accountId,
+          sessionId: persisted.sessionId
         });
-        dispatch({ type: "REQUEST_LOGIN" });
-        dispatch({ type: "MOBILE_SETUP_COMPLETE" });
-      };
-      const pollGuestAccount = async () => {
-        try {
-          if (cancelled) return;
-          const guestLookup = await fetchGuestAccount(apiBaseUrl, guestToken);
-          if (cancelled) return;
-          if (guestLookup != null) {
-            if (persisted.sessionId) {
-              try {
-                const session = await fetchAuthorizationSession(
-                  apiBaseUrl,
-                  persisted.sessionId
-                );
-                if (cancelled) return;
-                if (session.status !== "AUTHORIZED") return;
-              } catch {
-                return;
-              }
-            }
-            await handleAccountFound(guestLookup);
-          }
-        } catch {
-        }
-      };
-      pollGuestAccount();
-      const intervalId = window.setInterval(pollGuestAccount, POLL_INTERVAL_MS);
-      const handlePollVisibility = () => {
-        if (document.visibilityState === "visible" && !cancelled) void pollGuestAccount();
-      };
-      const handlePollPageShow = () => {
-        if (document.visibilityState === "visible" && !cancelled) void pollGuestAccount();
-      };
-      document.addEventListener("visibilitychange", handlePollVisibility);
-      window.addEventListener("pageshow", handlePollPageShow);
-      pollingCleanupRef.current = () => {
-        cancelled = true;
-        window.clearInterval(intervalId);
-        document.removeEventListener("visibilitychange", handlePollVisibility);
-        window.removeEventListener("pageshow", handlePollPageShow);
-        if (!completedRef.current) {
-          guestPreauthRestoreAttemptedKeys.delete(key);
-        }
-        pollingCleanupRef.current = null;
-      };
+      }
+      dispatch({
+        type: "MOBILE_DEEPLINK_READY",
+        deeplinkUri: persisted.deeplinkUri
+      });
+      console.info("[blink-sdk] guestPreauthMobileRestore: starting guest account polling", {
+        trigger,
+        sessionId: persisted.sessionId
+      });
+      startGuestAccountPolling(persisted.guestSessionToken, persisted.sessionId);
     };
-    const onOuterVisibility = () => {
-      if (document.visibilityState === "visible") tryStart();
+    const onVisibility = () => {
+      console.info("[blink-sdk] guestPreauthMobileRestore: visibilitychange fired", {
+        visibilityState: document.visibilityState,
+        startedRef: startedRef.current
+      });
+      if (document.visibilityState === "visible") tryStart("visibilitychange");
     };
-    const onOuterPageShow = () => {
-      if (document.visibilityState === "visible") tryStart();
+    const onPageShow = (e) => {
+      console.info("[blink-sdk] guestPreauthMobileRestore: pageshow fired", {
+        persisted: e.persisted,
+        visibilityState: document.visibilityState,
+        startedRef: startedRef.current
+      });
+      if (document.visibilityState === "visible") tryStart("pageshow");
     };
-    tryStart();
-    document.addEventListener("visibilitychange", onOuterVisibility);
-    window.addEventListener("pageshow", onOuterPageShow);
+    tryStart("initial");
+    document.addEventListener("visibilitychange", onVisibility);
+    window.addEventListener("pageshow", onPageShow);
     return () => {
-      document.removeEventListener("visibilitychange", onOuterVisibility);
-      window.removeEventListener("pageshow", onOuterPageShow);
-      pollingCleanupRef.current?.();
+      document.removeEventListener("visibilitychange", onVisibility);
+      window.removeEventListener("pageshow", onPageShow);
     };
-  }, [privyReady, apiBaseUrl, dispatch, mobileSetupFlowRef, setupAccountIdRef]);
+  }, [privyReady, dispatch, mobileSetupFlowRef, setupAccountIdRef, startGuestAccountPolling]);
 }
 function useSelectSourceEffect(deps) {
   const {
@@ -9286,6 +9264,118 @@ function useGuestPreauthWalletSetupEffect(deps) {
     dispatch
   ]);
 }
+function useGuestAccountPolling(intervalMs = 3e3) {
+  const { apiBaseUrl } = useBlinkConfig();
+  const [guestAccount, setGuestAccount] = react.useState(null);
+  const [isPolling, setIsPolling] = react.useState(false);
+  const intervalRef = react.useRef(null);
+  const guestTokenRef = react.useRef(null);
+  const sessionIdRef = react.useRef(null);
+  const apiBaseUrlRef = react.useRef(apiBaseUrl);
+  apiBaseUrlRef.current = apiBaseUrl;
+  const stopPolling = react.useCallback(() => {
+    console.info("[blink-sdk] useGuestAccountPolling.stopPolling called", {
+      hadInterval: !!intervalRef.current,
+      hadToken: !!guestTokenRef.current
+    });
+    if (intervalRef.current) {
+      clearInterval(intervalRef.current);
+      intervalRef.current = null;
+    }
+    guestTokenRef.current = null;
+    sessionIdRef.current = null;
+    setIsPolling(false);
+  }, []);
+  const poll = react.useCallback(async () => {
+    const token = guestTokenRef.current;
+    const sessionId = sessionIdRef.current;
+    if (!token || !sessionId) {
+      console.info("[blink-sdk] useGuestAccountPolling.poll skipped (no token or sessionId)", {
+        hasToken: !!token,
+        hasSessionId: !!sessionId
+      });
+      return;
+    }
+    console.info("[blink-sdk] useGuestAccountPolling.poll executing", {
+      apiBaseUrl: apiBaseUrlRef.current,
+      tokenPrefix: token.slice(0, 8),
+      sessionId
+    });
+    try {
+      const lookup = await fetchGuestAccount(apiBaseUrlRef.current, token);
+      if (!guestTokenRef.current) return;
+      if (lookup == null) {
+        console.info("[blink-sdk] useGuestAccountPolling.poll: account not found yet");
+        return;
+      }
+      console.info("[blink-sdk] useGuestAccountPolling.poll: account found, checking session");
+      try {
+        const session = await fetchAuthorizationSession(apiBaseUrlRef.current, sessionId);
+        if (!guestTokenRef.current) return;
+        if (session.status !== "AUTHORIZED") {
+          console.info("[blink-sdk] useGuestAccountPolling.poll: session not AUTHORIZED yet", session.status);
+          return;
+        }
+      } catch (err) {
+        console.info("[blink-sdk] useGuestAccountPolling.poll: session fetch failed", err);
+        return;
+      }
+      console.info("[blink-sdk] useGuestAccountPolling.poll: COMPLETE \u2014 account + AUTHORIZED");
+      setGuestAccount(lookup);
+      stopPolling();
+    } catch (err) {
+      console.info("[blink-sdk] useGuestAccountPolling.poll: fetch error, will retry", err);
+    }
+  }, [stopPolling]);
+  const startPolling = react.useCallback(
+    (guestToken, sessionId) => {
+      console.info("[blink-sdk] useGuestAccountPolling.startPolling called", {
+        tokenPrefix: guestToken.slice(0, 8),
+        sessionId,
+        intervalMs
+      });
+      stopPolling();
+      guestTokenRef.current = guestToken;
+      sessionIdRef.current = sessionId;
+      setGuestAccount(null);
+      setIsPolling(true);
+      poll();
+      intervalRef.current = setInterval(poll, intervalMs);
+    },
+    [poll, intervalMs, stopPolling]
+  );
+  react.useEffect(() => {
+    const handleVisibility = () => {
+      console.info("[blink-sdk] useGuestAccountPolling: visibilitychange fired", {
+        visibilityState: document.visibilityState,
+        hasToken: !!guestTokenRef.current,
+        hasSessionId: !!sessionIdRef.current
+      });
+      if (document.visibilityState === "visible" && guestTokenRef.current) {
+        void poll();
+      }
+    };
+    const handlePageShow = (e) => {
+      console.info("[blink-sdk] useGuestAccountPolling: pageshow fired", {
+        persisted: e.persisted,
+        visibilityState: document.visibilityState,
+        hasToken: !!guestTokenRef.current,
+        hasSessionId: !!sessionIdRef.current
+      });
+      if (document.visibilityState === "visible" && guestTokenRef.current) {
+        void poll();
+      }
+    };
+    document.addEventListener("visibilitychange", handleVisibility);
+    window.addEventListener("pageshow", handlePageShow);
+    return () => {
+      document.removeEventListener("visibilitychange", handleVisibility);
+      window.removeEventListener("pageshow", handlePageShow);
+    };
+  }, [poll]);
+  react.useEffect(() => () => stopPolling(), [stopPolling]);
+  return { guestAccount, isPolling, startPolling, stopPolling };
+}
 function BlinkPayment(props) {
   const resetKey = react.useRef(0);
   const handleBoundaryReset = react.useCallback(() => {
@@ -9322,6 +9412,7 @@ function BlinkPaymentInner({
   );
   const authExecutor = useAuthorizationExecutor();
   const polling = useTransferPolling();
+  const guestAccountPolling = useGuestAccountPolling();
   const transferSigning = useTransferSigning();
   const mobileFlowRefs = {
     mobileSetupFlowRef: react.useRef(false),
@@ -9366,6 +9457,12 @@ function BlinkPaymentInner({
     transfer.pollingTransferIdRef,
     state.transfer,
     mobileFlowRefs,
+    {
+      mobileFlow: state.mobileFlow,
+      isGuestFlow: state.isGuestFlow,
+      guestTransferId: state.guestTransferId,
+      guestSessionToken: state.guestSessionToken
+    },
     onComplete
   );
   const sourceSelection = useSourceSelectionHandlers(dispatch, authExecutor, {
@@ -9401,7 +9498,8 @@ function BlinkPaymentInner({
     destination,
     guestSessionToken: state.guestSessionToken,
     guestTransferId: state.guestTransferId,
-    selectedProviderId: state.selectedProviderId
+    selectedProviderId: state.selectedProviderId,
+    startGuestAccountPolling: guestAccountPolling.startPolling
   });
   const guestPostPayPreauth = react.useMemo(
     () => !!state.guestPreauthSessionId && state.isGuestFlow || state.guestPreauthorizing && isDesktop,
@@ -9464,11 +9562,40 @@ function BlinkPaymentInner({
   usePrivySessionSyncEffect({ dispatch, ready, authenticated });
   useGuestPreauthMobileRestoreEffect({
     dispatch,
-    apiBaseUrl,
     privyReady: state.privyReady,
     mobileSetupFlowRef: mobileFlowRefs.mobileSetupFlowRef,
-    setupAccountIdRef: mobileFlowRefs.setupAccountIdRef
+    setupAccountIdRef: mobileFlowRefs.setupAccountIdRef,
+    startGuestAccountPolling: guestAccountPolling.startPolling
   });
+  react.useEffect(() => {
+    console.info("[blink-sdk] guestPreauthCompletion effect", {
+      hasGuestAccount: !!guestAccountPolling.guestAccount,
+      guestAccountId: guestAccountPolling.guestAccount?.accountId ?? null,
+      currentPreauthAccountId: state.guestPreauthAccountId,
+      currentPhase: state.phase.step,
+      mobileFlow: state.mobileFlow,
+      loginRequested: state.loginRequested
+    });
+    if (!guestAccountPolling.guestAccount) return;
+    const acct = guestAccountPolling.guestAccount;
+    const needsDetect = acct.accountId !== state.guestPreauthAccountId;
+    console.info("[blink-sdk] guestPreauthCompletion: dispatching REQUEST_LOGIN + MOBILE_SETUP_COMPLETE", {
+      accountId: acct.accountId,
+      dispatchingGuestPreauthDetected: needsDetect
+    });
+    if (needsDetect) {
+      dispatch({
+        type: "GUEST_PREAUTH_DETECTED",
+        accountId: acct.accountId,
+        sessionId: state.guestPreauthSessionId ?? void 0
+      });
+    }
+    mobileFlowRefs.mobileSetupFlowRef.current = false;
+    mobileFlowRefs.setupAccountIdRef.current = null;
+    clearMobileFlowState();
+    dispatch({ type: "REQUEST_LOGIN" });
+    dispatch({ type: "MOBILE_SETUP_COMPLETE" });
+  }, [guestAccountPolling.guestAccount]);
   useOtpEffects({
     state,
     dispatch,
@@ -9498,7 +9625,8 @@ function BlinkPaymentInner({
     reauthTokenRef: mobileFlowRefs.reauthTokenRef,
     pollingTransferIdRef: transfer.pollingTransferIdRef,
     handleAuthorizedMobileReturn: mobileFlow.handleAuthorizedMobileReturn,
-    onComplete
+    onComplete,
+    startGuestAccountPolling: guestAccountPolling.startPolling
   });
   useDataLoadEffect({
     state,