From c9f3d8fc071e546aa9cedc24bc24c68c5a2d73fe Mon Sep 17 00:00:00 2001
From: Silberengel <silberengel7@protonmail.com>
Date: Mon, 27 Oct 2025 08:29:17 +0100
Subject: [PATCH] more efficient nostr stats

---
 src/components/NormalFeed/index.tsx         |   6 +-
 src/components/NoteList/index.tsx           |  24 +-
 src/components/ReplyNoteList/index.tsx      | 144 +++++---
 src/components/TrendingNotes/index.tsx      |  22 +-
 src/constants.ts                            |   2 +
 src/pages/primary/DiscussionsPage/index.tsx |  23 +-
 src/services/note-stats.service.ts          | 360 ++++++++------------
 7 files changed, 307 insertions(+), 274 deletions(-)

diff --git a/src/components/NormalFeed/index.tsx b/src/components/NormalFeed/index.tsx
index 9164afb..0cf2261 100644
--- a/src/components/NormalFeed/index.tsx
+++ b/src/components/NormalFeed/index.tsx
@@ -25,7 +25,11 @@ const NormalFeed = forwardRef<TNoteListRef, {
   const { hideUntrustedNotes } = useUserTrust()
   const { showKinds } = useKindFilter()
   const [temporaryShowKinds, setTemporaryShowKinds] = useState(showKinds)
-  const [listMode, setListMode] = useState<TNoteListMode>(() => storage.getNoteListMode())
+  const [listMode, setListMode] = useState<TNoteListMode>(() => {
+    const storedMode = storage.getNoteListMode()
+    // Default to 'posts' (Notes tab) for main feed, not replies
+    return storedMode || 'posts'
+  })
   const supportTouch = useMemo(() => isTouchDevice(), [])
   const internalNoteListRef = useRef<TNoteListRef>(null)
   const noteListRef = ref || internalNoteListRef
diff --git a/src/components/NoteList/index.tsx b/src/components/NoteList/index.tsx
index 0599255..7c06bf1 100644
--- a/src/components/NoteList/index.tsx
+++ b/src/components/NoteList/index.tsx
@@ -160,11 +160,16 @@ const NoteList = forwardRef(
     useImperativeHandle(ref, () => ({ scrollToTop, refresh }), [])
 
   useEffect(() => {
+    console.log('🚀 [NoteList] useEffect triggered:', { 
+      subRequests: subRequests.length, 
+      showKinds: showKinds.length,
+      refreshCount 
+    })
     logger.debug('NoteList useEffect:', { subRequests, subRequestsLength: subRequests.length })
     if (!subRequests.length) return
 
     async function init() {
-        
+        console.log('🔄 [NoteList] Initializing feed...')
         setLoading(true)
         setEvents([])
         setNewEvents([])
@@ -197,8 +202,15 @@ const NoteList = forwardRef(
           })),
           {
             onEvents: (events, eosed) => {
+              console.log('📥 [NoteList] Received events:', { 
+                eventsCount: events.length, 
+                eosed,
+                loading,
+                hasMore 
+              })
               logger.debug('NoteList received events:', { eventsCount: events.length, eosed })
               if (events.length > 0) {
+                console.log('✅ [NoteList] Setting events and stopping loading')
                 setEvents(events)
                 // Stop loading as soon as we have events, don't wait for all relays
                 setLoading(false)
@@ -207,6 +219,7 @@ const NoteList = forwardRef(
                 setHasMore(false)
               }
               if (eosed) {
+                console.log('🏁 [NoteList] EOSED - setting loading false, hasMore:', events.length > 0)
                 setLoading(false)
                 setHasMore(events.length > 0)
               }
@@ -329,6 +342,14 @@ const NoteList = forwardRef(
       }, 0)
     }
 
+    console.log('🎨 [NoteList] Rendering with state:', {
+      eventsCount: events.length,
+      filteredEventsCount: filteredEvents.length,
+      loading,
+      hasMore,
+      showKinds: showKinds.length
+    })
+
     const list = (
       <div className="min-h-screen">
         {customHeader}
@@ -349,6 +370,7 @@ const NoteList = forwardRef(
         ) : (
           <div className="flex justify-center w-full mt-2">
             <Button size="lg" onClick={() => {
+              console.log('🔄 [NoteList] Reload button clicked, refreshing feed')
               // Clear relay connection state to force fresh connections
               const relayUrls = subRequests.flatMap(req => req.urls)
               client.clearRelayConnectionState(relayUrls)
diff --git a/src/components/ReplyNoteList/index.tsx b/src/components/ReplyNoteList/index.tsx
index cd9d024..41da39f 100644
--- a/src/components/ReplyNoteList/index.tsx
+++ b/src/components/ReplyNoteList/index.tsx
@@ -13,13 +13,14 @@ import logger from '@/lib/logger'
 import { toNote } from '@/lib/link'
 import { generateBech32IdFromETag, tagNameEquals } from '@/lib/tag'
 import { normalizeUrl } from '@/lib/url'
-import { useSmartNoteNavigation, useSecondaryPage } from '@/PageManager'
+import { useSmartNoteNavigation } from '@/PageManager'
 import { useContentPolicy } from '@/providers/ContentPolicyProvider'
 import { useMuteList } from '@/providers/MuteListProvider'
 import { useNostr } from '@/providers/NostrProvider'
 import { useReply } from '@/providers/ReplyProvider'
 import { useFeed } from '@/providers/FeedProvider'
 import { useUserTrust } from '@/providers/UserTrustProvider'
+import { useUserPreferences } from '@/providers/UserPreferencesProvider'
 import client from '@/services/client.service'
 import noteStatsService from '@/services/note-stats.service'
 import { Filter, Event as NEvent, kinds } from 'nostr-tools'
@@ -36,17 +37,17 @@ type TRootInfo =
 const LIMIT = 100
 const SHOW_COUNT = 10
 
-function ReplyNoteList({ index, event, sort = 'oldest' }: { index?: number; event: NEvent; sort?: 'newest' | 'oldest' | 'top' | 'controversial' | 'most-zapped' }) {
+function ReplyNoteList({ index: _index, event, sort = 'oldest' }: { index?: number; event: NEvent; sort?: 'newest' | 'oldest' | 'top' | 'controversial' | 'most-zapped' }) {
   console.log('[ReplyNoteList] Component rendered for event:', event.id.substring(0, 8))
   
   const { t } = useTranslation()
   const { navigateToNote } = useSmartNoteNavigation()
-  const { currentIndex } = useSecondaryPage()
   const { hideUntrustedInteractions, isUserTrusted } = useUserTrust()
   const { mutePubkeySet } = useMuteList()
   const { hideContentMentioningMutedUsers } = useContentPolicy()
   const { relayList: userRelayList } = useNostr()
   const { relayUrls: currentFeedRelays } = useFeed()
+  const { showRecommendedRelaysPanel } = useUserPreferences()
   const [rootInfo, setRootInfo] = useState<TRootInfo | undefined>(undefined)
   const { repliesMap, addReplies } = useReply()
 
@@ -106,7 +107,7 @@ function ReplyNoteList({ index, event, sort = 'oldest' }: { index?: number; even
     // This prevents the doom loop that was causing "too many concurrent REQS"
     const events = parentEventKeys.flatMap((id) => repliesMap.get(id)?.events || [])
     
-    logger.debug('[ReplyNoteList] Processing replies:', {
+    console.log('🔍 [ReplyNoteList] Processing replies:', {
       eventId: event.id.substring(0, 8),
       parentEventKeys,
       eventsFromMap: events.length,
@@ -115,16 +116,22 @@ function ReplyNoteList({ index, event, sort = 'oldest' }: { index?: number; even
     })
     
     events.forEach((evt) => {
-      if (replyIdSet.has(evt.id)) return
+      if (replyIdSet.has(evt.id)) {
+        console.log('🔍 [ReplyNoteList] Skipping duplicate event:', evt.id.substring(0, 8))
+        return
+      }
       if (mutePubkeySet.has(evt.pubkey)) {
+        console.log('🔍 [ReplyNoteList] Skipping muted user event:', evt.id.substring(0, 8), 'pubkey:', evt.pubkey.substring(0, 8))
         return
       }
       if (hideContentMentioningMutedUsers && isMentioningMutedUsers(evt, mutePubkeySet)) {
+        console.log('🔍 [ReplyNoteList] Skipping event mentioning muted users:', evt.id.substring(0, 8))
         return
       }
 
       replyIdSet.add(evt.id)
       replyEvents.push(evt)
+      console.log('✅ [ReplyNoteList] Added reply event:', evt.id.substring(0, 8), 'kind:', evt.kind)
     })
     
 
@@ -169,6 +176,9 @@ function ReplyNoteList({ index, event, sort = 'oldest' }: { index?: number; even
         return replyEvents.sort((a, b) => b.created_at - a.created_at)
     }
   }, [event.id, repliesMap, mutePubkeySet, hideContentMentioningMutedUsers, sort])
+  
+  // Debug the final replies count
+  console.log('📊 [ReplyNoteList] Final replies count:', replies.length)
   const [timelineKey, setTimelineKey] = useState<string | undefined>(undefined)
   const [until, setUntil] = useState<number | undefined>(undefined)
   const [loading, setLoading] = useState<boolean>(false)
@@ -226,6 +236,7 @@ function ReplyNoteList({ index, event, sort = 'oldest' }: { index?: number; even
         rootInfo: root,
         eventKind: event.kind
       })
+      console.log('🏗️ [ReplyNoteList] Setting rootInfo:', root)
       setRootInfo(root)
     }
     fetchRootEvent()
@@ -253,26 +264,23 @@ function ReplyNoteList({ index, event, sort = 'oldest' }: { index?: number; even
   }, [rootInfo, onNewReply])
 
   useEffect(() => {
-    console.log('[ReplyNoteList] Main useEffect triggered:', {
+    console.log('⚡ [ReplyNoteList] Main useEffect triggered:', {
       loading,
       hasRootInfo: !!rootInfo,
-      currentIndex,
-      index,
-      shouldInit: !loading && !!rootInfo && currentIndex === index
+      shouldInit: !loading && !!rootInfo,
+      rootInfo
     })
     
-    if (loading || !rootInfo || currentIndex !== index) {
-      console.log('[ReplyNoteList] Early return - conditions not met:', {
+    if (loading || !rootInfo) {
+      console.log('❌ [ReplyNoteList] Early return - conditions not met:', {
         loading,
         hasRootInfo: !!rootInfo,
-        currentIndex,
-        index,
         rootInfo
       })
       return
     }
     
-    console.log('[ReplyNoteList] All conditions met, starting reply fetch...')
+    console.log('✅ [ReplyNoteList] All conditions met, starting reply fetch...')
     
     // Clear any existing timeout to prevent multiple simultaneous requests
     if (requestTimeoutRef.current) {
@@ -294,31 +302,26 @@ function ReplyNoteList({ index, event, sort = 'oldest' }: { index?: number; even
 
           try {
             
-            // Use current feed's relay selection - if user selected a specific relay, use only that
+            // For replies, always use a comprehensive relay list to ensure we find replies
+            // Don't rely on currentFeedRelays as it might be limited to a single relay
             let finalRelayUrls: string[]
             
             console.log('[ReplyNoteList] Current feed relays:', currentFeedRelays)
             
-            if (currentFeedRelays.length > 0) {
-              // Use the current feed's relay selection (respects user's choice of single relay)
-              finalRelayUrls = currentFeedRelays.map(url => normalizeUrl(url) || url).filter(Boolean)
-              console.log('[ReplyNoteList] Using current feed relays:', finalRelayUrls)
-            } else {
-              // Fallback: build comprehensive relay list only if no feed relays are set
-              const userReadRelays = userRelayList?.read || []
-              const userWriteRelays = userRelayList?.write || []
-              const eventHints = client.getEventHints(event.id)
-              
-              const allRelays = [
-                ...userReadRelays.map(url => normalizeUrl(url) || url),
-                ...userWriteRelays.map(url => normalizeUrl(url) || url),
-                ...eventHints.map(url => normalizeUrl(url) || url),
-                ...FAST_READ_RELAY_URLS.map(url => normalizeUrl(url) || url),
-              ]
-              
-              finalRelayUrls = Array.from(new Set(allRelays.filter(Boolean)))
-              console.log('[ReplyNoteList] Using fallback relay list:', finalRelayUrls)
-            }
+            // Always build comprehensive relay list for replies to ensure we find them
+            const userReadRelays = userRelayList?.read || []
+            const userWriteRelays = userRelayList?.write || []
+            const eventHints = client.getEventHints(event.id)
+            
+            const allRelays = [
+              ...userReadRelays.map(url => normalizeUrl(url) || url),
+              ...userWriteRelays.map(url => normalizeUrl(url) || url),
+              ...eventHints.map(url => normalizeUrl(url) || url),
+              ...FAST_READ_RELAY_URLS.map(url => normalizeUrl(url) || url),
+            ]
+            
+            finalRelayUrls = Array.from(new Set(allRelays.filter(Boolean)))
+            console.log('[ReplyNoteList] Using comprehensive relay list for replies:', finalRelayUrls)
             
             logger.debug('[ReplyNoteList] Fetching replies for event:', {
               eventId: event.id.substring(0, 8),
@@ -384,13 +387,17 @@ function ReplyNoteList({ index, event, sort = 'oldest' }: { index?: number; even
                   eosed,
                   eventIds: evts.map(e => e.id.substring(0, 8))
                 })
+                console.log('📥 [ReplyNoteList] Received events:', evts.length, 'eosed:', eosed)
                 if (evts.length > 0) {
                   const regularReplies = evts.filter((evt) => isReplyNoteEvent(evt))
-                  logger.debug('[ReplyNoteList] Filtered replies:', {
+                  console.log('🔍 [ReplyNoteList] Filtered replies:', {
                     replyCount: regularReplies.length,
                     replyIds: regularReplies.map(r => r.id.substring(0, 8))
                   })
+                  console.log('➕ [ReplyNoteList] Adding replies to map:', regularReplies.length)
                   addReplies(regularReplies)
+                } else {
+                  console.log('❌ [ReplyNoteList] No events received')
                 }
               if (eosed) {
                 setUntil(evts.length >= LIMIT ? evts[evts.length - 1].created_at - 1 : undefined)
@@ -434,7 +441,7 @@ function ReplyNoteList({ index, event, sort = 'oldest' }: { index?: number; even
         clearTimeout(requestTimeoutRef.current)
       }
     }
-  }, [rootInfo, currentIndex, index, onNewReply])
+  }, [rootInfo, onNewReply, loading])
 
   useEffect(() => {
     // Only try to load more if we have no replies, not loading, have a timeline key, and haven't reached the end
@@ -531,6 +538,16 @@ function ReplyNoteList({ index, event, sort = 'oldest' }: { index?: number; even
           const parentETag = getParentETag(reply)
           const parentEventHexId = parentETag?.[1]
           const parentEventId = parentETag ? generateBech32IdFromETag(parentETag) : undefined
+          
+          // Debug logging for parent event detection
+          logger.debug('[ReplyNoteList] Reply parent info:', {
+            replyId: reply.id.substring(0, 8),
+            parentETag,
+            parentEventHexId: parentEventHexId?.substring(0, 8),
+            parentEventId: parentEventId?.substring(0, 8),
+            isDifferentFromCurrent: event.id !== parentEventHexId,
+            currentEventId: event.id.substring(0, 8)
+          })
           return (
             <div
               ref={(el) => (replyRefs.current[reply.id] = el)}
@@ -541,12 +558,57 @@ function ReplyNoteList({ index, event, sort = 'oldest' }: { index?: number; even
                 event={reply}
                 parentEventId={event.id !== parentEventHexId ? parentEventId : undefined}
                 onClickParent={() => {
-                  if (!parentEventHexId) return
-                  if (replies.every((r) => r.id !== parentEventHexId)) {
-                    navigateToNote(toNote(parentEventId ?? parentEventHexId))
+                  logger.debug('[ReplyNoteList] onClickParent called:', {
+                    parentEventHexId: parentEventHexId?.substring(0, 8),
+                    parentEventId: parentEventId?.substring(0, 8),
+                    showRecommendedRelaysPanel,
+                    repliesCount: replies.length,
+                    parentInReplies: !replies.every((r) => r.id !== parentEventHexId)
+                  })
+                  
+                  if (!parentEventHexId) {
+                    logger.debug('[ReplyNoteList] No parentEventHexId, returning early')
+                    return
+                  }
+                  
+                  // First, try to highlight the parent if it's already in the replies
+                  if (!replies.every((r) => r.id !== parentEventHexId)) {
+                    logger.debug('[ReplyNoteList] Parent found in replies, highlighting:', parentEventHexId.substring(0, 8))
+                    highlightReply(parentEventHexId)
                     return
                   }
-                  highlightReply(parentEventHexId)
+                  
+                  // If parent is not in current replies, we need to fetch it
+                  // In single-panel mode, we should expand the thread to show the parent
+                  // rather than navigating away from the current thread
+                  if (!showRecommendedRelaysPanel) {
+                    // Single-panel mode: fetch and add the parent to the thread
+                    // This will expand the current thread to show the parent
+                    logger.debug('[ReplyNoteList] Single-panel mode: fetching parent event')
+                    const fetchAndAddParent = async () => {
+                      try {
+                        logger.debug('[ReplyNoteList] Fetching parent event:', parentEventId ?? parentEventHexId)
+                        const parentEvent = await client.fetchEvent(parentEventId ?? parentEventHexId)
+                        if (parentEvent) {
+                          logger.debug('[ReplyNoteList] Parent event fetched, adding to replies:', parentEvent.id.substring(0, 8))
+                          addReplies([parentEvent])
+                          // Highlight the parent after it's added
+                          setTimeout(() => highlightReply(parentEvent.id), 100)
+                        } else {
+                          logger.debug('[ReplyNoteList] Parent event not found')
+                        }
+                      } catch (error) {
+                        logger.debug('[ReplyNoteList] Failed to fetch parent event:', error)
+                        // Fallback to navigation if fetch fails
+                        navigateToNote(toNote(parentEventId ?? parentEventHexId))
+                      }
+                    }
+                    fetchAndAddParent()
+                  } else {
+                    // Double-panel mode: navigate to parent in secondary panel
+                    logger.debug('[ReplyNoteList] Double-panel mode: navigating to parent')
+                    navigateToNote(toNote(parentEventId ?? parentEventHexId))
+                  }
                 }}
                 highlight={highlightReplyId === reply.id}
               />
diff --git a/src/components/TrendingNotes/index.tsx b/src/components/TrendingNotes/index.tsx
index e8e2abf..5070361 100644
--- a/src/components/TrendingNotes/index.tsx
+++ b/src/components/TrendingNotes/index.tsx
@@ -10,7 +10,7 @@ import { useNostr } from '@/providers/NostrProvider'
 import { useFavoriteRelays } from '@/providers/FavoriteRelaysProvider'
 import { useZap } from '@/providers/ZapProvider'
 import noteStatsService from '@/services/note-stats.service'
-import { BIG_RELAY_URLS, FAST_READ_RELAY_URLS } from '@/constants'
+import { FAST_READ_RELAY_URLS } from '@/constants'
 import logger from '@/lib/logger'
 import { normalizeUrl } from '@/lib/url'
 
@@ -197,9 +197,13 @@ export default function TrendingNotes() {
       if (relayList?.read) {
         relays.push(...relayList.read)
       }
+      
+      // If user has no favorites and no read relays, fallback to FAST_READ_RELAY_URLS
+      if (relays.length === 0) {
+        relays.push(...FAST_READ_RELAY_URLS)
+      }
     } else {
-      // User is not logged in: BIG_RELAY_URLS + FAST_READ_RELAY_URLS
-      relays.push(...BIG_RELAY_URLS)
+      // User is not logged in: use FAST_READ_RELAY_URLS (includes all BIG_RELAY_URLS)
       relays.push(...FAST_READ_RELAY_URLS)
     }
 
@@ -278,10 +282,14 @@ export default function TrendingNotes() {
         
         logger.debug('[TrendingNotes] Starting cache initialization with', relays.length, 'relays:', relays)
         
-        // 1. Fetch top-level posts from last 24 hours - batch requests to avoid overwhelming relays
+        // 1. Fetch top-level posts from last 24 hours from ALL relays for comprehensive statistics
+        // Relay list: If user logged in = favoriteRelays + user's read relays (fallback to FAST_READ_RELAY_URLS), else = FAST_READ_RELAY_URLS
         const batchSize = 3 // Process 3 relays at a time
         const recentEvents: NostrEvent[] = []
         
+        logger.debug('[TrendingNotes] Using full relay set for comprehensive statistics:', relays.length, 'relays')
+        logger.debug('[TrendingNotes] Relay source:', pubkey ? 'user favorites + read relays (or FAST_READ_RELAY_URLS fallback)' : 'FAST_READ_RELAY_URLS')
+        
         for (let i = 0; i < relays.length; i += batchSize) {
           const batch = relays.slice(i, i + batchSize)
           logger.debug('[TrendingNotes] Processing batch', Math.floor(i/batchSize) + 1, 'of', Math.ceil(relays.length/batchSize), 'relays:', batch)
@@ -307,13 +315,13 @@ export default function TrendingNotes() {
           
           // Add a small delay between batches to be respectful to relays
           if (i + batchSize < relays.length) {
-            await new Promise(resolve => setTimeout(resolve, 100))
+            await new Promise(resolve => setTimeout(resolve, 200))
           }
         }
         
         allEvents.push(...recentEvents)
 
-        // 2. Fetch events from bookmark/pin lists (with rate limiting)
+        // 2. Fetch events from bookmark/pin lists (with rate limiting) - use full relay list
         if (listEventIds.length > 0) {
           try {
             const bookmarkPinEvents = await client.fetchEvents(relays, {
@@ -326,7 +334,7 @@ export default function TrendingNotes() {
           }
         }
 
-        // 3. Fetch pin list if user is logged in
+        // 3. Fetch pin list if user is logged in - use full relay list
         if (pubkey) {
           try {
             const pinListEvent = await client.fetchPinListEvent(pubkey)
diff --git a/src/constants.ts b/src/constants.ts
index 4fc534d..6ba7e0a 100644
--- a/src/constants.ts
+++ b/src/constants.ts
@@ -73,6 +73,8 @@ export const FAST_READ_RELAY_URLS = [
   'wss://theforest.nostr1.com',
   'wss://orly-relay.imwald.eu',
   'wss://nostr.wine',
+  'wss://nostr.land',
+  'wss://nostr21.com',
   'wss://thecitadel.nostr1.com',
   'wss://aggr.nostr.land'
 ]
diff --git a/src/pages/primary/DiscussionsPage/index.tsx b/src/pages/primary/DiscussionsPage/index.tsx
index e0d89e0..0c390fb 100644
--- a/src/pages/primary/DiscussionsPage/index.tsx
+++ b/src/pages/primary/DiscussionsPage/index.tsx
@@ -238,13 +238,13 @@ function analyzeDynamicTopics(entries: EventMapEntry[]): {
   
   const allTopics = [...mainTopics, ...subtopics]
   
-  // Debug logging
-  console.log('Dynamic topics analysis:', {
-    hashtagCounts: Object.fromEntries(hashtagCounts),
-    mainTopics: mainTopics.map(t => ({ id: t.id, count: t.count })),
-    subtopics: subtopics.map(t => ({ id: t.id, count: t.count })),
-    allTopics: allTopics.map(t => ({ id: t.id, count: t.count, isMainTopic: t.isMainTopic, isSubtopic: t.isSubtopic }))
-  })
+  // Debug logging (commented out to reduce console spam)
+  // console.log('Dynamic topics analysis:', {
+  //   hashtagCounts: Object.fromEntries(hashtagCounts),
+  //   mainTopics: mainTopics.map(t => ({ id: t.id, count: t.count })),
+  //   subtopics: subtopics.map(t => ({ id: t.id, count: t.count })),
+  //   allTopics: allTopics.map(t => ({ id: t.id, count: t.count, isMainTopic: t.isMainTopic, isSubtopic: t.isSubtopic }))
+  // })
   
   return { mainTopics, subtopics, allTopics }
 }
@@ -440,9 +440,12 @@ const DiscussionsPage = forwardRef(() => {
         }
       })
       
-      // Analyze dynamic topics
-      const dynamicTopicsAnalysis = analyzeDynamicTopics(Array.from(newEventMap.values()))
-      setDynamicTopics(dynamicTopicsAnalysis)
+      // Analyze dynamic topics only if we have new data
+      let dynamicTopicsAnalysis: { mainTopics: DynamicTopic[]; subtopics: DynamicTopic[]; allTopics: DynamicTopic[] } = { mainTopics: [], subtopics: [], allTopics: [] }
+      if (newEventMap.size > 0) {
+        dynamicTopicsAnalysis = analyzeDynamicTopics(Array.from(newEventMap.values()))
+        setDynamicTopics(dynamicTopicsAnalysis)
+      }
       
       // Update event map with enhanced topic categorization
       const updatedEventMap = new Map<string, EventMapEntry>()
diff --git a/src/services/note-stats.service.ts b/src/services/note-stats.service.ts
index 8110e54..4ffd25d 100644
--- a/src/services/note-stats.service.ts
+++ b/src/services/note-stats.service.ts
@@ -1,4 +1,4 @@
-import { BIG_RELAY_URLS, ExtendedKind, SEARCHABLE_RELAY_URLS, FAST_READ_RELAY_URLS } from '@/constants'
+import { ExtendedKind, FAST_READ_RELAY_URLS } from '@/constants'
 import { getReplaceableCoordinateFromEvent, isReplaceableEvent } from '@/lib/event'
 import { getZapInfoFromEvent } from '@/lib/event-metadata'
 import logger from '@/lib/logger'
@@ -29,8 +29,14 @@ class NoteStatsService {
   static instance: NoteStatsService
   private noteStatsMap: Map<string, Partial<TNoteStats>> = new Map()
   private noteStatsSubscribers = new Map<string, Set<() => void>>()
-  private processingCache = new Set<string>() // Prevent duplicate processing
-  private lastProcessedTime = new Map<string, number>() // Rate limiting
+  private processingCache = new Set<string>()
+  private lastProcessedTime = new Map<string, number>()
+  
+  // Batch processing
+  private pendingEvents = new Set<string>()
+  private batchTimeout: NodeJS.Timeout | null = null
+  private readonly BATCH_DELAY = 1000 // 1 second batch delay
+  private readonly MAX_BATCH_SIZE = 10 // Process up to 10 events at once
 
   constructor() {
     if (!NoteStatsService.instance) {
@@ -39,87 +45,126 @@ class NoteStatsService {
     return NoteStatsService.instance
   }
 
-  async fetchNoteStats(event: Event, pubkey?: string | null, favoriteRelays?: string[]) {
+  async fetchNoteStats(event: Event, _pubkey?: string | null, _favoriteRelays?: string[]) {
     const eventId = event.id
     
-    // Rate limiting: Don't process the same event more than once per 5 seconds
+    // Rate limiting: Don't process the same event more than once per 10 seconds
     const now = Date.now()
     const lastProcessed = this.lastProcessedTime.get(eventId)
-    if (lastProcessed && now - lastProcessed < 5000) {
+    if (lastProcessed && now - lastProcessed < 10000) {
       logger.debug('[NoteStats] Skipping duplicate fetch for event', eventId.substring(0, 8), 'too soon')
       return
     }
     
-    // Prevent concurrent processing of the same event
+    // Add to batch processing queue
+    this.pendingEvents.add(eventId)
+    this.lastProcessedTime.set(eventId, now)
+    
+    // Clear existing timeout and set new one
+    if (this.batchTimeout) {
+      clearTimeout(this.batchTimeout)
+    }
+    
+    this.batchTimeout = setTimeout(() => {
+      this.processBatch()
+    }, this.BATCH_DELAY)
+    
+    // If we have enough events or this is urgent, process immediately
+    if (this.pendingEvents.size >= this.MAX_BATCH_SIZE) {
+      this.processBatch()
+    }
+  }
+
+  private async processBatch() {
+    if (this.pendingEvents.size === 0) return
+    
+    const eventsToProcess = Array.from(this.pendingEvents).slice(0, this.MAX_BATCH_SIZE)
+    this.pendingEvents.clear()
+    
+    if (this.batchTimeout) {
+      clearTimeout(this.batchTimeout)
+      this.batchTimeout = null
+    }
+    
+    console.log('[NoteStats] Processing batch of', eventsToProcess.length, 'events')
+    
+    // Process all events in the batch
+    await Promise.all(eventsToProcess.map(eventId => this.processSingleEvent(eventId)))
+  }
+
+  private async processSingleEvent(eventId: string) {
     if (this.processingCache.has(eventId)) {
       logger.debug('[NoteStats] Skipping concurrent fetch for event', eventId.substring(0, 8))
       return
     }
     
     this.processingCache.add(eventId)
-    this.lastProcessedTime.set(eventId, now)
     
     try {
+      // Get the event from cache or fetch it
+      const event = await this.getEventById(eventId)
+      if (!event) {
+        logger.debug('[NoteStats] Event not found:', eventId.substring(0, 8))
+        return
+      }
+
       const oldStats = this.noteStatsMap.get(eventId)
       let since: number | undefined
       if (oldStats?.updatedAt) {
         since = oldStats.updatedAt
       }
-    // Privacy: Only use current user's relays + defaults, never connect to other users' relays
-    const [relayList, authorProfile] = await Promise.all([
-      pubkey ? client.fetchRelayList(pubkey) : Promise.resolve({ write: [], read: [] }),
-      client.fetchProfile(event.pubkey)
-    ])
-
-    // Build comprehensive relay list: user's inboxes + user's favorite relays + big relays
-    // For anonymous users, also include fast read relays for better coverage
-    const allRelays = [
-      ...(relayList.read || []), // User's inboxes (kind 10002)
-      ...(favoriteRelays || []), // User's favorite relays (kind 10012)
-      ...BIG_RELAY_URLS,         // Big relays
-      ...(pubkey ? [] : [...SEARCHABLE_RELAY_URLS, ...FAST_READ_RELAY_URLS]) // Fast read relays for anonymous users only
-    ]
-    
-    // Normalize and deduplicate relay URLs
-    const normalizedRelays = allRelays
+
+      // Use optimized relay selection - fewer relays, better performance
+      const finalRelayUrls = this.getOptimizedRelayList()
+      
+      const replaceableCoordinate = isReplaceableEvent(event.kind)
+        ? getReplaceableCoordinateFromEvent(event)
+        : undefined
+
+      const filters: Filter[] = this.buildFilters(event, replaceableCoordinate, since)
+
+      const events: Event[] = []
+      logger.debug('[NoteStats] Fetching stats for event', event.id.substring(0, 8), 'from', finalRelayUrls.length, 'relays')
+      
+      await client.fetchEvents(finalRelayUrls, filters, {
+        onevent: (evt) => {
+          this.updateNoteStatsByEvents([evt], event.pubkey)
+          events.push(evt)
+        }
+      })
+      
+      logger.debug('[NoteStats] Fetched', events.length, 'events for stats')
+      
+      this.noteStatsMap.set(event.id, {
+        ...(this.noteStatsMap.get(event.id) ?? {}),
+        updatedAt: dayjs().unix()
+      })
+      
+    } finally {
+      this.processingCache.delete(eventId)
+    }
+  }
+
+  private getOptimizedRelayList(): string[] {
+    // Use only FAST_READ_RELAY_URLS for optimal performance
+    const normalizedRelays = FAST_READ_RELAY_URLS
       .map(url => normalizeUrl(url))
       .filter((url): url is string => !!url)
     
-    const finalRelayUrls = Array.from(new Set(normalizedRelays))
-    const relayTypes = pubkey 
-      ? 'inboxes kind 10002 + favorites kind 10012 + big relays'
-      : 'big relays + fast read relays + searchable relays (anonymous user)'
-    logger.debug('[NoteStats] Using', finalRelayUrls.length, 'relays for stats (' + relayTypes + '):', finalRelayUrls)
-
-    const replaceableCoordinate = isReplaceableEvent(event.kind)
-      ? getReplaceableCoordinateFromEvent(event)
-      : undefined
+    return Array.from(new Set(normalizedRelays))
+  }
 
+  private buildFilters(event: Event, replaceableCoordinate?: string, since?: number): Filter[] {
     const filters: Filter[] = [
       {
         '#e': [event.id],
-        kinds: [kinds.Reaction],
-        limit: 100
-      },
-      {
-        '#e': [event.id],
-        kinds: [kinds.Repost],
-        limit: 100
-      },
-      {
-        '#e': [event.id],
-        kinds: [kinds.ShortTextNote, ExtendedKind.COMMENT, ExtendedKind.VOICE_COMMENT],
-        limit: 100
+        kinds: [kinds.Reaction, kinds.Repost, kinds.ShortTextNote, ExtendedKind.COMMENT, ExtendedKind.VOICE_COMMENT, kinds.Highlights],
+        limit: 50 // Reduced limit for better performance
       },
       {
         '#q': [event.id],
         kinds: [kinds.ShortTextNote, ExtendedKind.COMMENT, ExtendedKind.VOICE_COMMENT],
-        limit: 100
-      },
-      {
-        '#e': [event.id],
-        kinds: [kinds.Highlights],
-        limit: 100
+        limit: 50
       }
     ]
 
@@ -127,110 +172,30 @@ class NoteStatsService {
       filters.push(
         {
           '#a': [replaceableCoordinate],
-          kinds: [kinds.Reaction],
-          limit: 100
-        },
-        {
-          '#a': [replaceableCoordinate],
-          kinds: [kinds.Repost],
-          limit: 100
-        },
-        {
-          '#a': [replaceableCoordinate],
-          kinds: [kinds.ShortTextNote, ExtendedKind.COMMENT, ExtendedKind.VOICE_COMMENT],
-          limit: 100
+          kinds: [kinds.Reaction, kinds.Repost, kinds.ShortTextNote, ExtendedKind.COMMENT, ExtendedKind.VOICE_COMMENT, kinds.Highlights],
+          limit: 50
         },
         {
           '#q': [replaceableCoordinate],
           kinds: [kinds.ShortTextNote, ExtendedKind.COMMENT, ExtendedKind.VOICE_COMMENT],
-          limit: 100
-        },
-        {
-          '#a': [replaceableCoordinate],
-          kinds: [kinds.Highlights],
-          limit: 100
+          limit: 50
         }
       )
     }
 
-    if (authorProfile?.lightningAddress) {
-      filters.push({
-        '#e': [event.id],
-        kinds: [kinds.Zap],
-        limit: 100
-      })
-
-      if (replaceableCoordinate) {
-        filters.push({
-          '#a': [replaceableCoordinate],
-          kinds: [kinds.Zap],
-          limit: 100
-        })
-      }
-    }
-
-    if (pubkey) {
-      filters.push({
-        '#e': [event.id],
-        authors: [pubkey],
-        kinds: [kinds.Reaction, kinds.Repost]
-      })
-
-      if (replaceableCoordinate) {
-        filters.push({
-          '#a': [replaceableCoordinate],
-          authors: [pubkey],
-          kinds: [kinds.Reaction, kinds.Repost]
-        })
-      }
-
-      if (authorProfile?.lightningAddress) {
-        filters.push({
-          '#e': [event.id],
-          '#P': [pubkey],
-          kinds: [kinds.Zap]
-        })
-
-        if (replaceableCoordinate) {
-          filters.push({
-            '#a': [replaceableCoordinate],
-            '#P': [pubkey],
-            kinds: [kinds.Zap]
-          })
-        }
-      }
-    }
-
     if (since) {
       filters.forEach((filter) => {
         filter.since = since
       })
     }
-    const events: Event[] = []
-    logger.debug('[NoteStats] Fetching stats for event', event.id.substring(0, 8), 'from', finalRelayUrls.length, 'relays')
-    await client.fetchEvents(finalRelayUrls, filters, {
-      onevent: (evt) => {
-        this.updateNoteStatsByEvents([evt], event.pubkey)
-        events.push(evt)
-      }
-    })
-    logger.debug('[NoteStats] Fetched', events.length, 'events for stats')
-    
-    // Debug: Count events by kind
-    const eventsByKind = events.reduce((acc, evt) => {
-      acc[evt.kind] = (acc[evt.kind] || 0) + 1
-      return acc
-    }, {} as Record<number, number>)
-    logger.debug('[NoteStats] Events by kind:', eventsByKind)
-    this.noteStatsMap.set(event.id, {
-      ...(this.noteStatsMap.get(event.id) ?? {}),
-      updatedAt: dayjs().unix()
-    })
-    return this.noteStatsMap.get(event.id) ?? {}
-    } finally {
-      // Clean up processing cache
-      this.processingCache.delete(eventId)
-    }
+
+    return filters
+  }
+
+  private async getEventById(eventId: string): Promise<Event | null> {
+    // Fetch the event
+    const event = await client.fetchEvent(eventId)
+    return event || null
   }
 
   subscribeNoteStats(noteId: string, callback: () => void) {
@@ -257,7 +222,6 @@ class NoteStatsService {
     return this.noteStatsMap.get(id)
   }
 
-
   addZap(
     pubkey: string,
     eventId: string,
@@ -283,34 +247,47 @@ class NoteStatsService {
 
   updateNoteStatsByEvents(events: Event[], originalEventAuthor?: string) {
     const updatedEventIdSet = new Set<string>()
-    events.forEach((evt) => {
-      let updatedEventId: string | undefined
-      if (evt.kind === kinds.Reaction) {
-        updatedEventId = this.addLikeByEvent(evt, originalEventAuthor)
-      } else if (evt.kind === kinds.Repost) {
-        updatedEventId = this.addRepostByEvent(evt, originalEventAuthor)
-      } else if (evt.kind === kinds.Zap) {
-        updatedEventId = this.addZapByEvent(evt, originalEventAuthor)
-      } else if (evt.kind === kinds.ShortTextNote || evt.kind === ExtendedKind.COMMENT || evt.kind === ExtendedKind.VOICE_COMMENT) {
-        // Check if it's a reply or quote
-        const isQuote = this.isQuoteByEvent(evt)
-        if (isQuote) {
-          updatedEventId = this.addQuoteByEvent(evt, originalEventAuthor)
-        } else {
-          updatedEventId = this.addReplyByEvent(evt, originalEventAuthor)
+    
+    // Process events in batches for better performance
+    const batchSize = 50
+    for (let i = 0; i < events.length; i += batchSize) {
+      const batch = events.slice(i, i + batchSize)
+      batch.forEach((evt) => {
+        const updatedEventId = this.processEvent(evt, originalEventAuthor)
+        if (updatedEventId) {
+          updatedEventIdSet.add(updatedEventId)
         }
-      } else if (evt.kind === kinds.Highlights) {
-        updatedEventId = this.addHighlightByEvent(evt, originalEventAuthor)
-      }
-      if (updatedEventId) {
-        updatedEventIdSet.add(updatedEventId)
-      }
-    })
+      })
+    }
+    
     updatedEventIdSet.forEach((eventId) => {
       this.notifyNoteStats(eventId)
     })
   }
 
+  private processEvent(evt: Event, originalEventAuthor?: string): string | undefined {
+    let updatedEventId: string | undefined
+    
+    if (evt.kind === kinds.Reaction) {
+      updatedEventId = this.addLikeByEvent(evt, originalEventAuthor)
+    } else if (evt.kind === kinds.Repost) {
+      updatedEventId = this.addRepostByEvent(evt, originalEventAuthor)
+    } else if (evt.kind === kinds.Zap) {
+      updatedEventId = this.addZapByEvent(evt, originalEventAuthor)
+    } else if (evt.kind === kinds.ShortTextNote || evt.kind === ExtendedKind.COMMENT || evt.kind === ExtendedKind.VOICE_COMMENT) {
+      const isQuote = this.isQuoteByEvent(evt)
+      if (isQuote) {
+        updatedEventId = this.addQuoteByEvent(evt, originalEventAuthor)
+      } else {
+        updatedEventId = this.addReplyByEvent(evt, originalEventAuthor)
+      }
+    } else if (evt.kind === kinds.Highlights) {
+      updatedEventId = this.addHighlightByEvent(evt, originalEventAuthor)
+    }
+    
+    return updatedEventId
+  }
+
   private addLikeByEvent(evt: Event, originalEventAuthor?: string) {
     const targetEventId = evt.tags.findLast(tagNameEquals('e'))?.[1]
     if (!targetEventId) return
@@ -320,9 +297,7 @@ class NoteStatsService {
     const likes = old.likes || []
     if (likeIdSet.has(evt.id)) return
 
-    // Skip self-interactions - don't count likes from the original event author
     if (originalEventAuthor && originalEventAuthor === evt.pubkey) {
-      // console.log('[NoteStats] Skipping self-like from', evt.pubkey, 'to event', targetEventId)
       return
     }
 
@@ -369,9 +344,7 @@ class NoteStatsService {
     const reposts = old.reposts || []
     if (repostPubkeySet.has(evt.pubkey)) return
 
-    // Skip self-interactions - don't count reposts from the original event author
     if (originalEventAuthor && originalEventAuthor === evt.pubkey) {
-      // console.log('[NoteStats] Skipping self-repost from', evt.pubkey, 'to event', eventId)
       return
     }
 
@@ -387,9 +360,7 @@ class NoteStatsService {
     const { originalEventId, senderPubkey, invoice, amount, comment } = info
     if (!originalEventId || !senderPubkey) return
 
-    // Skip self-interactions - don't count zaps from the original event author
     if (originalEventAuthor && originalEventAuthor === senderPubkey) {
-      // console.log('[NoteStats] Skipping self-zap from', senderPubkey, 'to event', originalEventId)
       return
     }
 
@@ -405,53 +376,38 @@ class NoteStatsService {
   }
 
   private addReplyByEvent(evt: Event, originalEventAuthor?: string) {
-    // Use the same logic as isReplyNoteEvent to identify replies
     let originalEventId: string | undefined
 
-    // For kind 1111 and 1244, always consider them replies and look for parent event
     if (evt.kind === ExtendedKind.COMMENT || evt.kind === ExtendedKind.VOICE_COMMENT) {
       const eTag = evt.tags.find(tagNameEquals('e')) ?? evt.tags.find(tagNameEquals('E'))
       originalEventId = eTag?.[1]
-    }
-    // For kind 1 (ShortTextNote), check if it's actually a reply
-    else if (evt.kind === kinds.ShortTextNote) {
-      // Check for parent E tag (reply or root marker)
+    } else if (evt.kind === kinds.ShortTextNote) {
       const parentETag = evt.tags.find(([tagName, , , marker]) => {
         return tagName === 'e' && (marker === 'reply' || marker === 'root')
       })
       if (parentETag) {
         originalEventId = parentETag[1]
-        logger.debug('[NoteStats] Found reply with root/reply marker:', evt.id, '->', originalEventId)
       } else {
-        // Look for the last E tag that's not a mention
-        const embeddedEventIds = this.getEmbeddedNoteBech32Ids(evt)
         const lastETag = evt.tags.findLast(
           ([tagName, tagValue, , marker]) =>
             tagName === 'e' &&
             !!tagValue &&
-            marker !== 'mention' &&
-            !embeddedEventIds.includes(tagValue)
+            marker !== 'mention'
         )
         if (lastETag) {
           originalEventId = lastETag[1]
-          console.log('[NoteStats] Found reply with last E tag:', evt.id, '->', originalEventId)
         }
       }
       
-      // Also check for parent A tag
       if (!originalEventId) {
         const aTag = evt.tags.find(tagNameEquals('a'))
         if (aTag) {
           originalEventId = aTag[1]
-          console.log('[NoteStats] Found reply with A tag:', evt.id, '->', originalEventId)
         }
       }
     }
 
-    if (!originalEventId) {
-      console.log('[NoteStats] No original event ID found for potential reply:', evt.id, 'tags:', evt.tags)
-      return
-    }
+    if (!originalEventId) return
 
     const old = this.noteStatsMap.get(originalEventId) || {}
     const replyIdSet = old.replyIdSet || new Set()
@@ -459,26 +415,21 @@ class NoteStatsService {
 
     if (replyIdSet.has(evt.id)) return
 
-    // Skip self-interactions - don't count replies from the original event author
     if (originalEventAuthor && originalEventAuthor === evt.pubkey) {
-      logger.debug('[NoteStats] Skipping self-reply from', evt.pubkey, 'to event', originalEventId)
       return
     }
 
     replyIdSet.add(evt.id)
     replies.push({ id: evt.id, pubkey: evt.pubkey, created_at: evt.created_at })
     this.noteStatsMap.set(originalEventId, { ...old, replyIdSet, replies })
-    logger.debug('[NoteStats] Added reply:', evt.id, 'to event:', originalEventId, 'total replies:', replies.length)
     return originalEventId
   }
 
   private isQuoteByEvent(evt: Event): boolean {
-    // A quote has a 'q' tag (quoted event)
     return evt.tags.some(tag => tag[0] === 'q' && tag[1])
   }
 
   private addQuoteByEvent(evt: Event, originalEventAuthor?: string) {
-    // Find the quoted event ID from 'q' tag
     const quotedEventId = evt.tags.find(tag => tag[0] === 'q')?.[1]
     if (!quotedEventId) return
 
@@ -488,9 +439,7 @@ class NoteStatsService {
 
     if (quoteIdSet.has(evt.id)) return
 
-    // Skip self-interactions - don't count quotes from the original event author
     if (originalEventAuthor && originalEventAuthor === evt.pubkey) {
-      // console.log('[NoteStats] Skipping self-quote from', evt.pubkey, 'to event', quotedEventId)
       return
     }
 
@@ -501,7 +450,6 @@ class NoteStatsService {
   }
 
   private addHighlightByEvent(evt: Event, originalEventAuthor?: string) {
-    // Find the event ID from 'e' tag
     const highlightedEventId = evt.tags.find(tag => tag[0] === 'e')?.[1]
     if (!highlightedEventId) return
 
@@ -511,9 +459,7 @@ class NoteStatsService {
 
     if (highlightIdSet.has(evt.id)) return
 
-    // Skip self-interactions - don't count highlights from the original event author
     if (originalEventAuthor && originalEventAuthor === evt.pubkey) {
-      // console.log('[NoteStats] Skipping self-highlight from', evt.pubkey, 'to event', highlightedEventId)
       return
     }
 
@@ -522,20 +468,6 @@ class NoteStatsService {
     this.noteStatsMap.set(highlightedEventId, { ...old, highlightIdSet, highlights })
     return highlightedEventId
   }
-
-  private getEmbeddedNoteBech32Ids(event: Event): string[] {
-    // Simple implementation - in practice, this should match the logic in lib/event.ts
-    const embeddedIds: string[] = []
-    const content = event.content || ''
-    const matches = content.match(/nostr:(note1|nevent1)[a-zA-Z0-9]+/g)
-    if (matches) {
-      matches.forEach(match => {
-        const id = match.replace('nostr:', '')
-        embeddedIds.push(id)
-      })
-    }
-    return embeddedIds
-  }
 }
 
 const instance = new NoteStatsService()