Improves User filters by merging lastEOSEs into a single filter.

app/src/main/java/com/vitorpamplona/amethyst/service/NostrSingleUserDataSource.kt

@@ -12,61 +12,60 @@ import com.vitorpamplona.quartz.events.StatusEvent
 object NostrSingleUserDataSource : NostrDataSource("SingleUserFeed") {
     var usersToWatch = setOf<User>()
 
-    fun createUserFilter(): List<TypedFilter>? {
+    fun createUserMetadataFilter(): List<TypedFilter>? {
         if (usersToWatch.isEmpty()) return null
 
-        return usersToWatch.filter { it.info?.latestMetadata == null }.map {
+        val firstTimers = usersToWatch.filter { it.info?.latestMetadata == null }.map { it.pubkeyHex }
-            TypedFilter(
-                types = COMMON_FEED_TYPES,
-                filter = JsonFilter(
-                    kinds = listOf(MetadataEvent.kind),
-                    authors = listOf(it.pubkeyHex),
-                    limit = 1
-                )
-            )
-        }
-    }
-
-    fun createUserStatusFilter(): List<TypedFilter>? {
-        if (usersToWatch.isEmpty()) return null
-
-        val minLatestEOSEs = mutableMapOf<String, EOSETime>()
-        usersToWatch.forEach {
-            it.latestEOSEs.forEach {
-                val minEose = minLatestEOSEs[it.key]
-                if (minEose == null) {
-                    minLatestEOSEs.put(it.key, EOSETime(it.value.time))
-                } else if (it.value.time < minEose.time) {
-                    minEose.time = it.value.time
-                }
-            }
-        }
 
         return listOf(
             TypedFilter(
                 types = COMMON_FEED_TYPES,
                 filter = JsonFilter(
-                    kinds = listOf(StatusEvent.kind),
+                    kinds = listOf(MetadataEvent.kind, StatusEvent.kind),
-                    authors = usersToWatch.map { it.pubkeyHex },
+                    authors = firstTimers,
-                    since = minLatestEOSEs
+                    limit = 10 * firstTimers.size
                 )
             )
         )
     }
 
-    fun createUserReportFilter(): List<TypedFilter>? {
+    fun createUserMetadataFilter(minLatestEOSEs: Map<String, EOSETime>): TypedFilter? {
         if (usersToWatch.isEmpty()) return null
 
-        return usersToWatch.map {
+        return TypedFilter(
-            TypedFilter(
+            types = COMMON_FEED_TYPES,
-                types = COMMON_FEED_TYPES,
+            filter = JsonFilter(
-                filter = JsonFilter(
+                kinds = listOf(StatusEvent.kind),
-                    kinds = listOf(ReportEvent.kind),
+                authors = usersToWatch.map { it.pubkeyHex },
-                    tags = mapOf("p" to listOf(it.pubkeyHex)),
+                since = minLatestEOSEs
-                    since = it.latestEOSEs
-                )
             )
-        }
+        )
+    }
+
+    fun createUserStatusFilter(minLatestEOSEs: Map<String, EOSETime>): TypedFilter? {
+        if (usersToWatch.isEmpty()) return null
+
+        return TypedFilter(
+            types = COMMON_FEED_TYPES,
+            filter = JsonFilter(
+                kinds = listOf(StatusEvent.kind),
+                authors = usersToWatch.map { it.pubkeyHex },
+                since = minLatestEOSEs
+            )
+        )
+    }
+
+    fun createUserReportFilter(minLatestEOSEs: Map<String, EOSETime>): TypedFilter? {
+        if (usersToWatch.isEmpty()) return null
+
+        return TypedFilter(
+            types = COMMON_FEED_TYPES,
+            filter = JsonFilter(
+                kinds = listOf(ReportEvent.kind),
+                tags = mapOf("p" to usersToWatch.map { it.pubkeyHex }),
+                since = minLatestEOSEs
+            )
+        )
     }
 
     val userChannel = requestNewChannel() { time, relayUrl ->
@@ -80,15 +79,38 @@ object NostrSingleUserDataSource : NostrDataSource("SingleUserFeed") {
         }
     }
 
-    val userChannelOnce = requestNewChannel() { time, relayUrl ->
+    val userChannelFirstTimers = requestNewChannel() { time, relayUrl ->
         // Many relays operate with limits in the amount of filters.
         // As information comes, the filters will be rotated to get more data.
         invalidateFilters()
     }
 
     override fun updateChannelFilters() {
-        userChannel.typedFilters = listOfNotNull(createUserStatusFilter(), createUserReportFilter()).flatten().ifEmpty { null }
+        val minLatestEOSEs = mutableMapOf<String, EOSETime>()
-        userChannelOnce.typedFilters = listOfNotNull(createUserFilter()).flatten().ifEmpty { null }
+        val neverGottenAnEOSE = mutableSetOf<String>()
+        usersToWatch.forEach {
+            if (it.latestEOSEs.isEmpty()) { // first time
+                neverGottenAnEOSE.add(it.pubkeyHex)
+            } else {
+                it.latestEOSEs.forEach {
+                    val minEose = minLatestEOSEs[it.key]
+                    if (minEose == null) {
+                        minLatestEOSEs.put(it.key, EOSETime(it.value.time))
+                    } else if (it.value.time < minEose.time) {
+                        minEose.time = it.value.time
+                    }
+                }
+            }
+        }
+
+        userChannel.typedFilters = listOfNotNull(
+            createUserMetadataFilter(minLatestEOSEs),
+            createUserStatusFilter(minLatestEOSEs),
+            createUserReportFilter(minLatestEOSEs)
+        ).ifEmpty { null }
+        userChannelFirstTimers.typedFilters = listOfNotNull(
+            createUserMetadataFilter()
+        ).flatten().ifEmpty { null }
     }
 
     fun add(user: User) {