diff --git a/frontend/src/App.jsx b/frontend/src/App.jsx
index dce5ff80..82c2015b 100644
--- a/frontend/src/App.jsx
+++ b/frontend/src/App.jsx
@@ -43,7 +43,7 @@ function App() {
   const { healthy, error: healthError, checking: healthChecking, retry: retryHealth } = useContractHealth();
 
   const userAddress = getMainnetAddress(userData);
-  const { notifications, unreadCount, markAllRead, loading: notificationsLoading } = useNotifications(userAddress);
+  const { notifications, unreadCount, lastSeenTimestamp, markAllRead, loading: notificationsLoading } = useNotifications(userAddress);
   const { isOwner } = useAdmin(userAddress);
 
   usePageTitle();
@@ -137,6 +137,7 @@ function App() {
         authLoading={authLoading}
         notifications={notifications}
         unreadCount={unreadCount}
+        lastSeenTimestamp={lastSeenTimestamp}
         onMarkNotificationsRead={markAllRead}
         notificationsLoading={notificationsLoading}
         apiReachable={healthy}
diff --git a/frontend/src/components/Header.jsx b/frontend/src/components/Header.jsx
index 04e78857..f7456988 100644
--- a/frontend/src/components/Header.jsx
+++ b/frontend/src/components/Header.jsx
@@ -24,7 +24,7 @@ import { Sun, Moon } from 'lucide-react';
  * @param {Function} props.onMarkNotificationsRead - Callback to mark all read.
  * @param {boolean} props.notificationsLoading - Whether notifications are loading.
  */
-export default function Header({ userData, onAuth, authLoading, notifications, unreadCount, onMarkNotificationsRead, notificationsLoading, apiReachable = null }) {
+export default function Header({ userData, onAuth, authLoading, notifications, unreadCount, lastSeenTimestamp, onMarkNotificationsRead, notificationsLoading, apiReachable = null }) {
     const { theme, toggleTheme } = useTheme();
     const isOnline = useOnlineStatus();
 
@@ -85,6 +85,7 @@ export default function Header({ userData, onAuth, authLoading, notifications, u
                                 unreadCount={unreadCount}
                                 onMarkRead={onMarkNotificationsRead}
                                 loading={notificationsLoading}
+                                lastSeenTimestamp={lastSeenTimestamp}
                             />
                         )}
 
diff --git a/frontend/src/components/NotificationBell.jsx b/frontend/src/components/NotificationBell.jsx
index fde165a0..9259d055 100644
--- a/frontend/src/components/NotificationBell.jsx
+++ b/frontend/src/components/NotificationBell.jsx
@@ -2,7 +2,7 @@ import { useState, useRef, useEffect } from 'react';
 import { formatSTX, formatAddress } from '../lib/utils';
 import { Bell } from 'lucide-react';
 
-export default function NotificationBell({ notifications, unreadCount, onMarkRead, loading }) {
+export default function NotificationBell({ notifications, unreadCount, onMarkRead, loading, lastSeenTimestamp }) {
     const [open, setOpen] = useState(false);
     const dropdownRef = useRef(null);
 
@@ -25,6 +25,11 @@ export default function NotificationBell({ notifications, unreadCount, onMarkRea
 
     const truncateAddr = (addr) => formatAddress(addr, 6, 4);
 
+    const isUnread = (tip) => {
+        if (lastSeenTimestamp == null) return false;
+        return tip.timestamp > lastSeenTimestamp;
+    };
+
     return (
         <div className="relative" ref={dropdownRef}>
             <button
@@ -75,7 +80,7 @@ export default function NotificationBell({ notifications, unreadCount, onMarkRea
                             notifications.slice(0, 20).map((tip, i) => (
                                 <div
                                     key={tip.txId || i}
-                                    className="px-4 py-3 hover:bg-gray-50 dark:hover:bg-gray-800/50 transition-colors border-b border-gray-50 dark:border-gray-800/50 last:border-0"
+                                    className={`px-4 py-3 hover:bg-gray-50 dark:hover:bg-gray-800/50 transition-colors border-b border-gray-50 dark:border-gray-800/50 last:border-0${isUnread(tip) ? ' bg-blue-50 dark:bg-blue-900/20' : ''}`}
                                 >
                                     <div className="flex items-start justify-between gap-2">
                                         <div className="flex-1 min-w-0">
@@ -94,7 +99,9 @@ export default function NotificationBell({ notifications, unreadCount, onMarkRea
                                                 </p>
                                             )}
                                         </div>
-                                        <div className="w-2 h-2 rounded-full bg-green-400 flex-shrink-0 mt-1.5" />
+                                        {isUnread(tip) && (
+                                            <div className="w-2 h-2 rounded-full bg-green-400 flex-shrink-0 mt-1.5" />
+                                        )}
                                     </div>
                                 </div>
                             ))
diff --git a/frontend/src/hooks/useNotifications.js b/frontend/src/hooks/useNotifications.js
index 961e054b..351cad6a 100644
--- a/frontend/src/hooks/useNotifications.js
+++ b/frontend/src/hooks/useNotifications.js
@@ -12,9 +12,9 @@ const STORAGE_KEY = 'tipstream_last_seen_tip_ts';
 export function useNotifications(userAddress) {
     const { events, eventsLoading } = useTipContext();
     const [unreadCount, setUnreadCount] = useState(0);
-    const lastSeenRef = useRef(
-        parseInt(localStorage.getItem(STORAGE_KEY) || '0', 10)
-    );
+    const initialLastSeen = parseInt(localStorage.getItem(STORAGE_KEY) || '0', 10);
+    const lastSeenRef = useRef(initialLastSeen);
+    const [lastSeenTimestamp, setLastSeenTimestamp] = useState(initialLastSeen);
 
     /** Derive received tips from the shared event cache. */
     const notifications = useMemo(() => {
@@ -41,9 +41,10 @@ export function useNotifications(userAddress) {
     const markAllRead = useCallback(() => {
         const now = Math.floor(Date.now() / 1000);
         lastSeenRef.current = now;
+        setLastSeenTimestamp(now);
         localStorage.setItem(STORAGE_KEY, String(now));
         setUnreadCount(0);
     }, []);
 
-    return { notifications, unreadCount, loading: eventsLoading, markAllRead, refetch: () => {} };
+    return { notifications, unreadCount, lastSeenTimestamp, loading: eventsLoading, markAllRead, refetch: () => {} };
 }
diff --git a/frontend/src/test/NotificationBell.test.jsx b/frontend/src/test/NotificationBell.test.jsx
new file mode 100644
index 00000000..16fb2abc
--- /dev/null
+++ b/frontend/src/test/NotificationBell.test.jsx
@@ -0,0 +1,364 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { render, screen, cleanup, fireEvent } from '@testing-library/react';
+import NotificationBell from '../components/NotificationBell';
+
+afterEach(() => {
+    cleanup();
+    vi.restoreAllMocks();
+});
+
+function makeNotification(overrides = {}) {
+    return {
+        txId: '0x' + Math.random().toString(16).slice(2, 18),
+        event: 'tip-sent',
+        sender: 'SP31PKQVQZVZCK3FM3NH67CGD6G1FMR17VQVS2W5T',
+        recipient: 'SP1HTBVD3JG9C05J7HBJTHGR0GGW7KXW28M5JS8QE',
+        amount: '1000000',
+        timestamp: Math.floor(Date.now() / 1000),
+        ...overrides,
+    };
+}
+
+const defaultProps = {
+    notifications: [],
+    unreadCount: 0,
+    onMarkRead: vi.fn(),
+    loading: false,
+    lastSeenTimestamp: 0,
+};
+
+describe('NotificationBell', () => {
+    describe('rendering', () => {
+        it('renders the bell icon button', () => {
+            render(<NotificationBell {...defaultProps} />);
+            expect(screen.getByRole('button', { name: /notifications/i })).toBeInTheDocument();
+        });
+
+        it('shows unread badge when unreadCount > 0', () => {
+            render(<NotificationBell {...defaultProps} unreadCount={3} />);
+            expect(screen.getByText('3')).toBeInTheDocument();
+        });
+
+        it('shows 9+ when unreadCount exceeds 9', () => {
+            render(<NotificationBell {...defaultProps} unreadCount={15} />);
+            expect(screen.getByText('9+')).toBeInTheDocument();
+        });
+
+        it('hides badge when unreadCount is 0', () => {
+            render(<NotificationBell {...defaultProps} unreadCount={0} />);
+            expect(screen.queryByText('0')).not.toBeInTheDocument();
+        });
+
+        it('shows exact number when unreadCount is 9', () => {
+            render(<NotificationBell {...defaultProps} unreadCount={9} />);
+            expect(screen.getByText('9')).toBeInTheDocument();
+            expect(screen.queryByText('9+')).not.toBeInTheDocument();
+        });
+
+        it('shows 9+ when unreadCount is exactly 10', () => {
+            render(<NotificationBell {...defaultProps} unreadCount={10} />);
+            expect(screen.getByText('9+')).toBeInTheDocument();
+        });
+    });
+
+    describe('dropdown toggle', () => {
+        it('opens dropdown on click', () => {
+            render(<NotificationBell {...defaultProps} />);
+            fireEvent.click(screen.getByRole('button', { name: /notifications/i }));
+            expect(screen.getByRole('region', { name: /notifications/i })).toBeInTheDocument();
+        });
+
+        it('closes dropdown on second click', () => {
+            render(<NotificationBell {...defaultProps} />);
+            const btn = screen.getByRole('button', { name: /notifications/i });
+            fireEvent.click(btn);
+            fireEvent.click(btn);
+            expect(screen.queryByRole('region', { name: /notifications/i })).not.toBeInTheDocument();
+        });
+
+        it('calls onMarkRead when opening with unread items', () => {
+            const onMarkRead = vi.fn();
+            render(<NotificationBell {...defaultProps} unreadCount={2} onMarkRead={onMarkRead} />);
+            fireEvent.click(screen.getByRole('button', { name: /notifications/i }));
+            expect(onMarkRead).toHaveBeenCalledTimes(1);
+        });
+
+        it('does not call onMarkRead when there are no unread items', () => {
+            const onMarkRead = vi.fn();
+            render(<NotificationBell {...defaultProps} unreadCount={0} onMarkRead={onMarkRead} />);
+            fireEvent.click(screen.getByRole('button', { name: /notifications/i }));
+            expect(onMarkRead).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('read/unread visual distinction', () => {
+        it('shows green dot for unread notifications', () => {
+            const now = Math.floor(Date.now() / 1000);
+            const notifications = [makeNotification({ timestamp: now + 10 })];
+            const { container } = render(
+                <NotificationBell
+                    {...defaultProps}
+                    notifications={notifications}
+                    lastSeenTimestamp={now}
+                />
+            );
+            fireEvent.click(screen.getByRole('button', { name: /notifications/i }));
+            const dot = container.querySelector('.bg-green-400');
+            expect(dot).toBeInTheDocument();
+        });
+
+        it('hides green dot for read notifications', () => {
+            const now = Math.floor(Date.now() / 1000);
+            const notifications = [makeNotification({ timestamp: now - 100 })];
+            const { container } = render(
+                <NotificationBell
+                    {...defaultProps}
+                    notifications={notifications}
+                    lastSeenTimestamp={now}
+                />
+            );
+            fireEvent.click(screen.getByRole('button', { name: /notifications/i }));
+            const dots = container.querySelectorAll('.bg-green-400');
+            expect(dots.length).toBe(0);
+        });
+
+        it('shows background highlight for unread items', () => {
+            const now = Math.floor(Date.now() / 1000);
+            const notifications = [makeNotification({ timestamp: now + 10 })];
+            const { container } = render(
+                <NotificationBell
+                    {...defaultProps}
+                    notifications={notifications}
+                    lastSeenTimestamp={now}
+                />
+            );
+            fireEvent.click(screen.getByRole('button', { name: /notifications/i }));
+            const highlighted = container.querySelector('[class*="bg-blue-50"]');
+            expect(highlighted).toBeInTheDocument();
+        });
+
+        it('does not show background highlight for read items', () => {
+            const now = Math.floor(Date.now() / 1000);
+            const notifications = [makeNotification({ timestamp: now - 100 })];
+            const { container } = render(
+                <NotificationBell
+                    {...defaultProps}
+                    notifications={notifications}
+                    lastSeenTimestamp={now}
+                />
+            );
+            fireEvent.click(screen.getByRole('button', { name: /notifications/i }));
+            const highlighted = container.querySelector('[class*="bg-blue-50"]');
+            expect(highlighted).not.toBeInTheDocument();
+        });
+
+        it('shows mixed read and unread items correctly', () => {
+            const now = Math.floor(Date.now() / 1000);
+            const notifications = [
+                makeNotification({ txId: '0xnew1', timestamp: now + 10 }),
+                makeNotification({ txId: '0xold1', timestamp: now - 100 }),
+            ];
+            const { container } = render(
+                <NotificationBell
+                    {...defaultProps}
+                    notifications={notifications}
+                    lastSeenTimestamp={now}
+                />
+            );
+            fireEvent.click(screen.getByRole('button', { name: /notifications/i }));
+            const dots = container.querySelectorAll('.bg-green-400');
+            expect(dots.length).toBe(1);
+        });
+
+        it('treats all items as read when lastSeenTimestamp is null', () => {
+            const now = Math.floor(Date.now() / 1000);
+            const notifications = [makeNotification({ timestamp: now + 10 })];
+            const { container } = render(
+                <NotificationBell
+                    {...defaultProps}
+                    notifications={notifications}
+                    lastSeenTimestamp={null}
+                />
+            );
+            fireEvent.click(screen.getByRole('button', { name: /notifications/i }));
+            const dots = container.querySelectorAll('.bg-green-400');
+            expect(dots.length).toBe(0);
+        });
+
+        it('shows all items as unread when lastSeenTimestamp is 0', () => {
+            const now = Math.floor(Date.now() / 1000);
+            const notifications = [
+                makeNotification({ txId: '0xa', timestamp: now }),
+                makeNotification({ txId: '0xb', timestamp: now - 60 }),
+            ];
+            const { container } = render(
+                <NotificationBell
+                    {...defaultProps}
+                    notifications={notifications}
+                    lastSeenTimestamp={0}
+                />
+            );
+            fireEvent.click(screen.getByRole('button', { name: /notifications/i }));
+            const dots = container.querySelectorAll('.bg-green-400');
+            expect(dots.length).toBe(2);
+        });
+    });
+
+    describe('timestamp boundary', () => {
+        it('treats notification at exact lastSeenTimestamp as read', () => {
+            const ts = Math.floor(Date.now() / 1000);
+            const notifications = [makeNotification({ timestamp: ts })];
+            const { container } = render(
+                <NotificationBell
+                    {...defaultProps}
+                    notifications={notifications}
+                    lastSeenTimestamp={ts}
+                />
+            );
+            fireEvent.click(screen.getByRole('button', { name: /notifications/i }));
+            const dots = container.querySelectorAll('.bg-green-400');
+            expect(dots.length).toBe(0);
+        });
+
+        it('treats notification one second after lastSeen as unread', () => {
+            const ts = Math.floor(Date.now() / 1000);
+            const notifications = [makeNotification({ timestamp: ts + 1 })];
+            const { container } = render(
+                <NotificationBell
+                    {...defaultProps}
+                    notifications={notifications}
+                    lastSeenTimestamp={ts}
+                />
+            );
+            fireEvent.click(screen.getByRole('button', { name: /notifications/i }));
+            const dots = container.querySelectorAll('.bg-green-400');
+            expect(dots.length).toBe(1);
+        });
+    });
+
+    describe('empty states', () => {
+        it('shows loading text when loading with no notifications', () => {
+            render(<NotificationBell {...defaultProps} loading={true} />);
+            fireEvent.click(screen.getByRole('button', { name: /notifications/i }));
+            expect(screen.getByText('Loading...')).toBeInTheDocument();
+        });
+
+        it('shows empty message when not loading and no notifications', () => {
+            render(<NotificationBell {...defaultProps} />);
+            fireEvent.click(screen.getByRole('button', { name: /notifications/i }));
+            expect(screen.getByText('No tips received yet')).toBeInTheDocument();
+        });
+    });
+
+    describe('accessibility', () => {
+        it('bell button has accessible label', () => {
+            render(<NotificationBell {...defaultProps} unreadCount={5} />);
+            const btn = screen.getByRole('button');
+            expect(btn).toHaveAttribute('aria-label', 'Notifications (5 unread)');
+        });
+
+        it('bell button has default label with no unread', () => {
+            render(<NotificationBell {...defaultProps} />);
+            const btn = screen.getByRole('button');
+            expect(btn).toHaveAttribute('aria-label', 'Notifications');
+        });
+
+        it('dropdown has region role', () => {
+            render(<NotificationBell {...defaultProps} />);
+            fireEvent.click(screen.getByRole('button', { name: /notifications/i }));
+            expect(screen.getByRole('region')).toBeInTheDocument();
+        });
+    });
+
+    describe('click outside', () => {
+        it('closes dropdown when clicking outside', () => {
+            render(<NotificationBell {...defaultProps} />);
+            fireEvent.click(screen.getByRole('button', { name: /notifications/i }));
+            expect(screen.getByRole('region')).toBeInTheDocument();
+            fireEvent.mouseDown(document.body);
+            expect(screen.queryByRole('region')).not.toBeInTheDocument();
+        });
+    });
+
+    describe('notification items', () => {
+        it('renders notification items', () => {
+            const notifications = [makeNotification({ amount: '2000000' })];
+            render(<NotificationBell {...defaultProps} notifications={notifications} />);
+            fireEvent.click(screen.getByRole('button', { name: /notifications/i }));
+            expect(screen.getByText(/STX/)).toBeInTheDocument();
+        });
+
+        it('limits displayed items to 20', () => {
+            const notifications = Array.from({ length: 25 }, (_, i) =>
+                makeNotification({ txId: `0x${String(i).padStart(8, '0')}` })
+            );
+            const { container } = render(
+                <NotificationBell {...defaultProps} notifications={notifications} />
+            );
+            fireEvent.click(screen.getByRole('button', { name: /notifications/i }));
+            const items = container.querySelectorAll('.flex.items-start');
+            expect(items.length).toBe(20);
+        });
+
+        it('unread dot has correct size and shape classes', () => {
+            const now = Math.floor(Date.now() / 1000);
+            const notifications = [makeNotification({ timestamp: now + 10 })];
+            const { container } = render(
+                <NotificationBell
+                    {...defaultProps}
+                    notifications={notifications}
+                    lastSeenTimestamp={now}
+                />
+            );
+            fireEvent.click(screen.getByRole('button', { name: /notifications/i }));
+            const dot = container.querySelector('.bg-green-400');
+            expect(dot.className).toContain('w-2');
+            expect(dot.className).toContain('h-2');
+            expect(dot.className).toContain('rounded-full');
+            expect(dot.className).toContain('flex-shrink-0');
+        });
+
+        it('highlights multiple unread items simultaneously', () => {
+            const now = Math.floor(Date.now() / 1000);
+            const notifications = [
+                makeNotification({ txId: '0xaaa', timestamp: now + 5 }),
+                makeNotification({ txId: '0xbbb', timestamp: now + 10 }),
+                makeNotification({ txId: '0xccc', timestamp: now + 15 }),
+            ];
+            const { container } = render(
+                <NotificationBell
+                    {...defaultProps}
+                    notifications={notifications}
+                    lastSeenTimestamp={now}
+                />
+            );
+            fireEvent.click(screen.getByRole('button', { name: /notifications/i }));
+            const highlighted = container.querySelectorAll('[class*="bg-blue-50"]');
+            expect(highlighted.length).toBe(3);
+        });
+    });
+
+    describe('mark all read button', () => {
+        it('shows mark all read button when notifications exist', () => {
+            const notifications = [makeNotification()];
+            render(<NotificationBell {...defaultProps} notifications={notifications} />);
+            fireEvent.click(screen.getByRole('button', { name: /notifications/i }));
+            expect(screen.getByText('Mark all read')).toBeInTheDocument();
+        });
+
+        it('calls onMarkRead when mark all read is clicked', () => {
+            const onMarkRead = vi.fn();
+            const notifications = [makeNotification()];
+            render(
+                <NotificationBell
+                    {...defaultProps}
+                    notifications={notifications}
+                    onMarkRead={onMarkRead}
+                />
+            );
+            fireEvent.click(screen.getByRole('button', { name: /notifications/i }));
+            fireEvent.click(screen.getByText('Mark all read'));
+            expect(onMarkRead).toHaveBeenCalled();
+        });
+    });
+});
diff --git a/frontend/src/test/routing.test.jsx b/frontend/src/test/routing.test.jsx
index 4221ff6e..b3441a78 100644
--- a/frontend/src/test/routing.test.jsx
+++ b/frontend/src/test/routing.test.jsx
@@ -72,6 +72,7 @@ vi.mock('../hooks/useNotifications', () => ({
   useNotifications: () => ({
     notifications: [],
     unreadCount: 0,
+    lastSeenTimestamp: 0,
     markAllRead: vi.fn(),
     loading: false,
   }),
diff --git a/frontend/src/test/useNotifications.test.js b/frontend/src/test/useNotifications.test.js
new file mode 100644
index 00000000..4190ce59
--- /dev/null
+++ b/frontend/src/test/useNotifications.test.js
@@ -0,0 +1,293 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+
+const STORAGE_KEY = 'tipstream_last_seen_tip_ts';
+
+vi.mock('../context/TipContext', () => ({
+    useTipContext: vi.fn(() => ({
+        events: [],
+        eventsLoading: false,
+    })),
+}));
+
+import { useNotifications } from '../hooks/useNotifications';
+import { useTipContext } from '../context/TipContext';
+
+beforeEach(() => {
+    localStorage.clear();
+    vi.restoreAllMocks();
+});
+
+afterEach(() => {
+    localStorage.clear();
+    vi.restoreAllMocks();
+});
+
+const USER_ADDRESS = 'SP1HTBVD3JG9C05J7HBJTHGR0GGW7KXW28M5JS8QE';
+
+function makeTipEvent(overrides = {}) {
+    return {
+        event: 'tip-sent',
+        sender: 'SP31PKQVQZVZCK3FM3NH67CGD6G1FMR17VQVS2W5T',
+        recipient: USER_ADDRESS,
+        amount: '1000000',
+        timestamp: Math.floor(Date.now() / 1000),
+        txId: '0x' + Math.random().toString(16).slice(2, 18),
+        ...overrides,
+    };
+}
+
+describe('useNotifications', () => {
+    it('returns empty notifications when no address', () => {
+        const { result } = renderHook(() => useNotifications(null));
+        expect(result.current.notifications).toEqual([]);
+        expect(result.current.unreadCount).toBe(0);
+    });
+
+    it('filters events to only tip-sent for the user address', () => {
+        const now = Math.floor(Date.now() / 1000);
+        useTipContext.mockReturnValue({
+            events: [
+                makeTipEvent({ timestamp: now }),
+                makeTipEvent({ event: 'other-event', timestamp: now }),
+                makeTipEvent({ recipient: 'SP_OTHER_ADDRESS', timestamp: now }),
+            ],
+            eventsLoading: false,
+        });
+
+        const { result } = renderHook(() => useNotifications(USER_ADDRESS));
+        expect(result.current.notifications.length).toBe(1);
+    });
+
+    it('counts unread based on lastSeen timestamp', () => {
+        const now = Math.floor(Date.now() / 1000);
+        localStorage.setItem(STORAGE_KEY, String(now - 60));
+
+        useTipContext.mockReturnValue({
+            events: [
+                makeTipEvent({ timestamp: now }),
+                makeTipEvent({ timestamp: now - 120 }),
+            ],
+            eventsLoading: false,
+        });
+
+        const { result } = renderHook(() => useNotifications(USER_ADDRESS));
+        expect(result.current.unreadCount).toBe(1);
+    });
+
+    it('exposes lastSeenTimestamp from localStorage', () => {
+        localStorage.setItem(STORAGE_KEY, '1700000000');
+        useTipContext.mockReturnValue({ events: [], eventsLoading: false });
+
+        const { result } = renderHook(() => useNotifications(USER_ADDRESS));
+        expect(result.current.lastSeenTimestamp).toBe(1700000000);
+    });
+
+    it('defaults lastSeenTimestamp to 0 when not in storage', () => {
+        useTipContext.mockReturnValue({ events: [], eventsLoading: false });
+
+        const { result } = renderHook(() => useNotifications(USER_ADDRESS));
+        expect(result.current.lastSeenTimestamp).toBe(0);
+    });
+
+    it('markAllRead updates lastSeenTimestamp', () => {
+        useTipContext.mockReturnValue({ events: [], eventsLoading: false });
+
+        const { result } = renderHook(() => useNotifications(USER_ADDRESS));
+        const before = result.current.lastSeenTimestamp;
+
+        act(() => {
+            result.current.markAllRead();
+        });
+
+        expect(result.current.lastSeenTimestamp).toBeGreaterThan(before);
+    });
+
+    it('markAllRead persists to localStorage', () => {
+        useTipContext.mockReturnValue({ events: [], eventsLoading: false });
+
+        const { result } = renderHook(() => useNotifications(USER_ADDRESS));
+
+        act(() => {
+            result.current.markAllRead();
+        });
+
+        const stored = localStorage.getItem(STORAGE_KEY);
+        expect(stored).toBeTruthy();
+        expect(Number(stored)).toBe(result.current.lastSeenTimestamp);
+    });
+
+    it('markAllRead sets unreadCount to 0', () => {
+        const now = Math.floor(Date.now() / 1000);
+        useTipContext.mockReturnValue({
+            events: [makeTipEvent({ timestamp: now })],
+            eventsLoading: false,
+        });
+
+        const { result } = renderHook(() => useNotifications(USER_ADDRESS));
+        expect(result.current.unreadCount).toBe(1);
+
+        act(() => {
+            result.current.markAllRead();
+        });
+
+        expect(result.current.unreadCount).toBe(0);
+    });
+
+    it('exposes loading state from TipContext', () => {
+        useTipContext.mockReturnValue({ events: [], eventsLoading: true });
+
+        const { result } = renderHook(() => useNotifications(USER_ADDRESS));
+        expect(result.current.loading).toBe(true);
+    });
+
+    it('provides a no-op refetch function', () => {
+        useTipContext.mockReturnValue({ events: [], eventsLoading: false });
+
+        const { result } = renderHook(() => useNotifications(USER_ADDRESS));
+        expect(typeof result.current.refetch).toBe('function');
+        expect(() => result.current.refetch()).not.toThrow();
+    });
+
+    it('assigns synthetic timestamps when block_time is missing', () => {
+        useTipContext.mockReturnValue({
+            events: [
+                makeTipEvent({ timestamp: undefined }),
+            ],
+            eventsLoading: false,
+        });
+
+        const { result } = renderHook(() => useNotifications(USER_ADDRESS));
+        expect(result.current.notifications[0].timestamp).toBeDefined();
+        expect(typeof result.current.notifications[0].timestamp).toBe('number');
+    });
+
+    it('preserves existing timestamp from enriched events', () => {
+        const fixedTs = 1700000000;
+        useTipContext.mockReturnValue({
+            events: [makeTipEvent({ timestamp: fixedTs })],
+            eventsLoading: false,
+        });
+
+        const { result } = renderHook(() => useNotifications(USER_ADDRESS));
+        expect(result.current.notifications[0].timestamp).toBe(fixedTs);
+    });
+
+    it('deduplicates events by txId in notification list', () => {
+        const sharedTxId = '0xdeadbeef';
+        useTipContext.mockReturnValue({
+            events: [
+                makeTipEvent({ txId: sharedTxId, timestamp: 1700000000 }),
+                makeTipEvent({ txId: sharedTxId, timestamp: 1700000001 }),
+            ],
+            eventsLoading: false,
+        });
+
+        const { result } = renderHook(() => useNotifications(USER_ADDRESS));
+        expect(result.current.notifications.length).toBe(2);
+    });
+
+    it('handles empty events array gracefully', () => {
+        useTipContext.mockReturnValue({ events: [], eventsLoading: false });
+
+        const { result } = renderHook(() => useNotifications(USER_ADDRESS));
+        expect(result.current.notifications).toEqual([]);
+        expect(result.current.unreadCount).toBe(0);
+        expect(result.current.lastSeenTimestamp).toBe(0);
+    });
+
+    it('updates unread count when events change', () => {
+        const now = Math.floor(Date.now() / 1000);
+        const mockContext = { events: [], eventsLoading: false };
+        useTipContext.mockReturnValue(mockContext);
+
+        const { result, rerender } = renderHook(() => useNotifications(USER_ADDRESS));
+        expect(result.current.unreadCount).toBe(0);
+
+        useTipContext.mockReturnValue({
+            events: [makeTipEvent({ timestamp: now + 100 })],
+            eventsLoading: false,
+        });
+        rerender();
+
+        expect(result.current.unreadCount).toBe(1);
+    });
+
+    it('returns empty when address changes to null', () => {
+        const now = Math.floor(Date.now() / 1000);
+        useTipContext.mockReturnValue({
+            events: [makeTipEvent({ timestamp: now })],
+            eventsLoading: false,
+        });
+
+        const { result, rerender } = renderHook(
+            ({ addr }) => useNotifications(addr),
+            { initialProps: { addr: USER_ADDRESS } }
+        );
+        expect(result.current.notifications.length).toBe(1);
+
+        rerender({ addr: null });
+        expect(result.current.notifications).toEqual([]);
+    });
+
+    it('excludes events where user is the sender, not recipient', () => {
+        const now = Math.floor(Date.now() / 1000);
+        useTipContext.mockReturnValue({
+            events: [
+                makeTipEvent({
+                    sender: USER_ADDRESS,
+                    recipient: 'SP31PKQVQZVZCK3FM3NH67CGD6G1FMR17VQVS2W5T',
+                    timestamp: now,
+                }),
+            ],
+            eventsLoading: false,
+        });
+
+        const { result } = renderHook(() => useNotifications(USER_ADDRESS));
+        expect(result.current.notifications.length).toBe(0);
+    });
+
+    it('new events after markAllRead appear as unread', () => {
+        const now = Math.floor(Date.now() / 1000);
+        useTipContext.mockReturnValue({
+            events: [makeTipEvent({ timestamp: now })],
+            eventsLoading: false,
+        });
+
+        const { result, rerender } = renderHook(() => useNotifications(USER_ADDRESS));
+
+        act(() => {
+            result.current.markAllRead();
+        });
+        expect(result.current.unreadCount).toBe(0);
+
+        useTipContext.mockReturnValue({
+            events: [
+                makeTipEvent({ timestamp: now }),
+                makeTipEvent({ txId: '0xnew', timestamp: now + 600 }),
+            ],
+            eventsLoading: false,
+        });
+        rerender();
+
+        expect(result.current.unreadCount).toBe(1);
+    });
+
+    it('counts all matching notifications regardless of order', () => {
+        const now = Math.floor(Date.now() / 1000);
+        useTipContext.mockReturnValue({
+            events: [
+                makeTipEvent({ txId: '0x1', timestamp: now - 10 }),
+                makeTipEvent({ txId: '0x2', timestamp: now + 5 }),
+                makeTipEvent({ txId: '0x3', timestamp: now - 20 }),
+                makeTipEvent({ txId: '0x4', timestamp: now + 15 }),
+            ],
+            eventsLoading: false,
+        });
+
+        localStorage.setItem(STORAGE_KEY, String(now));
+        const { result } = renderHook(() => useNotifications(USER_ADDRESS));
+        expect(result.current.notifications.length).toBe(4);
+        expect(result.current.unreadCount).toBe(2);
+    });
+});