Notifications n plus one

__tests__/components/auth/SeizeConnectContext.addAccount.test.tsx

@@ -57,6 +57,13 @@ jest.mock("@/hooks/useConnectedAccountsUnreadNotifications", () => ({
   useConnectedAccountsUnreadNotifications: () => ({}),
 }));
 
+jest.mock("@/hooks/useUnreadNotifications", () => ({
+  useUnreadNotifications: () => ({
+    notifications: { unread_count: 0 },
+    haveUnreadNotifications: false,
+  }),
+}));
+
 jest.mock("@/services/auth/auth.utils", () => ({
   WALLET_ACCOUNTS_UPDATED_EVENT: "6529-wallet-accounts-updated",
   canStoreAnotherWalletAccount: jest.fn(() => true),

__tests__/components/auth/SeizeConnectContext.switch-sync.test.tsx

@@ -35,6 +35,13 @@ jest.mock("@/hooks/useConnectedAccountsUnreadNotifications", () => ({
   useConnectedAccountsUnreadNotifications: jest.fn(() => ({})),
 }));
 
+jest.mock("@/hooks/useUnreadNotifications", () => ({
+  useUnreadNotifications: jest.fn(() => ({
+    notifications: { unread_count: 0 },
+    haveUnreadNotifications: false,
+  })),
+}));
+
 jest.mock("@/services/auth/auth.utils", () => ({
   canStoreAnotherWalletAccount: jest.fn(() => true),
   getConnectedWalletAccounts: jest.fn(() => []),
@@ -54,20 +61,40 @@ const AddressProbe: React.FC = () => {
   return <div data-testid="active-address">{address ?? "undefined"}</div>;
 };
 
+const UnreadProbe: React.FC = () => {
+  const { connectedAccountUnreadNotifications } = useSeizeConnectContext();
+  return (
+    <div data-testid="unread-map">
+      {JSON.stringify(connectedAccountUnreadNotifications)}
+    </div>
+  );
+};
+
 const buildStoredAccount = (
-  address: string
+  address: string,
+  profileHandle: string | null = null,
+  jwt: string | null = null
 ): authUtils.ConnectedWalletAccount => ({
   address,
   refreshToken: "dummy-refresh-token",
   role: null,
-  jwt: null,
+  jwt,
   profileId: null,
-  profileHandle: null,
+  profileHandle,
 });
 
 describe("SeizeConnectContext switch sync guard", () => {
   beforeEach(() => {
     jest.clearAllMocks();
+    require("@/hooks/useConnectedAccountsUnreadNotifications").useConnectedAccountsUnreadNotifications.mockReturnValue(
+      {}
+    );
+    require("@/hooks/useUnreadNotifications").useUnreadNotifications.mockReturnValue(
+      {
+        notifications: { unread_count: 0 },
+        haveUnreadNotifications: false,
+      }
+    );
   });
 
   it("prefers stored active account while provider still reports previous known account", async () => {
@@ -185,4 +212,126 @@ describe("SeizeConnectContext switch sync guard", () => {
       expect(screen.getByTestId("active-address")).toHaveTextContent(addressA);
     });
   });
+
+  it("polls inactive accounts only and merges the active unread count", async () => {
+    const { useAppKitAccount } = require("@reown/appkit/react");
+    const mockGetWalletAddress =
+      authUtils.getWalletAddress as jest.MockedFunction<
+        typeof authUtils.getWalletAddress
+      >;
+    const mockGetConnectedWalletAccounts =
+      authUtils.getConnectedWalletAccounts as jest.MockedFunction<
+        typeof authUtils.getConnectedWalletAccounts
+      >;
+    const mockUseConnectedAccountsUnreadNotifications =
+      require("@/hooks/useConnectedAccountsUnreadNotifications")
+        .useConnectedAccountsUnreadNotifications as jest.Mock;
+    const mockUseUnreadNotifications = require("@/hooks/useUnreadNotifications")
+      .useUnreadNotifications as jest.Mock;
+
+    const activeAccount = buildStoredAccount(addressA, "alice");
+    const inactiveAccount = buildStoredAccount(addressB, "bob");
+
+    (useAppKitAccount as jest.Mock).mockReturnValue({
+      address: addressA,
+      isConnected: true,
+      status: "connected",
+    });
+    mockGetWalletAddress.mockReturnValue(addressA);
+    mockGetConnectedWalletAccounts.mockReturnValue([
+      activeAccount,
+      inactiveAccount,
+    ]);
+    mockUseConnectedAccountsUnreadNotifications.mockReturnValue({
+      [addressB]: 4,
+    });
+    mockUseUnreadNotifications.mockReturnValue({
+      notifications: { unread_count: 7 },
+      haveUnreadNotifications: true,
+    });
+
+    render(
+      <SeizeConnectProvider>
+        <UnreadProbe />
+      </SeizeConnectProvider>
+    );
+
+    await waitFor(() => {
+      expect(mockUseConnectedAccountsUnreadNotifications).toHaveBeenCalledWith([
+        inactiveAccount,
+      ]);
+      expect(mockUseUnreadNotifications).toHaveBeenCalledWith("alice");
+    });
+
+    const unreadMap = JSON.parse(
+      screen.getByTestId("unread-map").textContent ?? "{}"
+    );
+
+    expect(unreadMap).toEqual({
+      [addressA]: 7,
+      [addressB]: 4,
+    });
+  });
+
+  it("keeps the active JWT unread count when the active account has no profile handle", async () => {
+    const { useAppKitAccount } = require("@reown/appkit/react");
+    const mockGetWalletAddress =
+      authUtils.getWalletAddress as jest.MockedFunction<
+        typeof authUtils.getWalletAddress
+      >;
+    const mockGetConnectedWalletAccounts =
+      authUtils.getConnectedWalletAccounts as jest.MockedFunction<
+        typeof authUtils.getConnectedWalletAccounts
+      >;
+    const mockUseConnectedAccountsUnreadNotifications =
+      require("@/hooks/useConnectedAccountsUnreadNotifications")
+        .useConnectedAccountsUnreadNotifications as jest.Mock;
+    const mockUseUnreadNotifications = require("@/hooks/useUnreadNotifications")
+      .useUnreadNotifications as jest.Mock;
+
+    const activeAccount = buildStoredAccount(addressA, null, "active-jwt");
+    const inactiveAccount = buildStoredAccount(addressB, "bob", "inactive-jwt");
+
+    (useAppKitAccount as jest.Mock).mockReturnValue({
+      address: addressA,
+      isConnected: true,
+      status: "connected",
+    });
+    mockGetWalletAddress.mockReturnValue(addressA);
+    mockGetConnectedWalletAccounts.mockReturnValue([
+      activeAccount,
+      inactiveAccount,
+    ]);
+    mockUseConnectedAccountsUnreadNotifications.mockReturnValue({
+      [addressA]: 9,
+      [addressB]: 4,
+    });
+    mockUseUnreadNotifications.mockReturnValue({
+      notifications: { unread_count: 0 },
+      haveUnreadNotifications: false,
+    });
+
+    render(
+      <SeizeConnectProvider>
+        <UnreadProbe />
+      </SeizeConnectProvider>
+    );
+
+    await waitFor(() => {
+      expect(mockUseConnectedAccountsUnreadNotifications).toHaveBeenCalledWith([
+        activeAccount,
+        inactiveAccount,
+      ]);
+      expect(mockUseUnreadNotifications).toHaveBeenCalledWith(null);
+    });
+
+    const unreadMap = JSON.parse(
+      screen.getByTestId("unread-map").textContent ?? "{}"
+    );
+
+    expect(unreadMap).toEqual({
+      [addressA]: 9,
+      [addressB]: 4,
+    });
+  });
 });

__tests__/components/auth/SeizeConnectContext.test.tsx

@@ -43,6 +43,17 @@ jest.mock("viem", () => ({
   getAddress: jest.fn((address: string) => address.toLowerCase()),
 }));
 
+jest.mock("@/hooks/useConnectedAccountsUnreadNotifications", () => ({
+  useConnectedAccountsUnreadNotifications: jest.fn(() => ({})),
+}));
+
+jest.mock("@/hooks/useUnreadNotifications", () => ({
+  useUnreadNotifications: jest.fn(() => ({
+    notifications: { unread_count: 0 },
+    haveUnreadNotifications: false,
+  })),
+}));
+
 // Mock auth utils
 jest.mock("@/services/auth/auth.utils", () => ({
   canStoreAnotherWalletAccount: jest.fn(() => true),

__tests__/components/brain/my-stream/MyStreamWaveChat.test.tsx

@@ -21,6 +21,16 @@ const invalidateNotificationsMock = jest.fn();
 const mockUseAuth = jest.fn();
 const mockApprovalStatus = jest.fn();
 
+let documentVisibilityState: DocumentVisibilityState = "visible";
+
+const setDocumentVisibilityState = (state: DocumentVisibilityState) => {
+  documentVisibilityState = state;
+  Object.defineProperty(document, "visibilityState", {
+    configurable: true,
+    get: () => documentVisibilityState,
+  });
+};
+
 jest.mock("next/navigation", () => ({
   useRouter: () => ({ replace: replaceMock }),
   useSearchParams: () => searchParamsMock,
@@ -115,29 +125,41 @@ jest.mock("@/components/auth/Auth", () => ({
   useAuth: () => mockUseAuth(),
 }));
 
+jest.mock("@/components/auth/SeizeConnectContext", () => ({
+  useSeizeConnectContext: () => ({ address: "0xAAA" }),
+}));
+
 jest.mock("@/services/api/common-api", () => ({
   commonApiPostWithoutBodyAndResponse: jest.fn().mockResolvedValue(undefined),
 }));
 
+jest.mock("@/services/auth/auth.utils", () => ({
+  getAuthJwt: () => "test-jwt",
+}));
+
+jest.mock("jwt-decode", () => ({
+  jwtDecode: (token: string) => {
+    if (token !== "test-jwt") {
+      throw new Error(`Unexpected JWT decode for ${token}`);
+    }
+
+    return { sub: "0xAAA", role: null, exp: 4102444800 };
+  },
+}));
+
 const wave = {
   id: "10",
   participation: {},
   metrics: { muted: false, your_unread_drops_count: 0 },
   wave: { type: ApiWaveType.Rank, winning_threshold: null },
 } as any;
 const mockOnDropClick = jest.fn();
-const setDocumentVisibility = (visibilityState: DocumentVisibilityState) => {
-  Object.defineProperty(document, "visibilityState", {
-    configurable: true,
-    value: visibilityState,
-  });
-};
 
 describe("MyStreamWaveChat", () => {
   let store: any;
 
   beforeEach(() => {
-    setDocumentVisibility("visible");
+    setDocumentVisibilityState("visible");
     capturedPropsHolder.current = {};
     capturedCreatorPropsHolder.current = {};
     capturedMemesButtonPropsHolder.current = {};
@@ -160,6 +182,7 @@ describe("MyStreamWaveChat", () => {
     });
     mockUseAuth.mockReturnValue({
       connectedProfile: { handle: "tester" },
+      activeProfileProxy: null,
     });
     (
       commonApiPostWithoutBodyAndResponse as jest.MockedFunction<
@@ -319,13 +342,16 @@ describe("MyStreamWaveChat", () => {
       expect(mockRemoveWaveDeliveredNotifications).toHaveBeenCalledWith("10");
       expect(commonApiPostWithoutBodyAndResponse).toHaveBeenCalledWith({
         endpoint: "notifications/wave/10/read",
+        headers: { Authorization: "Bearer test-jwt" },
       });
       expect(invalidateNotificationsMock).toHaveBeenCalled();
     });
   });
 
-  it("does not call the read endpoint on unmount when the tab is hidden", async () => {
-    setDocumentVisibility("hidden");
+  it("does not mark notifications read on hidden unmount", async () => {
+    setDocumentVisibilityState("hidden");
+    searchParamsMock.get.mockReturnValueOnce("5").mockReturnValue(null);
+    searchParamsMock.toString.mockReturnValue("serialNo=5");
 
     const { unmount } = renderWithProvider(
       <MyStreamWaveChat
@@ -338,16 +364,19 @@ describe("MyStreamWaveChat", () => {
 
     await act(async () => {
       unmount();
+      await Promise.resolve();
     });
 
+    expect(mockSetUnreadDividerSerialNo).toHaveBeenCalledWith(null);
+    expect(mockRemoveWaveDeliveredNotifications).not.toHaveBeenCalled();
     expect(commonApiPostWithoutBodyAndResponse).not.toHaveBeenCalled();
     expect(invalidateNotificationsMock).not.toHaveBeenCalled();
-    expect(mockRemoveWaveDeliveredNotifications).not.toHaveBeenCalled();
   });
 
   it("skips notification cleanup on unmount for anonymous viewers", async () => {
     mockUseAuth.mockReturnValue({
       connectedProfile: null,
+      activeProfileProxy: null,
     });
 
     const { unmount } = renderWithProvider(