Merge branch 'main' into add-ktlint

Conflicts:
	app/src/main/java/com/vitorpamplona/amethyst/model/LocalCache.kt
	app/src/main/java/com/vitorpamplona/amethyst/model/Note.kt
	app/src/main/java/com/vitorpamplona/amethyst/model/ThreadAssembler.kt
	app/src/main/java/com/vitorpamplona/amethyst/service/Nip19.kt
	app/src/main/java/com/vitorpamplona/amethyst/service/NostrUserProfileDataSource.kt
	app/src/main/java/com/vitorpamplona/amethyst/service/model/ATag.kt
	app/src/main/java/com/vitorpamplona/amethyst/service/model/LnZapEvent.kt
	app/src/main/java/com/vitorpamplona/amethyst/service/model/LnZapRequestEvent.kt
	app/src/main/java/com/vitorpamplona/amethyst/service/model/ReactionEvent.kt
	app/src/main/java/com/vitorpamplona/amethyst/service/model/ReportEvent.kt
	app/src/main/java/com/vitorpamplona/amethyst/service/model/RepostEvent.kt
	app/src/main/java/com/vitorpamplona/amethyst/ui/components/ClickableRoute.kt
	app/src/main/java/com/vitorpamplona/amethyst/ui/components/RichTextViewer.kt
	app/src/test/java/com/vitorpamplona/amethyst/NIP19ParserTest.kt

app/src/main/java/com/vitorpamplona/amethyst/model/Note.kt

@@ -6,13 +6,6 @@ import com.vitorpamplona.amethyst.service.model.*
 import com.vitorpamplona.amethyst.service.relays.Relay
 import com.vitorpamplona.amethyst.ui.note.toShortenHex
 import fr.acinq.secp256k1.Hex
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.NonCancellable
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
 import java.math.BigDecimal
 import java.time.Instant
 import java.time.ZoneId
@@ -20,10 +13,18 @@ import java.time.format.DateTimeFormatter
 import java.util.Date
 import java.util.concurrent.atomic.AtomicBoolean
 import java.util.regex.Pattern
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.NonCancellable
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 
 val tagSearch = Pattern.compile("(?:\\s|\\A)\\#\\[([0-9]+)\\]")
 
-class AddressableNote(val address: ATag) : Note(address.toNAddr()) {
+
+class AddressableNote(val address: ATag): Note(address.toTag()) {
     override fun idNote() = address.toNAddr()
     override fun idDisplayNote() = idNote().toShortenHex()
     override fun address() = address
@@ -61,9 +62,9 @@ open class Note(val idHex: String) {
 
     fun channel(): Channel? {
         val channelHex =
-            (event as? ChannelMessageEvent)?.channel()
-                ?: (event as? ChannelMetadataEvent)?.channel()
-                ?: (event as? ChannelCreateEvent)?.let { it.id }
+            (event as? ChannelMessageEvent)?.channel() ?:
+            (event as? ChannelMetadataEvent)?.channel() ?:
+            (event as? ChannelCreateEvent)?.let { it.id }
 
         return channelHex?.let { LocalCache.checkGetOrCreateChannel(it) }
     }
@@ -136,7 +137,7 @@ open class Note(val idHex: String) {
     fun removeReport(deleteNote: Note) {
         val author = deleteNote.author ?: return
 
-        if (author in reports.keys && reports[author]?.contains(deleteNote) == true) {
+        if (author in reports.keys && reports[author]?.contains(deleteNote) == true ) {
             reports[author]?.let {
                 reports = reports + Pair(author, it.minus(deleteNote))
                 liveSet?.reports?.invalidateData()
@@ -155,6 +156,7 @@ open class Note(val idHex: String) {
         }
     }
 
+
     fun addBoost(note: Note) {
         if (note !in boosts) {
             boosts = boosts + note
@@ -238,13 +240,11 @@ open class Note(val idHex: String) {
     }
 
     fun hasAnyReports(): Boolean {
-        val dayAgo = Date().time / 1000 - 24 * 60 * 60
+        val dayAgo = Date().time / 1000 - 24*60*60
         return reports.isNotEmpty() ||
-            (
-                author?.reports?.values?.filter {
-                    it.firstOrNull { (it.createdAt() ?: 0) > dayAgo } != null
-                }?.isNotEmpty() ?: false
-                )
+          (author?.reports?.values?.filter {
+              it.firstOrNull { ( it.createdAt() ?: 0 ) > dayAgo } != null
+          }?.isNotEmpty() ?: false)
     }
 
     fun directlyCiteUsersHex(): Set<HexKey> {
@@ -257,6 +257,7 @@ open class Note(val idHex: String) {
                     returningList.add(tag[1])
                 }
             } catch (e: Exception) {
+
             }
         }
         return returningList
@@ -273,17 +274,18 @@ open class Note(val idHex: String) {
                         returningList.add(it)
                     }
                 }
-            } catch (_: Exception) {
+            } catch (e: Exception) {
+
             }
         }
         return returningList
     }
 
     fun directlyCites(userProfile: User): Boolean {
-        return author == userProfile ||
-            (userProfile in directlyCiteUsers()) ||
-            (event is ReactionEvent && replyTo?.lastOrNull()?.directlyCites(userProfile) == true) ||
-            (event is RepostEvent && replyTo?.lastOrNull()?.directlyCites(userProfile) == true)
+        return author == userProfile
+          || (userProfile in directlyCiteUsers())
+          || (event is ReactionEvent && replyTo?.lastOrNull()?.directlyCites(userProfile) == true)
+          || (event is RepostEvent && replyTo?.lastOrNull()?.directlyCites(userProfile) == true)
     }
 
     fun isNewThread(): Boolean {
@@ -304,7 +306,7 @@ open class Note(val idHex: String) {
 
     fun hasBoostedInTheLast5Minutes(loggedIn: User): Boolean {
         val currentTime = Date().time / 1000
-        return boosts.firstOrNull { it.author == loggedIn && (it.createdAt() ?: 0) > currentTime - (60 * 5) } != null // 5 minute protection
+        return boosts.firstOrNull { it.author == loggedIn && (it.createdAt() ?: 0) > currentTime - (60 * 5)} != null // 5 minute protection
     }
 
     fun boostedBy(loggedIn: User): List<Note> {
@@ -327,6 +329,7 @@ open class Note(val idHex: String) {
     }
 }
 
+
 class NoteLiveSet(u: Note) {
     // Observers line up here.
     val metadata: NoteLiveData = NoteLiveData(u)
@@ -339,17 +342,17 @@ class NoteLiveSet(u: Note) {
     val zaps: NoteLiveData = NoteLiveData(u)
 
     fun isInUse(): Boolean {
-        return metadata.hasObservers() ||
-            reactions.hasObservers() ||
-            boosts.hasObservers() ||
-            replies.hasObservers() ||
-            reports.hasObservers() ||
-            relays.hasObservers() ||
-            zaps.hasObservers()
+        return metadata.hasObservers()
+          || reactions.hasObservers()
+          || boosts.hasObservers()
+          || replies.hasObservers()
+          || reports.hasObservers()
+          || relays.hasObservers()
+          || zaps.hasObservers()
     }
 }
 
-class NoteLiveData(val note: Note) : LiveData<NoteState>(NoteState(note)) {
+class NoteLiveData(val note: Note): LiveData<NoteState>(NoteState(note)) {
     // Refreshes observers in batches.
     var handlerWaiting = AtomicBoolean()
 
@@ -381,6 +384,7 @@ class NoteLiveData(val note: Note) : LiveData<NoteState>(NoteState(note)) {
         } else {
             NostrSingleEventDataSource.add(note)
         }
+
     }
 
     override fun onInactive() {

app/src/main/java/com/vitorpamplona/amethyst/model/ThreadAssembler.kt

@@ -6,72 +6,71 @@ import kotlin.time.measureTimedValue
 
 class ThreadAssembler {
 
-    fun searchRoot(note: Note, testedNotes: MutableSet<Note> = mutableSetOf()): Note? {
-        if (note.replyTo == null || note.replyTo?.isEmpty() == true) return note
+  fun searchRoot(note: Note, testedNotes: MutableSet<Note> = mutableSetOf()): Note? {
+    if (note.replyTo == null || note.replyTo?.isEmpty() == true) return note
 
-        testedNotes.add(note)
+    testedNotes.add(note)
 
-        val markedAsRoot = note.event?.tags()?.firstOrNull { it[0] == "e" && it.size > 3 && it[3] == "root" }?.getOrNull(1)
-        if (markedAsRoot != null) return LocalCache.checkGetOrCreateNote(markedAsRoot)
+    val markedAsRoot = note.event?.tags()?.firstOrNull { it[0] == "e" && it.size > 3 && it[3] == "root" }?.getOrNull(1)
+    if (markedAsRoot != null) return LocalCache.checkGetOrCreateNote(markedAsRoot)
 
-        val hasNoReplyTo = note.replyTo?.firstOrNull { it.replyTo?.isEmpty() == true }
-        if (hasNoReplyTo != null) return hasNoReplyTo
+    val hasNoReplyTo = note.replyTo?.firstOrNull { it.replyTo?.isEmpty() == true }
+    if (hasNoReplyTo != null) return hasNoReplyTo
 
-        // recursive
-        val roots = note.replyTo?.map {
-            if (it !in testedNotes) {
-                searchRoot(it, testedNotes)
-            } else {
-                null
-            }
-        }?.filterNotNull()
+    // recursive
+    val roots = note.replyTo?.map {
+      if (it !in testedNotes)
+        searchRoot(it, testedNotes)
+      else
+        null
+    }?.filterNotNull()
 
-        if (roots != null && roots.isNotEmpty()) {
-            return roots[0]
-        }
-
-        return null
+    if (roots != null && roots.isNotEmpty()) {
+      return roots[0]
     }
 
-    @OptIn(ExperimentalTime::class)
-    fun findThreadFor(noteId: String): Set<Note> {
-        val (result, elapsed) = measureTimedValue {
-            val note = if (noteId.startsWith("naddr")) {
-                val aTag = ATag.parse(noteId)
-                if (aTag != null) {
-                    LocalCache.getOrCreateAddressableNote(aTag)
-                } else {
-                    return emptySet()
-                }
-            } else {
-                LocalCache.getOrCreateNote(noteId)
-            }
+    return null
+  }
 
-            if (note.event != null) {
-                val thread = mutableSetOf<Note>()
+  @OptIn(ExperimentalTime::class)
+  fun findThreadFor(noteId: String): Set<Note> {
+    val (result, elapsed) = measureTimedValue {
+      val note = if (noteId.contains(":")) {
+        val aTag = ATag.parse(noteId, null)
+        if (aTag != null)
+          LocalCache.getOrCreateAddressableNote(aTag)
+        else
+          return emptySet()
+      } else {
+        LocalCache.getOrCreateNote(noteId)
+      }
 
-                val threadRoot = searchRoot(note, thread) ?: note
 
-                loadDown(threadRoot, thread)
+      if (note.event != null) {
+        val thread = mutableSetOf<Note>()
 
-                thread.toSet()
-            } else {
-                setOf(note)
-            }
-        }
+        val threadRoot = searchRoot(note, thread) ?: note
 
-        println("Model Refresh: Thread loaded in $elapsed")
+        loadDown(threadRoot, thread)
 
-        return result
+        thread.toSet()
+      } else {
+        setOf(note)
+      }
     }
 
-    fun loadDown(note: Note, thread: MutableSet<Note>) {
-        if (note !in thread) {
-            thread.add(note)
+    println("Model Refresh: Thread loaded in ${elapsed}")
 
-            note.replies.forEach {
-                loadDown(it, thread)
-            }
-        }
+    return result
+  }
+
+  fun loadDown(note: Note, thread: MutableSet<Note>) {
+    if (note !in thread) {
+      thread.add(note)
+
+      note.replies.forEach {
+        loadDown(it, thread)
+      }
     }
+  }
 }

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

@@ -7,122 +7,132 @@ import java.nio.ByteOrder
 
 class Nip19 {
 
-    enum class Type {
-        USER, NOTE, RELAY, ADDRESS
+  enum class Type {
+    USER, NOTE, RELAY, ADDRESS
+  }
+
+  data class Return(val type: Type, val hex: String, val relay: String?)
+
+  fun uriToRoute(uri: String?): Return? {
+    try {
+      val key = uri?.removePrefix("nostr:") ?: return null
+
+      val bytes = key.bechToBytes()
+      if (key.startsWith("npub")) {
+        return npub(bytes)
+      } else if (key.startsWith("note")) {
+        return note(bytes)
+      } else if (key.startsWith("nprofile")) {
+        return nprofile(bytes)
+      } else if (key.startsWith("nevent")) {
+        return nevent(bytes)
+      } else if (key.startsWith("nrelay")) {
+        return nrelay(bytes)
+      } else if (key.startsWith("naddr")) {
+        return naddr(bytes)
+      }
+    } catch (e: Throwable) {
+      println("Issue trying to Decode NIP19 ${uri}: ${e.message}")
     }
 
-    data class Return(val type: Type, val hex: String)
+    return null
+  }
 
-    fun uriToRoute(uri: String?): Return? {
-        try {
-            val key = uri?.removePrefix("nostr:") ?: return null
+  private fun npub(bytes: ByteArray): Return {
+    return Return(Type.USER, bytes.toHexKey(), null)
+  }
 
-            val bytes = key.bechToBytes()
-            if (key.startsWith("npub")) {
-                return npub(bytes)
-            } else if (key.startsWith("note")) {
-                return note(bytes)
-            } else if (key.startsWith("nprofile")) {
-                return nprofile(bytes)
-            } else if (key.startsWith("nevent")) {
-                return nevent(bytes)
-            } else if (key.startsWith("nrelay")) {
-                return nrelay(bytes)
-            } else if (key.startsWith("naddr")) {
-                return naddr(bytes)
-            }
-        } catch (e: Throwable) {
-            println("Issue trying to Decode NIP19 $uri: ${e.message}")
-        }
+  private fun note(bytes: ByteArray): Return {
+    return Return(Type.NOTE, bytes.toHexKey(), null);
+  }
 
-        return null
-    }
+  private fun nprofile(bytes: ByteArray): Return? {
+    val tlv = parseTLV(bytes)
 
-    private fun npub(bytes: ByteArray): Return {
-        return Return(Type.USER, bytes.toHexKey())
-    }
+    val hex = tlv.get(NIP19TLVTypes.SPECIAL.id)
+      ?.get(0)
+      ?.toHexKey() ?: return null
 
-    private fun note(bytes: ByteArray): Return {
-        return Return(Type.NOTE, bytes.toHexKey())
-    }
+    val relay = tlv.get(NIP19TLVTypes.RELAY.id)
+      ?.get(0)
+      ?.toString(Charsets.UTF_8)
 
-    private fun nprofile(bytes: ByteArray): Return? {
-        val hex = parseTLV(bytes)
-            .get(NIP19TLVTypes.SPECIAL.id)
-            ?.get(0)
-            ?.toHexKey() ?: return null
+    return Return(Type.USER, hex, relay)
+  }
 
-        return Return(Type.USER, hex)
-    }
+  private fun nevent(bytes: ByteArray): Return? {
+    val tlv = parseTLV(bytes)
 
-    private fun nevent(bytes: ByteArray): Return? {
-        val hex = parseTLV(bytes)
-            .get(NIP19TLVTypes.SPECIAL.id)
-            ?.get(0)
-            ?.toHexKey() ?: return null
+    val hex = tlv.get(NIP19TLVTypes.SPECIAL.id)
+      ?.get(0)
+      ?.toHexKey() ?: return null
 
-        return Return(Type.USER, hex)
-    }
+    val relay = tlv.get(NIP19TLVTypes.RELAY.id)
+      ?.get(0)
+      ?.toString(Charsets.UTF_8)
 
-    private fun nrelay(bytes: ByteArray): Return? {
-        val relayUrl = parseTLV(bytes)
-            .get(NIP19TLVTypes.SPECIAL.id)
-            ?.get(0)
-            ?.toString(Charsets.UTF_8) ?: return null
+    return Return(Type.USER, hex, relay)
+  }
 
-        return Return(Type.RELAY, relayUrl)
-    }
+  private fun nrelay(bytes: ByteArray): Return? {
+    val relayUrl = parseTLV(bytes)
+      .get(NIP19TLVTypes.SPECIAL.id)
+      ?.get(0)
+      ?.toString(Charsets.UTF_8) ?: return null
 
-    private fun naddr(bytes: ByteArray): Return? {
-        val tlv = parseTLV(bytes)
+    return Return(Type.RELAY, relayUrl, null)
+  }
 
-        val d = tlv.get(NIP19TLVTypes.SPECIAL.id)
-            ?.get(0)
-            ?.toString(Charsets.UTF_8) ?: return null
+  private fun naddr(bytes: ByteArray): Return? {
+    val tlv = parseTLV(bytes)
 
-        val relay = tlv.get(NIP19TLVTypes.RELAY.id)
-            ?.get(0)
-            ?.toString(Charsets.UTF_8)
+    val d = tlv.get(NIP19TLVTypes.SPECIAL.id)
+      ?.get(0)
+      ?.toString(Charsets.UTF_8) ?: return null
 
-        val author = tlv.get(NIP19TLVTypes.AUTHOR.id)
-            ?.get(0)
-            ?.toHexKey()
+    val relay = tlv.get(NIP19TLVTypes.RELAY.id)
+      ?.get(0)
+      ?.toString(Charsets.UTF_8)
 
-        val kind = tlv.get(NIP19TLVTypes.KIND.id)
-            ?.get(0)
-            ?.let { toInt32(it) }
+    val author = tlv.get(NIP19TLVTypes.AUTHOR.id)
+      ?.get(0)
+      ?.toHexKey()
 
-        return Return(Type.ADDRESS, "$kind:$author:$d")
-    }
+    val kind = tlv.get(NIP19TLVTypes.KIND.id)
+      ?.get(0)
+      ?.let { toInt32(it) }
+
+    return Return(Type.ADDRESS, "$kind:$author:$d", relay)
+  }
 }
 
 // Classes should start with an uppercase letter in kotlin
 enum class NIP19TLVTypes(val id: Byte) {
-    SPECIAL(0),
-    RELAY(1),
-    AUTHOR(2),
-    KIND(3);
+  SPECIAL(0),
+  RELAY(1),
+  AUTHOR(2),
+  KIND(3);
 }
 
 fun toInt32(bytes: ByteArray): Int {
-    require(bytes.size == 4) { "length must be 4, got: ${bytes.size}" }
-    return ByteBuffer.wrap(bytes, 0, 4).order(ByteOrder.BIG_ENDIAN).int
+  require(bytes.size == 4) { "length must be 4, got: ${bytes.size}" }
+  return ByteBuffer.wrap(bytes, 0, 4).order(ByteOrder.BIG_ENDIAN).int
 }
 
 fun parseTLV(data: ByteArray): Map<Byte, List<ByteArray>> {
-    val result = mutableMapOf<Byte, MutableList<ByteArray>>()
-    var rest = data
-    while (rest.isNotEmpty()) {
-        val t = rest[0]
-        val l = rest[1]
-        val v = rest.sliceArray(IntRange(2, (2 + l) - 1))
-        rest = rest.sliceArray(IntRange(2 + l, rest.size - 1))
-        if (v.size < l) continue
+  val result = mutableMapOf<Byte, MutableList<ByteArray>>()
+  var rest = data
+  while (rest.isNotEmpty()) {
+    val t = rest[0]
+    val l = rest[1]
+    val v = rest.sliceArray(IntRange(2, (2 + l) - 1))
+    rest = rest.sliceArray(IntRange(2 + l, rest.size - 1))
+    if (v.size < l) continue
 
-        if (!result.containsKey(t)) {
-            result[t] = mutableListOf()
-        }
-        result[t]?.add(v)
+    if (!result.containsKey(t)) {
+      result[t] = mutableListOf()
     }
-    return result
+    result[t]?.add(v)
+  }
+  return result
 }

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

@@ -4,114 +4,114 @@ import com.vitorpamplona.amethyst.model.LocalCache
 import com.vitorpamplona.amethyst.model.User
 import com.vitorpamplona.amethyst.service.model.BadgeAwardEvent
 import com.vitorpamplona.amethyst.service.model.BadgeProfilesEvent
-import com.vitorpamplona.amethyst.service.model.ContactListEvent
 import com.vitorpamplona.amethyst.service.model.LnZapEvent
 import com.vitorpamplona.amethyst.service.model.LongTextNoteEvent
+import com.vitorpamplona.amethyst.service.relays.FeedType
+import com.vitorpamplona.amethyst.service.relays.TypedFilter
+import com.vitorpamplona.amethyst.service.relays.JsonFilter
+import com.vitorpamplona.amethyst.service.model.ContactListEvent
 import com.vitorpamplona.amethyst.service.model.MetadataEvent
 import com.vitorpamplona.amethyst.service.model.TextNoteEvent
-import com.vitorpamplona.amethyst.service.relays.FeedType
-import com.vitorpamplona.amethyst.service.relays.JsonFilter
-import com.vitorpamplona.amethyst.service.relays.TypedFilter
 
-object NostrUserProfileDataSource : NostrDataSource("UserProfileFeed") {
-    var user: User? = null
+object NostrUserProfileDataSource: NostrDataSource("UserProfileFeed") {
+  var user: User? = null
 
-    fun loadUserProfile(userId: String?) {
-        if (userId != null) {
-            user = LocalCache.getOrCreateUser(userId)
-        } else {
-            user = null
-        }
-
-        resetFilters()
+  fun loadUserProfile(userId: String?) {
+    if (userId != null) {
+      user = LocalCache.getOrCreateUser(userId)
+    } else {
+      user = null
     }
 
-    fun createUserInfoFilter() = user?.let {
-        TypedFilter(
-            types = FeedType.values().toSet(),
-            filter = JsonFilter(
-                kinds = listOf(MetadataEvent.kind),
-                authors = listOf(it.pubkeyHex),
-                limit = 1
-            )
-        )
-    }
+    resetFilters()
+  }
 
-    fun createUserPostsFilter() = user?.let {
-        TypedFilter(
-            types = FeedType.values().toSet(),
-            filter = JsonFilter(
-                kinds = listOf(TextNoteEvent.kind, LongTextNoteEvent.kind),
-                authors = listOf(it.pubkeyHex),
-                limit = 200
-            )
-        )
-    }
+  fun createUserInfoFilter() = user?.let {
+    TypedFilter(
+      types = FeedType.values().toSet(),
+      filter = JsonFilter(
+        kinds = listOf(MetadataEvent.kind),
+        authors = listOf(it.pubkeyHex),
+        limit = 1
+      )
+    )
+  }
 
-    fun createUserReceivedZapsFilter() = user?.let {
-        TypedFilter(
-            types = FeedType.values().toSet(),
-            filter = JsonFilter(
-                kinds = listOf(LnZapEvent.kind),
-                tags = mapOf("p" to listOf(it.pubkeyHex))
-            )
-        )
-    }
+  fun createUserPostsFilter() = user?.let {
+    TypedFilter(
+      types = FeedType.values().toSet(),
+      filter = JsonFilter(
+        kinds = listOf(TextNoteEvent.kind, LongTextNoteEvent.kind),
+        authors = listOf(it.pubkeyHex),
+        limit = 200
+      )
+    )
+  }
 
-    fun createFollowFilter() = user?.let {
-        TypedFilter(
-            types = FeedType.values().toSet(),
-            filter = JsonFilter(
-                kinds = listOf(ContactListEvent.kind),
-                authors = listOf(it.pubkeyHex),
-                limit = 1
-            )
-        )
-    }
+  fun createUserReceivedZapsFilter() = user?.let {
+    TypedFilter(
+      types = FeedType.values().toSet(),
+      filter = JsonFilter(
+        kinds = listOf(LnZapEvent.kind),
+        tags = mapOf("p" to listOf(it.pubkeyHex))
+      )
+    )
+  }
 
-    fun createFollowersFilter() = user?.let {
-        TypedFilter(
-            types = FeedType.values().toSet(),
-            filter = JsonFilter(
-                kinds = listOf(ContactListEvent.kind),
-                tags = mapOf("p" to listOf(it.pubkeyHex))
-            )
-        )
-    }
+  fun createFollowFilter() = user?.let {
+    TypedFilter(
+      types = FeedType.values().toSet(),
+      filter = JsonFilter(
+        kinds = listOf(ContactListEvent.kind),
+        authors = listOf(it.pubkeyHex),
+        limit = 1
+      )
+    )
+  }
 
-    fun createAcceptedAwardsFilter() = user?.let {
-        TypedFilter(
-            types = FeedType.values().toSet(),
-            filter = JsonFilter(
-                kinds = listOf(BadgeProfilesEvent.kind),
-                tags = mapOf("p" to listOf(it.pubkeyHex)),
-                limit = 1
-            )
-        )
-    }
+  fun createFollowersFilter() = user?.let {
+    TypedFilter(
+      types = FeedType.values().toSet(),
+      filter = JsonFilter(
+        kinds = listOf(ContactListEvent.kind),
+        tags = mapOf("p" to listOf(it.pubkeyHex))
+      )
+    )
+  }
 
-    fun createReceivedAwardsFilter() = user?.let {
-        TypedFilter(
-            types = FeedType.values().toSet(),
-            filter = JsonFilter(
-                kinds = listOf(BadgeAwardEvent.kind),
-                tags = mapOf("p" to listOf(it.pubkeyHex)),
-                limit = 20
-            )
-        )
-    }
+  fun createAcceptedAwardsFilter() = user?.let {
+    TypedFilter(
+      types = FeedType.values().toSet(),
+      filter = JsonFilter(
+        kinds = listOf(BadgeProfilesEvent.kind),
+        authors = listOf(it.pubkeyHex),
+        limit = 1
+      )
+    )
+  }
 
-    val userInfoChannel = requestNewChannel()
+  fun createReceivedAwardsFilter() = user?.let {
+    TypedFilter(
+      types = FeedType.values().toSet(),
+      filter = JsonFilter(
+        kinds = listOf(BadgeAwardEvent.kind),
+        tags = mapOf("p" to listOf(it.pubkeyHex)),
+        limit = 20
+      )
+    )
+  }
 
-    override fun updateChannelFilters() {
-        userInfoChannel.typedFilters = listOfNotNull(
-            createUserInfoFilter(),
-            createUserPostsFilter(),
-            createFollowFilter(),
-            createFollowersFilter(),
-            createUserReceivedZapsFilter(),
-            createAcceptedAwardsFilter(),
-            createReceivedAwardsFilter()
-        ).ifEmpty { null }
-    }
-}
+  val userInfoChannel = requestNewChannel()
+
+  override fun updateChannelFilters() {
+    userInfoChannel.typedFilters = listOfNotNull(
+      createUserInfoFilter(),
+      createUserPostsFilter(),
+      createFollowFilter(),
+      createFollowersFilter(),
+      createUserReceivedZapsFilter(),
+      createAcceptedAwardsFilter(),
+      createReceivedAwardsFilter()
+    ).ifEmpty { null }
+  }
+}

app/src/main/java/com/vitorpamplona/amethyst/service/model/ATag.kt

@@ -11,38 +11,47 @@ import nostr.postr.Bech32
 import nostr.postr.bechToBytes
 import nostr.postr.toByteArray
 
-data class ATag(val kind: Int, val pubKeyHex: String, val dTag: String) {
+data class ATag(val kind: Int, val pubKeyHex: String, val dTag: String, val relay: String?) {
     fun toTag() = "$kind:$pubKeyHex:$dTag"
 
     fun toNAddr(): String {
         val kind = kind.toByteArray()
-        val addr = pubKeyHex.toByteArray()
+        val author = pubKeyHex.toByteArray()
         val dTag = dTag.toByteArray(Charsets.UTF_8)
+        val relay = relay?.toByteArray(Charsets.UTF_8)
 
-        val fullArray =
-            byteArrayOf(NIP19TLVTypes.SPECIAL.id, dTag.size.toByte()) + dTag +
-                byteArrayOf(NIP19TLVTypes.AUTHOR.id, addr.size.toByte()) + addr +
-                byteArrayOf(NIP19TLVTypes.KIND.id, kind.size.toByte()) + kind
+        var fullArray =
+            byteArrayOf(NIP19TLVTypes.SPECIAL.id, dTag.size.toByte()) + dTag
+
+        if (relay != null)
+            fullArray = fullArray + byteArrayOf(NIP19TLVTypes.RELAY.id, relay.size.toByte()) + relay
+
+        fullArray = fullArray +
+            byteArrayOf(NIP19TLVTypes.AUTHOR.id, author.size.toByte()) + author +
+            byteArrayOf(NIP19TLVTypes.KIND.id, kind.size.toByte()) + kind
 
         return Bech32.encodeBytes(hrp = "naddr", fullArray, Bech32.Encoding.Bech32)
     }
 
     companion object {
-        fun parse(address: String): ATag? {
-            return if (address.startsWith("naddr") || address.startsWith("nostr:naddr")) {
-                parseNAddr(address)
-            } else {
-                parseAtag(address)
-            }
+        fun isATag(key: String): Boolean {
+            return key.startsWith("naddr1") || key.contains(":")
         }
 
-        fun parseAtag(atag: String): ATag? {
+        fun parse(address: String, relay: String?): ATag? {
+            return if (address.startsWith("naddr") || address.startsWith("nostr:naddr"))
+                parseNAddr(address)
+            else
+                parseAtag(address, relay)
+        }
+
+        fun parseAtag(atag: String, relay: String?): ATag? {
             return try {
                 val parts = atag.split(":")
-                Hex.decode(parts[1])
-                ATag(parts[0].toInt(), parts[1], parts[2])
+              Hex.decode(parts[1])
+              ATag(parts[0].toInt(), parts[1], parts[2], relay)
             } catch (t: Throwable) {
-                Log.w("ATag", "Error parsing A Tag: $atag: ${t.message}")
+              Log.w("ATag",  "Error parsing A Tag: ${atag}: ${t.message}")
                 null
             }
         }
@@ -58,16 +67,16 @@ data class ATag(val kind: Int, val pubKeyHex: String, val dTag: String) {
                     val author = tlv.get(NIP19TLVTypes.AUTHOR.id)?.get(0)?.toHexKey()
                     val kind = tlv.get(NIP19TLVTypes.KIND.id)?.get(0)?.let { toInt32(it) }
 
-                    if (kind != null && author != null) {
-                        return ATag(kind, author, d)
-                    }
+                    if (kind != null && author != null)
+                        return ATag(kind, author, d, relay)
                 }
+
             } catch (e: Throwable) {
-                Log.w("ATag", "Issue trying to Decode NIP19 $this: ${e.message}")
-                // e.printStackTrace()
+                Log.w( "ATag", "Issue trying to Decode NIP19 ${this}: ${e.message}")
+                //e.printStackTrace()
             }
 
             return null
         }
     }
-}
+}

app/src/main/java/com/vitorpamplona/amethyst/service/model/BadgeAwardEvent.kt

@@ -11,7 +11,12 @@ class BadgeAwardEvent(
     sig: HexKey
 ) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
     fun awardees() = tags.filter { it.firstOrNull() == "p" }.mapNotNull { it.getOrNull(1) }
-    fun awardDefinition() = tags.filter { it.firstOrNull() == "a" }.mapNotNull { it.getOrNull(1) }.mapNotNull { ATag.parse(it) }
+    fun awardDefinition() = tags.filter { it.firstOrNull() == "a" }.mapNotNull {
+        val aTagValue = it.getOrNull(1)
+        val relay = it.getOrNull(2)
+
+        if (aTagValue != null) ATag.parse(aTagValue, relay) else null
+    }
 
     companion object {
         const val kind = 8

app/src/main/java/com/vitorpamplona/amethyst/service/model/BadgeDefinitionEvent.kt

@@ -11,7 +11,7 @@ class BadgeDefinitionEvent(
     sig: HexKey
 ) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
     fun dTag() = tags.filter { it.firstOrNull() == "d" }.mapNotNull { it.getOrNull(1) }.firstOrNull() ?: ""
-    fun address() = ATag(kind, pubKey, dTag())
+    fun address() = ATag(kind, pubKey, dTag(), null)
 
     fun name() = tags.filter { it.firstOrNull() == "name" }.mapNotNull { it.getOrNull(1) }.firstOrNull()
     fun thumb() = tags.filter { it.firstOrNull() == "thumb" }.mapNotNull { it.getOrNull(1) }.firstOrNull()

app/src/main/java/com/vitorpamplona/amethyst/service/model/BadgeProfilesEvent.kt

@@ -11,10 +11,15 @@ class BadgeProfilesEvent(
     sig: HexKey
 ) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
     fun badgeAwardEvents() = tags.filter { it.firstOrNull() == "e" }.mapNotNull { it.getOrNull(1) }
-    fun badgeAwardDefinitions() = tags.filter { it.firstOrNull() == "a" }.mapNotNull { it.getOrNull(1) }.mapNotNull { ATag.parse(it) }
+    fun badgeAwardDefinitions() = tags.filter { it.firstOrNull() == "a" }.mapNotNull {
+        val aTagValue = it.getOrNull(1)
+        val relay = it.getOrNull(2)
+
+        if (aTagValue != null) ATag.parse(aTagValue, relay) else null
+    }
 
     fun dTag() = tags.filter { it.firstOrNull() == "d" }.mapNotNull { it.getOrNull(1) }.firstOrNull() ?: ""
-    fun address() = ATag(kind, pubKey, dTag())
+    fun address() = ATag(kind, pubKey, dTag(), null)
 
     companion object {
         const val kind = 30008

app/src/main/java/com/vitorpamplona/amethyst/service/model/LnZapEvent.kt

@@ -6,53 +6,57 @@ import com.vitorpamplona.amethyst.service.relays.Client
 import java.math.BigDecimal
 
 class LnZapEvent(
-    id: HexKey,
-    pubKey: HexKey,
-    createdAt: Long,
-    tags: List<List<String>>,
-    content: String,
-    sig: HexKey
-) : LnZapEventInterface, Event(id, pubKey, createdAt, kind, tags, content, sig) {
+  id: HexKey,
+  pubKey: HexKey,
+  createdAt: Long,
+  tags: List<List<String>>,
+  content: String,
+  sig: HexKey
+): LnZapEventInterface, Event(id, pubKey, createdAt, kind, tags, content, sig) {
 
-    override fun zappedPost() = tags
-        .filter { it.firstOrNull() == "e" }
-        .mapNotNull { it.getOrNull(1) }
+  override fun zappedPost() = tags
+    .filter { it.firstOrNull() == "e" }
+    .mapNotNull { it.getOrNull(1) }
 
-    override fun zappedAuthor() = tags
-        .filter { it.firstOrNull() == "p" }
-        .mapNotNull { it.getOrNull(1) }
+  override fun zappedAuthor() = tags
+    .filter { it.firstOrNull() == "p" }
+    .mapNotNull { it.getOrNull(1) }
 
-    override fun taggedAddresses(): List<ATag> = tags
-        .filter { it.firstOrNull() == "a" }
-        .mapNotNull { it.getOrNull(1) }
-        .mapNotNull { ATag.parse(it) }
+  override fun taggedAddresses(): List<ATag> = tags
+    .filter { it.firstOrNull() == "a" }
+    .mapNotNull {
+      val aTagValue = it.getOrNull(1)
+      val relay = it.getOrNull(2)
 
-    override fun amount(): BigDecimal? {
-        return lnInvoice()?.let { LnInvoiceUtil.getAmountInSats(it) }
+      if (aTagValue != null) ATag.parse(aTagValue, relay) else null
     }
 
-    // Keeps this as a field because it's a heavier function used everywhere.
-    val amount = lnInvoice()?.let { LnInvoiceUtil.getAmountInSats(it) }
+  override fun amount(): BigDecimal? {
+    return lnInvoice()?.let { LnInvoiceUtil.getAmountInSats(it) }
+  }
 
-    override fun containedPost(): Event? = try {
-        description()?.let {
-            fromJson(it, Client.lenient)
-        }
-    } catch (e: Exception) {
-        null
+  // Keeps this as a field because it's a heavier function used everywhere.
+  val amount = lnInvoice()?.let { LnInvoiceUtil.getAmountInSats(it) }
+
+  override fun containedPost(): Event? = try {
+    description()?.let {
+      fromJson(it, Client.lenient)
     }
+  } catch (e: Exception) {
+    null
+  }
 
-    private fun lnInvoice(): String? = tags
-        .filter { it.firstOrNull() == "bolt11" }
-        .mapNotNull { it.getOrNull(1) }
-        .firstOrNull()
+  private fun lnInvoice(): String? = tags
+    .filter { it.firstOrNull() == "bolt11" }
+    .mapNotNull { it.getOrNull(1) }
+    .firstOrNull()
 
-    private fun description(): String? = tags
-        .filter { it.firstOrNull() == "description" }
-        .mapNotNull { it.getOrNull(1) }
-        .firstOrNull()
+  private fun description(): String? = tags
+    .filter { it.firstOrNull() == "description" }
+    .mapNotNull { it.getOrNull(1) }
+    .firstOrNull()
 
-    companion object {
-        const val kind = 9735
-    }
+  companion object {
+    const val kind = 9735
+  }
 }

app/src/main/java/com/vitorpamplona/amethyst/service/model/LnZapRequestEvent.kt

@@ -2,53 +2,59 @@ package com.vitorpamplona.amethyst.service.model
 
 import com.vitorpamplona.amethyst.model.HexKey
 import com.vitorpamplona.amethyst.model.toHexKey
-import nostr.postr.Utils
 import java.util.Date
+import nostr.postr.Utils
+import nostr.postr.toHex
 
-class LnZapRequestEvent(
-    id: HexKey,
-    pubKey: HexKey,
-    createdAt: Long,
-    tags: List<List<String>>,
-    content: String,
-    sig: HexKey
-) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
-    fun zappedPost() = tags.filter { it.firstOrNull() == "e" }.mapNotNull { it.getOrNull(1) }
-    fun zappedAuthor() = tags.filter { it.firstOrNull() == "p" }.mapNotNull { it.getOrNull(1) }
-    fun taggedAddresses() = tags.filter { it.firstOrNull() == "a" }.mapNotNull { it.getOrNull(1) }.mapNotNull { ATag.parse(it) }
+class LnZapRequestEvent (
+  id: HexKey,
+  pubKey: HexKey,
+  createdAt: Long,
+  tags: List<List<String>>,
+  content: String,
+  sig: HexKey
+): Event(id, pubKey, createdAt, kind, tags, content, sig) {
+  fun zappedPost() = tags.filter { it.firstOrNull() == "e" }.mapNotNull { it.getOrNull(1) }
+  fun zappedAuthor() = tags.filter { it.firstOrNull() == "p" }.mapNotNull { it.getOrNull(1) }
+  fun taggedAddresses() = tags.filter { it.firstOrNull() == "a" }.mapNotNull {
+    val aTagValue = it.getOrNull(1)
+    val relay = it.getOrNull(2)
 
-    companion object {
-        const val kind = 9734
+    if (aTagValue != null) ATag.parse(aTagValue, relay) else null
+  }
 
-        fun create(originalNote: EventInterface, relays: Set<String>, privateKey: ByteArray, createdAt: Long = Date().time / 1000): LnZapRequestEvent {
-            val content = ""
-            val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
-            var tags = listOf(
-                listOf("e", originalNote.id()),
-                listOf("p", originalNote.pubKey()),
-                listOf("relays") + relays
-            )
-            if (originalNote is LongTextNoteEvent) {
-                tags = tags + listOf(listOf("a", originalNote.address().toTag()))
-            }
+  companion object {
+    const val kind = 9734
 
-            val id = generateId(pubKey, createdAt, kind, tags, content)
-            val sig = Utils.sign(id, privateKey)
-            return LnZapRequestEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
-        }
+    fun create(originalNote: EventInterface, relays: Set<String>, privateKey: ByteArray, createdAt: Long = Date().time / 1000): LnZapRequestEvent {
+      val content = ""
+      val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
+      var tags = listOf(
+        listOf("e", originalNote.id()),
+        listOf("p", originalNote.pubKey()),
+        listOf("relays") + relays
+      )
+      if (originalNote is LongTextNoteEvent) {
+        tags = tags + listOf( listOf("a", originalNote.address().toTag()) )
+      }
 
-        fun create(userHex: String, relays: Set<String>, privateKey: ByteArray, createdAt: Long = Date().time / 1000): LnZapRequestEvent {
-            val content = ""
-            val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
-            val tags = listOf(
-                listOf("p", userHex),
-                listOf("relays") + relays
-            )
-            val id = generateId(pubKey, createdAt, kind, tags, content)
-            val sig = Utils.sign(id, privateKey)
-            return LnZapRequestEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
-        }
+      val id = generateId(pubKey, createdAt, kind, tags, content)
+      val sig = Utils.sign(id, privateKey)
+      return LnZapRequestEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
     }
+
+    fun create(userHex: String, relays: Set<String>, privateKey: ByteArray, createdAt: Long = Date().time / 1000): LnZapRequestEvent {
+      val content = ""
+      val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
+      val tags = listOf(
+        listOf("p", userHex),
+        listOf("relays") + relays
+      )
+      val id = generateId(pubKey, createdAt, kind, tags, content)
+      val sig = Utils.sign(id, privateKey)
+      return LnZapRequestEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
+    }
+  }
 }
 
 /*

app/src/main/java/com/vitorpamplona/amethyst/service/model/LongTextNoteEvent.kt

@@ -17,7 +17,7 @@ class LongTextNoteEvent(
     fun mentions() = tags.filter { it.firstOrNull() == "p" }.mapNotNull { it.getOrNull(1) }
 
     fun dTag() = tags.filter { it.firstOrNull() == "d" }.mapNotNull { it.getOrNull(1) }.firstOrNull() ?: ""
-    fun address() = ATag(kind, pubKey, dTag())
+    fun address() = ATag(kind, pubKey, dTag(), null)
 
     fun topics() = tags.filter { it.firstOrNull() == "t" }.mapNotNull { it.getOrNull(1) }
     fun title() = tags.filter { it.firstOrNull() == "title" }.mapNotNull { it.getOrNull(1) }.firstOrNull()

app/src/main/java/com/vitorpamplona/amethyst/service/model/ReactionEvent.kt

@@ -2,44 +2,50 @@ package com.vitorpamplona.amethyst.service.model
 
 import com.vitorpamplona.amethyst.model.HexKey
 import com.vitorpamplona.amethyst.model.toHexKey
-import nostr.postr.Utils
 import java.util.Date
+import nostr.postr.Utils
+import nostr.postr.toHex
 
-class ReactionEvent(
-    id: HexKey,
-    pubKey: HexKey,
-    createdAt: Long,
-    tags: List<List<String>>,
-    content: String,
-    sig: HexKey
-) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
+class ReactionEvent (
+  id: HexKey,
+  pubKey: HexKey,
+  createdAt: Long,
+  tags: List<List<String>>,
+  content: String,
+  sig: HexKey
+): Event(id, pubKey, createdAt, kind, tags, content, sig) {
 
-    fun originalPost() = tags.filter { it.firstOrNull() == "e" }.mapNotNull { it.getOrNull(1) }
-    fun originalAuthor() = tags.filter { it.firstOrNull() == "p" }.mapNotNull { it.getOrNull(1) }
-    fun taggedAddresses() = tags.filter { it.firstOrNull() == "a" }.mapNotNull { it.getOrNull(1) }.mapNotNull { ATag.parse(it) }
+  fun originalPost() = tags.filter { it.firstOrNull() == "e" }.mapNotNull { it.getOrNull(1) }
+  fun originalAuthor() = tags.filter { it.firstOrNull() == "p" }.mapNotNull { it.getOrNull(1) }
+  fun taggedAddresses() = tags.filter { it.firstOrNull() == "a" }.mapNotNull {
+    val aTagValue = it.getOrNull(1)
+    val relay = it.getOrNull(2)
 
-    companion object {
-        const val kind = 7
+    if (aTagValue != null) ATag.parse(aTagValue, relay) else null
+  }
 
-        fun createWarning(originalNote: EventInterface, privateKey: ByteArray, createdAt: Long = Date().time / 1000): ReactionEvent {
-            return create("\u26A0\uFE0F", originalNote, privateKey, createdAt)
-        }
+  companion object {
+    const val kind = 7
 
-        fun createLike(originalNote: EventInterface, privateKey: ByteArray, createdAt: Long = Date().time / 1000): ReactionEvent {
-            return create("+", originalNote, privateKey, createdAt)
-        }
-
-        fun create(content: String, originalNote: EventInterface, privateKey: ByteArray, createdAt: Long = Date().time / 1000): ReactionEvent {
-            val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
-
-            var tags = listOf(listOf("e", originalNote.id()), listOf("p", originalNote.pubKey()))
-            if (originalNote is LongTextNoteEvent) {
-                tags = tags + listOf(listOf("a", originalNote.address().toTag()))
-            }
-
-            val id = generateId(pubKey, createdAt, kind, tags, content)
-            val sig = Utils.sign(id, privateKey)
-            return ReactionEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
-        }
+    fun createWarning(originalNote: EventInterface, privateKey: ByteArray, createdAt: Long = Date().time / 1000): ReactionEvent {
+      return create("\u26A0\uFE0F", originalNote, privateKey, createdAt)
     }
+
+    fun createLike(originalNote: EventInterface, privateKey: ByteArray, createdAt: Long = Date().time / 1000): ReactionEvent {
+      return create("+", originalNote, privateKey, createdAt)
+    }
+
+    fun create(content: String, originalNote: EventInterface, privateKey: ByteArray, createdAt: Long = Date().time / 1000): ReactionEvent {
+      val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
+
+      var tags = listOf( listOf("e", originalNote.id()), listOf("p", originalNote.pubKey()))
+      if (originalNote is LongTextNoteEvent) {
+        tags = tags + listOf( listOf("a", originalNote.address().toTag()) )
+      }
+
+      val id = generateId(pubKey, createdAt, kind, tags, content)
+      val sig = Utils.sign(id, privateKey)
+      return ReactionEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
+    }
+  }
 }

app/src/main/java/com/vitorpamplona/amethyst/service/model/ReportEvent.kt

@@ -2,93 +2,99 @@ package com.vitorpamplona.amethyst.service.model
 
 import com.vitorpamplona.amethyst.model.HexKey
 import com.vitorpamplona.amethyst.model.toHexKey
-import nostr.postr.Utils
 import java.util.Date
+import nostr.postr.Utils
+import nostr.postr.toHex
 
 data class ReportedKey(val key: String, val reportType: ReportEvent.ReportType)
 
 // NIP 56 event.
-class ReportEvent(
-    id: HexKey,
-    pubKey: HexKey,
-    createdAt: Long,
-    tags: List<List<String>>,
-    content: String,
-    sig: HexKey
-) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
+class ReportEvent (
+  id: HexKey,
+  pubKey: HexKey,
+  createdAt: Long,
+  tags: List<List<String>>,
+  content: String,
+  sig: HexKey
+): Event(id, pubKey, createdAt, kind, tags, content, sig) {
 
-    private fun defaultReportType(): ReportType {
-        // Works with old and new structures for report.
-        var reportType = tags.filter { it.firstOrNull() == "report" }.mapNotNull { it.getOrNull(1) }.map { ReportType.valueOf(it.toUpperCase()) }.firstOrNull()
-        if (reportType == null) {
-            reportType = tags.mapNotNull { it.getOrNull(2) }.map { ReportType.valueOf(it.toUpperCase()) }.firstOrNull()
-        }
-        if (reportType == null) {
-            reportType = ReportType.SPAM
-        }
-        return reportType
+  private fun defaultReportType(): ReportType {
+    // Works with old and new structures for report.
+    var reportType = tags.filter { it.firstOrNull() == "report" }.mapNotNull { it.getOrNull(1) }.map { ReportType.valueOf(it.toUpperCase()) }.firstOrNull()
+    if (reportType == null) {
+      reportType = tags.mapNotNull { it.getOrNull(2) }.map { ReportType.valueOf(it.toUpperCase()) }.firstOrNull()
+    }
+    if (reportType == null) {
+      reportType = ReportType.SPAM
+    }
+    return reportType
+  }
+
+  fun reportedPost() = tags
+    .filter { it.firstOrNull() == "e" && it.getOrNull(1) != null }
+    .map {
+      ReportedKey(
+        it[1],
+        it.getOrNull(2)?.toUpperCase()?.let { it1 -> ReportType.valueOf(it1) }?: defaultReportType()
+      )
     }
 
-    fun reportedPost() = tags
-        .filter { it.firstOrNull() == "e" && it.getOrNull(1) != null }
-        .map {
-            ReportedKey(
-                it[1],
-                it.getOrNull(2)?.toUpperCase()?.let { it1 -> ReportType.valueOf(it1) } ?: defaultReportType()
-            )
-        }
-
-    fun reportedAuthor() = tags
-        .filter { it.firstOrNull() == "p" && it.getOrNull(1) != null }
-        .map {
-            ReportedKey(
-                it[1],
-                it.getOrNull(2)?.toUpperCase()?.let { it1 -> ReportType.valueOf(it1) } ?: defaultReportType()
-            )
-        }
-
-    fun taggedAddresses() = tags.filter { it.firstOrNull() == "a" }.mapNotNull { it.getOrNull(1) }.mapNotNull { ATag.parse(it) }
-
-    companion object {
-        const val kind = 1984
-
-        fun create(reportedPost: EventInterface, type: ReportType, privateKey: ByteArray, createdAt: Long = Date().time / 1000): ReportEvent {
-            val content = ""
-
-            val reportPostTag = listOf("e", reportedPost.id(), type.name.lowercase())
-            val reportAuthorTag = listOf("p", reportedPost.pubKey(), type.name.lowercase())
-
-            val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
-            var tags: List<List<String>> = listOf(reportPostTag, reportAuthorTag)
-
-            if (reportedPost is LongTextNoteEvent) {
-                tags = tags + listOf(listOf("a", reportedPost.address().toTag()))
-            }
-
-            val id = generateId(pubKey, createdAt, kind, tags, content)
-            val sig = Utils.sign(id, privateKey)
-            return ReportEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
-        }
-
-        fun create(reportedUser: String, type: ReportType, privateKey: ByteArray, createdAt: Long = Date().time / 1000): ReportEvent {
-            val content = ""
-
-            val reportAuthorTag = listOf("p", reportedUser, type.name.lowercase())
-
-            val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
-            val tags: List<List<String>> = listOf(reportAuthorTag)
-            val id = generateId(pubKey, createdAt, kind, tags, content)
-            val sig = Utils.sign(id, privateKey)
-            return ReportEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
-        }
+  fun reportedAuthor() = tags
+    .filter { it.firstOrNull() == "p" && it.getOrNull(1) != null }
+    .map {
+      ReportedKey(
+        it[1],
+        it.getOrNull(2)?.toUpperCase()?.let { it1 -> ReportType.valueOf(it1) }?: defaultReportType()
+      )
     }
 
-    enum class ReportType() {
-        EXPLICIT, // Not used anymore.
-        ILLEGAL,
-        SPAM,
-        IMPERSONATION,
-        NUDITY,
-        PROFANITY
+  fun taggedAddresses() = tags.filter { it.firstOrNull() == "a" }.mapNotNull {
+    val aTagValue = it.getOrNull(1)
+    val relay = it.getOrNull(2)
+
+    if (aTagValue != null) ATag.parse(aTagValue, relay) else null
+  }
+
+  companion object {
+    const val kind = 1984
+
+    fun create(reportedPost: EventInterface, type: ReportType, privateKey: ByteArray, createdAt: Long = Date().time / 1000): ReportEvent {
+      val content = ""
+
+      val reportPostTag = listOf("e", reportedPost.id(), type.name.lowercase())
+      val reportAuthorTag = listOf("p", reportedPost.pubKey(), type.name.lowercase())
+
+      val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
+      var tags:List<List<String>> = listOf(reportPostTag, reportAuthorTag)
+
+      if (reportedPost is LongTextNoteEvent) {
+        tags = tags + listOf( listOf("a", reportedPost.address().toTag()) )
+      }
+
+      val id = generateId(pubKey, createdAt, kind, tags, content)
+      val sig = Utils.sign(id, privateKey)
+      return ReportEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
     }
+
+    fun create(reportedUser: String, type: ReportType, privateKey: ByteArray, createdAt: Long = Date().time / 1000): ReportEvent {
+      val content = ""
+
+      val reportAuthorTag = listOf("p", reportedUser, type.name.lowercase())
+
+      val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
+      val tags:List<List<String>> = listOf(reportAuthorTag)
+      val id = generateId(pubKey, createdAt, kind, tags, content)
+      val sig = Utils.sign(id, privateKey)
+      return ReportEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
+    }
+  }
+
+  enum class ReportType() {
+    EXPLICIT, // Not used anymore.
+    ILLEGAL,
+    SPAM,
+    IMPERSONATION,
+    NUDITY,
+    PROFANITY,
+  }
 }

app/src/main/java/com/vitorpamplona/amethyst/service/model/RepostEvent.kt

@@ -3,47 +3,53 @@ package com.vitorpamplona.amethyst.service.model
 import com.vitorpamplona.amethyst.model.HexKey
 import com.vitorpamplona.amethyst.model.toHexKey
 import com.vitorpamplona.amethyst.service.relays.Client
-import nostr.postr.Utils
 import java.util.Date
+import nostr.postr.Utils
 
-class RepostEvent(
-    id: HexKey,
-    pubKey: HexKey,
-    createdAt: Long,
-    tags: List<List<String>>,
-    content: String,
-    sig: HexKey
-) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
+class RepostEvent (
+  id: HexKey,
+  pubKey: HexKey,
+  createdAt: Long,
+  tags: List<List<String>>,
+  content: String,
+  sig: HexKey
+): Event(id, pubKey, createdAt, kind, tags, content, sig) {
 
-    fun boostedPost() = tags.filter { it.firstOrNull() == "e" }.mapNotNull { it.getOrNull(1) }
-    fun originalAuthor() = tags.filter { it.firstOrNull() == "p" }.mapNotNull { it.getOrNull(1) }
-    fun taggedAddresses() = tags.filter { it.firstOrNull() == "a" }.mapNotNull { it.getOrNull(1) }.mapNotNull { ATag.parse(it) }
 
-    fun containedPost() = try {
-        fromJson(content, Client.lenient)
-    } catch (e: Exception) {
-        null
-    }
-
-    companion object {
-        const val kind = 6
-
-        fun create(boostedPost: EventInterface, privateKey: ByteArray, createdAt: Long = Date().time / 1000): RepostEvent {
-            val content = boostedPost.toJson()
-
-            val replyToPost = listOf("e", boostedPost.id())
-            val replyToAuthor = listOf("p", boostedPost.pubKey())
-
-            val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
-            var tags: List<List<String>> = boostedPost.tags().plus(listOf(replyToPost, replyToAuthor))
-
-            if (boostedPost is LongTextNoteEvent) {
-                tags = tags + listOf(listOf("a", boostedPost.address().toTag()))
-            }
-
-            val id = generateId(pubKey, createdAt, kind, tags, content)
-            val sig = Utils.sign(id, privateKey)
-            return RepostEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
-        }
+  fun boostedPost() = tags.filter { it.firstOrNull() == "e" }.mapNotNull { it.getOrNull(1) }
+  fun originalAuthor() = tags.filter { it.firstOrNull() == "p" }.mapNotNull { it.getOrNull(1) }
+  fun taggedAddresses() = tags.filter { it.firstOrNull() == "a" }.mapNotNull {
+    val aTagValue = it.getOrNull(1)
+    val relay = it.getOrNull(2)
+
+    if (aTagValue != null) ATag.parse(aTagValue, relay) else null
+  }
+
+  fun containedPost() = try {
+    fromJson(content, Client.lenient)
+  } catch (e: Exception) {
+    null
+  }
+
+  companion object {
+    const val kind = 6
+
+    fun create(boostedPost: EventInterface, privateKey: ByteArray, createdAt: Long = Date().time / 1000): RepostEvent {
+      val content = boostedPost.toJson()
+
+      val replyToPost = listOf("e", boostedPost.id())
+      val replyToAuthor = listOf("p", boostedPost.pubKey())
+
+      val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
+      var tags:List<List<String>> = boostedPost.tags().plus(listOf(replyToPost, replyToAuthor))
+
+      if (boostedPost is LongTextNoteEvent) {
+        tags = tags + listOf( listOf("a", boostedPost.address().toTag()) )
+      }
+
+      val id = generateId(pubKey, createdAt, kind, tags, content)
+      val sig = Utils.sign(id, privateKey)
+      return RepostEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
     }
+  }
 }

app/src/main/java/com/vitorpamplona/amethyst/service/model/TextNoteEvent.kt

@@ -14,7 +14,13 @@ class TextNoteEvent(
     sig: HexKey
 ) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
     fun mentions() = tags.filter { it.firstOrNull() == "p" }.mapNotNull { it.getOrNull(1) }
-    fun taggedAddresses() = tags.filter { it.firstOrNull() == "a" }.mapNotNull { it.getOrNull(1) }.mapNotNull { ATag.parse(it) }
+    fun taggedAddresses() = tags.filter { it.firstOrNull() == "a" }.mapNotNull {
+        val aTagValue = it.getOrNull(1)
+        val relay = it.getOrNull(2)
+
+        if (aTagValue != null) ATag.parse(aTagValue, relay) else null
+    }
+
     fun replyTos() = tags.filter { it.firstOrNull() == "e" }.mapNotNull { it.getOrNull(1) }
 
     companion object {

app/src/main/java/com/vitorpamplona/amethyst/ui/components/ClickableRoute.kt

@@ -3,6 +3,7 @@ package com.vitorpamplona.amethyst.ui.components
 import androidx.compose.foundation.text.ClickableText
 import androidx.compose.material.LocalTextStyle
 import androidx.compose.material.MaterialTheme
+import androidx.compose.material.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.livedata.observeAsState
@@ -14,46 +15,67 @@ import com.vitorpamplona.amethyst.service.model.ChannelCreateEvent
 
 @Composable
 fun ClickableRoute(
-    nip19: Nip19.Return,
-    navController: NavController
+  nip19: Nip19.Return,
+  navController: NavController
 ) {
-    if (nip19.type == Nip19.Type.USER) {
-        val userBase = LocalCache.getOrCreateUser(nip19.hex)
+  if (nip19.type == Nip19.Type.USER) {
+    val userBase = LocalCache.getOrCreateUser(nip19.hex)
 
-        val userState by userBase.live().metadata.observeAsState()
-        val user = userState?.user ?: return
+    val userState by userBase.live().metadata.observeAsState()
+    val user = userState?.user ?: return
 
-        val route = "User/${nip19.hex}"
-        val text = user.toBestDisplayName()
+    val route = "User/${nip19.hex}"
+    val text = user.toBestDisplayName()
 
-        ClickableText(
-            text = AnnotatedString("@$text "),
-            onClick = { navController.navigate(route) },
-            style = LocalTextStyle.current.copy(color = MaterialTheme.colors.primary)
-        )
+    ClickableText(
+      text = AnnotatedString("@${text} "),
+      onClick = { navController.navigate(route) },
+      style = LocalTextStyle.current.copy(color = MaterialTheme.colors.primary)
+    )
+  } else if (nip19.type == Nip19.Type.ADDRESS) {
+    val noteBase = LocalCache.checkGetOrCreateAddressableNote(nip19.hex)
+
+    if (noteBase == null) {
+      Text(
+        "@${nip19.hex} "
+      )
     } else {
-        val noteBase = LocalCache.getOrCreateNote(nip19.hex)
-        val noteState by noteBase.live().metadata.observeAsState()
-        val note = noteState?.note ?: return
+      val noteState by noteBase.live().metadata.observeAsState()
+      val note = noteState?.note ?: return
 
-        if (note.event is ChannelCreateEvent) {
-            ClickableText(
-                text = AnnotatedString("@${note.idDisplayNote()} "),
-                onClick = { navController.navigate("Channel/${nip19.hex}") },
-                style = LocalTextStyle.current.copy(color = MaterialTheme.colors.primary)
-            )
-        } else if (note.channel() != null) {
-            ClickableText(
-                text = AnnotatedString("@${note.channel()?.toBestDisplayName()} "),
-                onClick = { navController.navigate("Channel/${note.channel()?.idHex}") },
-                style = LocalTextStyle.current.copy(color = MaterialTheme.colors.primary)
-            )
-        } else {
-            ClickableText(
-                text = AnnotatedString("@${note.idDisplayNote()} "),
-                onClick = { navController.navigate("Note/${nip19.hex}") },
-                style = LocalTextStyle.current.copy(color = MaterialTheme.colors.primary)
-            )
-        }
+      ClickableText(
+        text = AnnotatedString("@${note.idDisplayNote()} "),
+        onClick = { navController.navigate("Note/${nip19.hex}") },
+        style = LocalTextStyle.current.copy(color = MaterialTheme.colors.primary)
+      )
     }
-}
+  } else if (nip19.type == Nip19.Type.NOTE) {
+    val noteBase = LocalCache.getOrCreateNote(nip19.hex)
+    val noteState by noteBase.live().metadata.observeAsState()
+    val note = noteState?.note ?: return
+
+    if (note.event is ChannelCreateEvent) {
+      ClickableText(
+        text = AnnotatedString("@${note.idDisplayNote()} "),
+        onClick = { navController.navigate("Channel/${nip19.hex}") },
+        style = LocalTextStyle.current.copy(color = MaterialTheme.colors.primary)
+      )
+    } else if (note.channel() != null) {
+      ClickableText(
+        text = AnnotatedString("@${note.channel()?.toBestDisplayName()} "),
+        onClick = { navController.navigate("Channel/${note.channel()?.idHex}") },
+        style = LocalTextStyle.current.copy(color = MaterialTheme.colors.primary)
+      )
+    } else {
+      ClickableText(
+        text = AnnotatedString("@${note.idDisplayNote()} "),
+        onClick = { navController.navigate("Note/${nip19.hex}") },
+        style = LocalTextStyle.current.copy(color = MaterialTheme.colors.primary)
+      )
+    }
+  } else {
+    Text(
+      "@${nip19.hex} "
+    )
+  }
+}

app/src/main/java/com/vitorpamplona/amethyst/ui/components/RichTextViewer.kt

@@ -8,20 +8,28 @@ import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.LocalContentColor
 import androidx.compose.material.LocalTextStyle
 import androidx.compose.material.MaterialTheme
 import androidx.compose.material.Text
+import androidx.compose.material.contentColorFor
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.livedata.observeAsState
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.compositeOver
+import androidx.compose.ui.text.Paragraph
 import androidx.compose.ui.text.SpanStyle
 import androidx.compose.ui.text.TextStyle
 import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.text.style.TextDecoration
 import androidx.compose.ui.text.style.TextDirection
 import androidx.compose.ui.unit.dp
@@ -33,9 +41,9 @@ import com.halilibo.richtext.markdown.MarkdownParseOptions
 import com.halilibo.richtext.ui.RichTextStyle
 import com.halilibo.richtext.ui.material.MaterialRichText
 import com.halilibo.richtext.ui.resolveDefaults
+import com.vitorpamplona.amethyst.service.lnurl.LnInvoiceUtil
 import com.vitorpamplona.amethyst.model.LocalCache
 import com.vitorpamplona.amethyst.service.Nip19
-import com.vitorpamplona.amethyst.service.lnurl.LnInvoiceUtil
 import com.vitorpamplona.amethyst.ui.note.NoteCompose
 import com.vitorpamplona.amethyst.ui.screen.loggedIn.AccountViewModel
 import java.net.MalformedURLException
@@ -53,234 +61,240 @@ val hashTagsPattern: Pattern = Pattern.compile("#([A-Za-z0-9_-]+)")
 val urlPattern: Pattern = Patterns.WEB_URL
 
 fun isValidURL(url: String?): Boolean {
-    return try {
-        URL(url).toURI()
-        true
-    } catch (e: MalformedURLException) {
-        false
-    } catch (e: URISyntaxException) {
-        false
-    }
+  return try {
+    URL(url).toURI()
+    true
+  } catch (e: MalformedURLException) {
+    false
+  } catch (e: URISyntaxException) {
+    false
+  }
 }
 
 @Composable
 fun RichTextViewer(
-    content: String,
-    canPreview: Boolean,
-    modifier: Modifier = Modifier,
-    tags: List<List<String>>?,
-    backgroundColor: Color,
-    accountViewModel: AccountViewModel,
-    navController: NavController
+  content: String,
+  canPreview: Boolean,
+  modifier: Modifier = Modifier,
+  tags: List<List<String>>?,
+  backgroundColor: Color,
+  accountViewModel: AccountViewModel,
+  navController: NavController,
 ) {
-    val myMarkDownStyle = RichTextStyle().resolveDefaults().copy(
-        codeBlockStyle = RichTextStyle().resolveDefaults().codeBlockStyle?.copy(
-            textStyle = TextStyle(
-                fontFamily = FontFamily.Monospace,
-                fontSize = 14.sp
-            ),
-            modifier = Modifier
-                .padding(0.dp)
-                .fillMaxWidth()
-                .clip(shape = RoundedCornerShape(15.dp))
-                .border(
-                    1.dp,
-                    MaterialTheme.colors.onSurface.copy(alpha = 0.12f),
-                    RoundedCornerShape(15.dp)
-                )
-                .background(MaterialTheme.colors.onSurface.copy(alpha = 0.05f).compositeOver(backgroundColor))
-        ),
-        stringStyle = RichTextStyle().resolveDefaults().stringStyle?.copy(
-            linkStyle = SpanStyle(
-                textDecoration = TextDecoration.Underline,
-                color = MaterialTheme.colors.primary
-            ),
-            codeStyle = SpanStyle(
-                fontFamily = FontFamily.Monospace,
-                fontSize = 14.sp,
-                background = MaterialTheme.colors.onSurface.copy(alpha = 0.22f).compositeOver(backgroundColor)
-            )
-        )
-    )
 
-    Column(modifier = modifier.animateContentSize()) {
-        if (content.startsWith("# ") ||
-            content.contains("##") ||
-            content.contains("**") ||
-            content.contains("__") ||
-            content.contains("```")
-        ) {
-            MaterialRichText(
-                style = myMarkDownStyle
-            ) {
-                Markdown(
-                    content = content,
-                    markdownParseOptions = MarkdownParseOptions.Default
-                )
-            }
-        } else {
-            // FlowRow doesn't work well with paragraphs. So we need to split them
-            content.split('\n').forEach { paragraph ->
-                FlowRow() {
-                    val s = if (isArabic(paragraph)) paragraph.split(' ').reversed() else paragraph.split(' ')
-                    s.forEach { word: String ->
-                        if (canPreview) {
-                            // Explicit URL
-                            val lnInvoice = LnInvoiceUtil.findInvoice(word)
-                            if (lnInvoice != null) {
-                                InvoicePreview(lnInvoice)
-                            } else if (isValidURL(word)) {
-                                val removedParamsFromUrl = word.split("?")[0].lowercase()
-                                if (imageExtension.matcher(removedParamsFromUrl).matches()) {
-                                    ZoomableImageView(word)
-                                } else if (videoExtension.matcher(removedParamsFromUrl).matches()) {
-                                    VideoView(word)
-                                } else {
-                                    UrlPreview(word, word)
-                                }
-                            } else if (Patterns.EMAIL_ADDRESS.matcher(word).matches()) {
-                                ClickableEmail(word)
-                            } else if (Patterns.PHONE.matcher(word).matches() && word.length > 6) {
-                                ClickablePhone(word)
-                            } else if (noProtocolUrlValidator.matcher(word).matches()) {
-                                UrlPreview("https://$word", word)
-                            } else if (tagIndex.matcher(word).matches() && tags != null) {
-                                TagLink(word, tags, canPreview, backgroundColor, accountViewModel, navController)
-                            } else if (isBechLink(word)) {
-                                BechLink(word, navController)
-                            } else {
-                                Text(
-                                    text = "$word ",
-                                    style = LocalTextStyle.current.copy(textDirection = TextDirection.Content)
-                                )
-                            }
-                        } else {
-                            if (isValidURL(word)) {
-                                ClickableUrl("$word ", word)
-                            } else if (Patterns.EMAIL_ADDRESS.matcher(word).matches()) {
-                                ClickableEmail(word)
-                            } else if (Patterns.PHONE.matcher(word).matches() && word.length > 6) {
-                                ClickablePhone(word)
-                            } else if (noProtocolUrlValidator.matcher(word).matches()) {
-                                ClickableUrl(word, "https://$word")
-                            } else if (tagIndex.matcher(word).matches() && tags != null) {
-                                TagLink(word, tags, canPreview, backgroundColor, accountViewModel, navController)
-                            } else if (isBechLink(word)) {
-                                BechLink(word, navController)
-                            } else {
-                                Text(
-                                    text = "$word ",
-                                    style = LocalTextStyle.current.copy(textDirection = TextDirection.Content)
-                                )
-                            }
-                        }
-                    }
+  val myMarkDownStyle = RichTextStyle().resolveDefaults().copy(
+    codeBlockStyle = RichTextStyle().resolveDefaults().codeBlockStyle?.copy(
+      textStyle = TextStyle(
+        fontFamily = FontFamily.Monospace,
+        fontSize = 14.sp
+      ),
+      modifier = Modifier
+        .padding(0.dp)
+        .fillMaxWidth()
+        .clip(shape = RoundedCornerShape(15.dp))
+        .border(
+          1.dp,
+          MaterialTheme.colors.onSurface.copy(alpha = 0.12f),
+          RoundedCornerShape(15.dp)
+        )
+        .background(MaterialTheme.colors.onSurface.copy(alpha = 0.05f).compositeOver(backgroundColor))
+    ),
+    stringStyle = RichTextStyle().resolveDefaults().stringStyle?.copy(
+      linkStyle = SpanStyle(
+        textDecoration = TextDecoration.Underline,
+        color = MaterialTheme.colors.primary
+      ),
+      codeStyle = SpanStyle(
+        fontFamily = FontFamily.Monospace,
+        fontSize = 14.sp,
+        background = MaterialTheme.colors.onSurface.copy(alpha = 0.22f).compositeOver(backgroundColor)
+      )
+    )
+  )
+
+  Column(modifier = modifier.animateContentSize()) {
+
+    if ( content.startsWith("# ")
+      || content.contains("##")
+      || content.contains("**")
+      || content.contains("__")
+      || content.contains("```")
+    ) {
+
+      MaterialRichText(
+        style = myMarkDownStyle,
+      ) {
+        Markdown(
+          content = content,
+          markdownParseOptions = MarkdownParseOptions.Default,
+        )
+      }
+    } else {
+      // FlowRow doesn't work well with paragraphs. So we need to split them
+      content.split('\n').forEach { paragraph ->
+        FlowRow() {
+          val s = if (isArabic(paragraph))  paragraph.split(' ').reversed() else paragraph.split(' ');
+          s.forEach { word: String ->
+            if (canPreview) {
+              // Explicit URL
+              val lnInvoice = LnInvoiceUtil.findInvoice(word)
+              if (lnInvoice != null) {
+                InvoicePreview(lnInvoice)
+              } else if (isValidURL(word)) {
+                val removedParamsFromUrl = word.split("?")[0].lowercase()
+                if (imageExtension.matcher(removedParamsFromUrl).matches()) {
+                  ZoomableImageView(word)
+                } else if (videoExtension.matcher(removedParamsFromUrl).matches()) {
+                  VideoView(word)
+                } else {
+                  UrlPreview(word, word)
                 }
+              } else if (Patterns.EMAIL_ADDRESS.matcher(word).matches()) {
+                ClickableEmail(word)
+              } else if (Patterns.PHONE.matcher(word).matches() && word.length > 6) {
+                ClickablePhone(word)
+              } else if (noProtocolUrlValidator.matcher(word).matches()) {
+                UrlPreview("https://$word", word)
+              } else if (tagIndex.matcher(word).matches() && tags != null) {
+                TagLink(word, tags, canPreview, backgroundColor, accountViewModel, navController)
+              } else if (isBechLink(word)) {
+                BechLink(word, navController)
+              } else {
+                Text(
+                  text = "$word ",
+                  style = LocalTextStyle.current.copy(textDirection = TextDirection.Content),
+                )
+              }
+            } else {
+              if (isValidURL(word)) {
+                ClickableUrl("$word ", word)
+              } else if (Patterns.EMAIL_ADDRESS.matcher(word).matches()) {
+                ClickableEmail(word)
+              } else if (Patterns.PHONE.matcher(word).matches() && word.length > 6) {
+                ClickablePhone(word)
+              } else if (noProtocolUrlValidator.matcher(word).matches()) {
+                ClickableUrl(word, "https://$word")
+              } else if (tagIndex.matcher(word).matches() && tags != null) {
+                TagLink(word, tags, canPreview, backgroundColor, accountViewModel, navController)
+              } else if (isBechLink(word)) {
+                BechLink(word, navController)
+              } else {
+                Text(
+                  text = "$word ",
+                  style = LocalTextStyle.current.copy(textDirection = TextDirection.Content),
+                )
+              }
             }
+          }
         }
+      }
     }
+  }
 }
 
 private fun isArabic(text: String): Boolean {
-    return text.any { it in '\u0600'..'\u06FF' || it in '\u0750'..'\u077F' }
+  return text.any { it in '\u0600'..'\u06FF' || it in '\u0750'..'\u077F' }
 }
 
+
 fun isBechLink(word: String): Boolean {
-    return word.startsWith("nostr:", true) ||
-        word.startsWith("npub1", true) ||
-        word.startsWith("note1", true) ||
-        word.startsWith("nprofile1", true) ||
-        word.startsWith("nevent1", true) ||
-        word.startsWith("@npub1", true) ||
-        word.startsWith("@note1", true) ||
-        word.startsWith("@nprofile1", true) ||
-        word.startsWith("@nevent1", true)
+  return word.startsWith("nostr:", true)
+    || word.startsWith("npub1", true)
+    || word.startsWith("naddr1", true)
+    || word.startsWith("note1", true)
+    || word.startsWith("nprofile1", true)
+    || word.startsWith("nevent1", true)
+    || word.startsWith("@npub1", true)
+    || word.startsWith("@note1", true)
+    || word.startsWith("@addr1", true)
+    || word.startsWith("@nprofile1", true)
+    || word.startsWith("@nevent1", true)
 }
 
 @Composable
 fun BechLink(word: String, navController: NavController) {
-    val uri = if (word.startsWith("nostr", true)) {
-        word
-    } else if (word.startsWith("@")) {
-        word.replaceFirst("@", "nostr:")
-    } else {
-        "nostr:$word"
-    }
+  val uri = if (word.startsWith("nostr", true)) {
+    word
+  } else if (word.startsWith("@")) {
+    word.replaceFirst("@", "nostr:")
+  } else {
+    "nostr:${word}"
+  }
 
-    val nip19Route = try {
-        Nip19().uriToRoute(uri)
-    } catch (e: Exception) {
-        null
-    }
+  val nip19Route = try {
+    Nip19().uriToRoute(uri)
+  } catch (e: Exception) {
+    null
+  }
 
-    if (nip19Route == null) {
-        Text(text = "$word ")
-    } else {
-        ClickableRoute(nip19Route, navController)
-    }
+  if (nip19Route == null) {
+    Text(text = "$word ")
+  } else {
+    ClickableRoute(nip19Route, navController)
+  }
 }
 
+
 @Composable
 fun TagLink(word: String, tags: List<List<String>>, canPreview: Boolean, backgroundColor: Color, accountViewModel: AccountViewModel, navController: NavController) {
-    val matcher = tagIndex.matcher(word)
+  val matcher = tagIndex.matcher(word)
 
-    val index = try {
-        matcher.find()
-        matcher.group(1).toInt()
-    } catch (e: Exception) {
-        println("Couldn't link tag $word")
-        null
-    }
+  val index = try {
+    matcher.find()
+    matcher.group(1).toInt()
+  } catch (e: Exception) {
+    println("Couldn't link tag ${word}")
+    null
+  }
 
-    if (index == null) {
-        return Text(text = "$word ")
-    }
+  if (index == null) {
+    return Text(text = "$word ")
+  }
 
-    if (index >= 0 && index < tags.size) {
-        if (tags[index][0] == "p") {
-            val baseUser = LocalCache.checkGetOrCreateUser(tags[index][1])
-            if (baseUser != null) {
-                val userState = baseUser.live().metadata.observeAsState()
-                val user = userState.value?.user
-                if (user != null) {
-                    ClickableUserTag(user, navController)
-                } else {
-                    Text(text = "$word ")
-                }
-            } else {
-                // if here the tag is not a valid Nostr Hex
-                Text(text = "$word ")
-            }
-        } else if (tags[index][0] == "e") {
-            val note = LocalCache.checkGetOrCreateNote(tags[index][1])
-            if (note != null) {
-                if (canPreview) {
-                    NoteCompose(
-                        baseNote = note,
-                        accountViewModel = accountViewModel,
-                        modifier = Modifier
-                            .padding(0.dp)
-                            .fillMaxWidth()
-                            .clip(shape = RoundedCornerShape(15.dp))
-                            .border(
-                                1.dp,
-                                MaterialTheme.colors.onSurface.copy(alpha = 0.12f),
-                                RoundedCornerShape(15.dp)
-                            ),
-                        parentBackgroundColor = MaterialTheme.colors.onSurface.copy(alpha = 0.05f)
-                            .compositeOver(backgroundColor),
-                        isQuotedNote = true,
-                        navController = navController
-                    )
-                } else {
-                    ClickableNoteTag(note, navController)
-                }
-            } else {
-                // if here the tag is not a valid Nostr Hex
-                Text(text = "$word ")
-            }
+  if (index >= 0 && index < tags.size) {
+    if (tags[index][0] == "p") {
+      val baseUser = LocalCache.checkGetOrCreateUser(tags[index][1])
+      if (baseUser != null) {
+        val userState = baseUser.live().metadata.observeAsState()
+        val user = userState.value?.user
+        if (user != null) {
+          ClickableUserTag(user, navController)
         } else {
-            Text(text = "$word ")
+          Text(text = "$word ")
         }
-    }
+      } else {
+        // if here the tag is not a valid Nostr Hex
+        Text(text = "$word ")
+      }
+    } else if (tags[index][0] == "e") {
+      val note = LocalCache.checkGetOrCreateNote(tags[index][1])
+      if (note != null) {
+        if (canPreview) {
+          NoteCompose(
+            baseNote = note,
+            accountViewModel = accountViewModel,
+            modifier = Modifier
+              .padding(0.dp)
+              .fillMaxWidth()
+              .clip(shape = RoundedCornerShape(15.dp))
+              .border(
+                1.dp,
+                MaterialTheme.colors.onSurface.copy(alpha = 0.12f),
+                RoundedCornerShape(15.dp)
+              ),
+            parentBackgroundColor = MaterialTheme.colors.onSurface.copy(alpha = 0.05f)
+              .compositeOver(backgroundColor),
+            isQuotedNote = true,
+            navController = navController
+          )
+        } else {
+          ClickableNoteTag(note, navController)
+        }
+      } else {
+        // if here the tag is not a valid Nostr Hex
+        Text(text = "$word ")
+      }
+    } else
+      Text(text = "$word ")
+  }
 }

app/src/test/java/com/vitorpamplona/amethyst/NIP19ParserTest.kt

@@ -6,27 +6,51 @@ import org.junit.Assert.assertEquals
 import org.junit.Test
 
 class NIP19ParserTest {
-    @Test
-    fun nAddrParser() {
-        val result = Nip19().uriToRoute("nostr:naddr1qqqqygzxpsj7dqha57pjk5k37gkn6g4nzakewtmqmnwryyhd3jfwlpgxtspsgqqqw4rs3xyxus")
-        assertEquals("30023:460c25e682fda7832b52d1f22d3d22b3176d972f60dcdc3212ed8c92ef85065c:", result?.hex)
-    }
+  @Test
+  fun nAddrParser() {
+    val result = Nip19().uriToRoute("nostr:naddr1qqqqygzxpsj7dqha57pjk5k37gkn6g4nzakewtmqmnwryyhd3jfwlpgxtspsgqqqw4rs3xyxus")
+    assertEquals("30023:460c25e682fda7832b52d1f22d3d22b3176d972f60dcdc3212ed8c92ef85065c:", result?.hex)
+  }
 
-    @Test
-    fun nAddrParser2() {
-        val result = Nip19().uriToRoute("nostr:naddr1qq8kwatfv3jj6amfwfjkwatpwfjqygxsm6lelvfda7qlg0tud9pfhduysy4vrexj65azqtdk4tr75j6xdspsgqqqw4rsg32ag8")
-        assertEquals("30023:d0debf9fb12def81f43d7c69429bb784812ac1e4d2d53a202db6aac7ea4b466c:guide-wireguard", result?.hex)
-    }
+  @Test
+  fun nAddrParser2() {
+    val result = Nip19().uriToRoute("nostr:naddr1qq8kwatfv3jj6amfwfjkwatpwfjqygxsm6lelvfda7qlg0tud9pfhduysy4vrexj65azqtdk4tr75j6xdspsgqqqw4rsg32ag8")
+    assertEquals("30023:d0debf9fb12def81f43d7c69429bb784812ac1e4d2d53a202db6aac7ea4b466c:guide-wireguard", result?.hex)
+  }
 
-    @Test
-    fun nAddrFormatter() {
-        val address = ATag(30023, "460c25e682fda7832b52d1f22d3d22b3176d972f60dcdc3212ed8c92ef85065c", "")
-        assertEquals("naddr1qqqqygzxpsj7dqha57pjk5k37gkn6g4nzakewtmqmnwryyhd3jfwlpgxtspsgqqqw4rs3xyxus", address.toNAddr())
-    }
+  @Test
+  fun nAddrParse3() {
+    val result = Nip19().uriToRoute("naddr1qqyrswtyv5mnjv3sqy28wumn8ghj7un9d3shjtnyv9kh2uewd9hsygx3uczxts4hwue9ayfn7ggq62anzstde2qs749pm9tx2csuthhpjvpsgqqqw4rs8pmj38")
+    assertEquals(Nip19.Type.ADDRESS, result?.type)
+    assertEquals("30023:d1e60465c2b777325e9133f2100d2bb31416dca810f54a1d95665621c5dee193:89de7920", result?.hex)
+    assertEquals("wss://relay.damus.io", result?.relay)
+  }
 
-    @Test
-    fun nAddrFormatter2() {
-        val address = ATag(30023, "d0debf9fb12def81f43d7c69429bb784812ac1e4d2d53a202db6aac7ea4b466c", "guide-wireguard")
-        assertEquals("naddr1qq8kwatfv3jj6amfwfjkwatpwfjqygxsm6lelvfda7qlg0tud9pfhduysy4vrexj65azqtdk4tr75j6xdspsgqqqw4rsg32ag8", address.toNAddr())
-    }
-}
+  @Test
+  fun nAddrATagParse3() {
+    val address = ATag.parse("30023:d1e60465c2b777325e9133f2100d2bb31416dca810f54a1d95665621c5dee193:89de7920", "wss://relay.damus.io")
+    assertEquals(30023, address?.kind)
+    assertEquals("d1e60465c2b777325e9133f2100d2bb31416dca810f54a1d95665621c5dee193", address?.pubKeyHex)
+    assertEquals("89de7920", address?.dTag)
+    assertEquals("wss://relay.damus.io" , address?.relay)
+    assertEquals("naddr1qqyrswtyv5mnjv3sqy28wumn8ghj7un9d3shjtnyv9kh2uewd9hsygx3uczxts4hwue9ayfn7ggq62anzstde2qs749pm9tx2csuthhpjvpsgqqqw4rs8pmj38", address?.toNAddr())
+  }
+
+  @Test
+  fun nAddrFormatter() {
+    val address = ATag(30023, "460c25e682fda7832b52d1f22d3d22b3176d972f60dcdc3212ed8c92ef85065c", "", null)
+    assertEquals("naddr1qqqqygzxpsj7dqha57pjk5k37gkn6g4nzakewtmqmnwryyhd3jfwlpgxtspsgqqqw4rs3xyxus", address.toNAddr())
+  }
+
+  @Test
+  fun nAddrFormatter2() {
+    val address = ATag(30023, "d0debf9fb12def81f43d7c69429bb784812ac1e4d2d53a202db6aac7ea4b466c", "guide-wireguard", null)
+    assertEquals("naddr1qq8kwatfv3jj6amfwfjkwatpwfjqygxsm6lelvfda7qlg0tud9pfhduysy4vrexj65azqtdk4tr75j6xdspsgqqqw4rsg32ag8", address.toNAddr())
+  }
+
+  @Test
+  fun nAddrFormatter3() {
+    val address = ATag(30023, "d1e60465c2b777325e9133f2100d2bb31416dca810f54a1d95665621c5dee193", "89de7920", "wss://relay.damus.io")
+    assertEquals("naddr1qqyrswtyv5mnjv3sqy28wumn8ghj7un9d3shjtnyv9kh2uewd9hsygx3uczxts4hwue9ayfn7ggq62anzstde2qs749pm9tx2csuthhpjvpsgqqqw4rs8pmj38", address.toNAddr())
+  }
+}