Move post-unlock navigation from SessionLockListener to UnlockAccount

The SessionLockListener was navigating to /account on SESSION_UNLOCKED
from the /unlock-account route. Because runtime.sendMessage broadcasts
to every extension context — including the popup that initiated the
unlock via confirmPassword — this navigation raced the UnlockAccount
post-submit navigation. In the grant-access flow that meant the popup
sometimes landed on /account instead of the /grant-access destination
preserved via state.from, which broke the
freighterApiIntegration.test.ts "should get public key when logged
out" e2e test.

Move navigation responsibility to UnlockAccount itself: it watches
hasPrivateKey in redux and navigates to from || /account on the
false → true transition. This unifies both surfaces — the one that
submitted the password and the passive surface that received the
cross-surface SESSION_UNLOCKED broadcast — through a single code path
and removes the race.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Copilot

extension/src/popup/components/SessionLockListener/index.tsx

@@ -72,15 +72,20 @@ export const SessionLockListener = () => {
         return undefined;
       }
 
+      // SESSION_UNLOCKED. Refresh this surface's auth state so passive
+      // surfaces (e.g. sidebar parked on /unlock-account) reflect the
+      // unlocked wallet. We deliberately do NOT navigate here:
+      // `runtime.sendMessage` is broadcast by the background to every
+      // extension context including the popup that *initiated* the
+      // unlock via `confirmPassword`, so navigating from this listener
+      // would race the unlock view's own post-submit navigation (and
+      // in the grant-access flow would land the user on /account
+      // instead of /grant-access). The unlock screens watch
+      // `hasPrivateKey` and navigate themselves once auth state
+      // flips, which covers both the active and passive surfaces.
       void (async () => {
         const account = await loadAccount();
         dispatch(saveAccount(account));
-        if (
-          location.pathname === ROUTES.unlockAccount ||
-          location.pathname === ROUTES.verifyAccount
-        ) {
-          navigate(ROUTES.account, { replace: true });
-        }
       })();
       return undefined;
     };

extension/src/popup/components/__tests__/SessionLockListener.test.tsx

@@ -168,20 +168,12 @@ describe("SessionLockListener", () => {
     expect(auth.allAccounts).toEqual([{ publicKey: "GBUPDATED" }]);
   });
 
-  it("navigates to account from unlockAccount on SESSION_UNLOCKED", async () => {
+  it("does not navigate from any route on SESSION_UNLOCKED (unlock views navigate themselves via redux state)", async () => {
     renderListener(ROUTES.unlockAccount);
 
     await emitMessage({ type: SERVICE_TYPES.SESSION_UNLOCKED });
 
-    expect(lastLocation?.pathname).toBe(ROUTES.account);
-  });
-
-  it("navigates to account from verifyAccount on SESSION_UNLOCKED", async () => {
-    renderListener(ROUTES.verifyAccount);
-
-    await emitMessage({ type: SERVICE_TYPES.SESSION_UNLOCKED });
-
-    expect(lastLocation?.pathname).toBe(ROUTES.account);
+    expect(lastLocation?.pathname).toBe(ROUTES.unlockAccount);
   });
 
   it("does not navigate from a non-lock route on SESSION_UNLOCKED", async () => {

extension/src/popup/views/UnlockAccount/index.tsx

@@ -1,8 +1,8 @@
 import { Button } from "@stellar/design-system";
 import get from "lodash/get";
-import React, { useEffect, useState } from "react";
+import React, { useEffect, useRef, useState } from "react";
 import { useTranslation } from "react-i18next";
-import { useDispatch } from "react-redux";
+import { useDispatch, useSelector } from "react-redux";
 import { useLocation, useNavigate } from "react-router-dom";
 
 import { newTabHref } from "helpers/urls";
@@ -12,6 +12,7 @@ import { openTab } from "popup/helpers/navigate";
 import { View } from "popup/basics/layout/View";
 import {
   confirmPassword,
+  hasPrivateKeySelector,
   loadLastUsedAccount,
 } from "popup/ducks/accountServices";
 import { EnterPassword } from "popup/components/EnterPassword";
@@ -30,14 +31,27 @@ export const UnlockAccount = () => {
   const [accountAddress, setAccountAddress] = useState("");
 
   const dispatch = useDispatch<AppDispatch>();
+  const hasPrivateKey = useSelector(hasPrivateKeySelector);
+  // Track the initial auth state so we don't auto-navigate if the
+  // component happens to mount while the wallet is already unlocked
+  // (e.g. a stale `/unlock-account` route). We only redirect on the
+  // false → true transition that signals an unlock just happened
+  // (either via this surface's password submit or via a cross-surface
+  // SESSION_UNLOCKED broadcast saving fresh auth state).
+  const wasLockedOnMount = useRef(!hasPrivateKey);
 
   const handleSubmit = async (password: string) => {
-    const res = await dispatch(confirmPassword(password));
-    if (confirmPassword.fulfilled.match(res) && res.payload.publicKey) {
-      // skip this location in history, we won't need to come back here after unlocking account
+    await dispatch(confirmPassword(password));
+    // Navigation is handled by the `hasPrivateKey` effect below so
+    // that both password-submit and cross-surface SESSION_UNLOCKED
+    // broadcasts converge on the same destination.
+  };
+
+  useEffect(() => {
+    if (wasLockedOnMount.current && hasPrivateKey) {
       navigate(`${destination}${queryParams}`, { replace: true });
     }
-  };
+  }, [hasPrivateKey, destination, queryParams, navigate]);
 
   useEffect(() => {
     const fetchLastUsedAccount = async () => {