v0.79.6

Added #thenostr hashtag icon

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,32 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="PreviewAnnotationInFunctionWithParameters" enabled="true" level="ERROR" enabled_by_default="true">
+      <option name="composableFile" value="true" />
+    </inspection_tool>
+    <inspection_tool class="PreviewApiLevelMustBeValid" enabled="true" level="ERROR" enabled_by_default="true">
+      <option name="composableFile" value="true" />
+    </inspection_tool>
+    <inspection_tool class="PreviewDimensionRespectsLimit" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="composableFile" value="true" />
+    </inspection_tool>
+    <inspection_tool class="PreviewFontScaleMustBeGreaterThanZero" enabled="true" level="ERROR" enabled_by_default="true">
+      <option name="composableFile" value="true" />
+    </inspection_tool>
+    <inspection_tool class="PreviewMultipleParameterProviders" enabled="true" level="ERROR" enabled_by_default="true">
+      <option name="composableFile" value="true" />
+    </inspection_tool>
+    <inspection_tool class="PreviewMustBeTopLevelFunction" enabled="true" level="ERROR" enabled_by_default="true">
+      <option name="composableFile" value="true" />
+    </inspection_tool>
+    <inspection_tool class="PreviewNeedsComposableAnnotation" enabled="true" level="ERROR" enabled_by_default="true">
+      <option name="composableFile" value="true" />
+    </inspection_tool>
+    <inspection_tool class="PreviewNotSupportedInUnitTestFiles" enabled="true" level="ERROR" enabled_by_default="true">
+      <option name="composableFile" value="true" />
+    </inspection_tool>
+    <inspection_tool class="PreviewPickerAnnotation" enabled="true" level="ERROR" enabled_by_default="true">
+      <option name="composableFile" value="true" />
+    </inspection_tool>
+  </profile>
+</component>

README.md

@@ -106,7 +106,7 @@ height="80">](https://github.com/vitorpamplona/amethyst/releases)
 
 This is a native Android app made with Kotlin and Jetpack Compose.
 The app uses a modified version of the [nostrpostrlib](https://github.com/Giszmo/NostrPostr/tree/master/nostrpostrlib) to talk to Nostr relays.
-The overall architecture consists in the UI, which uses the usual State/ViewModel/Composition, the service layer that connects with Nostr relays,
+The overall architecture consists of the UI, which uses the usual State/ViewModel/Composition, the service layer that connects with Nostr relays,
 and the model/repository layer, which keeps all Nostr objects in memory, in a full OO graph.
 
 The repository layer stores Nostr Events as Notes and Users separately. Those classes use LiveData objects to
@@ -172,7 +172,7 @@ For the Play build:
 keytool -genkey -v -keystore <my-release-key.keystore> -alias <alias_name> -keyalg RSA -keysize 2048 -validity 10000
 openssl base64 < <my-release-key.keystore> | tr -d '\n' | tee some_signing_key.jks.base64.txt
 ```
-2. Create 4 Secret Key variables on your GitHub repository and fill in with the signing key information
+2. Create four Secret Key variables on your GitHub repository and fill in the signing key information
     - `KEY_ALIAS` <- `<alias_name>`
     - `KEY_PASSWORD` <- `<your password>`
     - `KEY_STORE_PASSWORD` <- `<your key store password>`
@@ -192,15 +192,15 @@ The relay also learns which public keys you are requesting, meaning your public
 Relays have all your data in raw text. They know your IP, your name, your location (guessed from IP), your pub key, all your contacts, and other relays, and can read every action you do (post, like, boost, quote, report, etc) with the exception of Private Zaps and Private DMs.
 
 # DM Privacy #
-While the content of direct messages (DMs) is only visible to you, and your DM nostr counterparty, everyone can see that and when you and your counterparty are DM-ing each other.
+While the content of direct messages (DMs) is only visible to you and your DM counterparty, everyone can see when you and your counterparty DM each other.
 
 # Visibility & Permanence of Your Content on nostr
 ## Information Visibility ##
 Content that you share can be shared to other relays. 
-Information that you share is publicly visible to anyone reading from relays that have your information. Your information may also be visible to nostr users who do not share relays with you.
+Information that you share publicly is visible to anyone reading from relays that have your information. Your information may also be visible to nostr users who do not share relays with you.
 
 ## Information Permanence ##
-Information shared on nostr should be assumed permanent for privacy purposes. There is no way to guarantee deleting or editing any content once posted. 
+Information shared on nostr should be assumed permanent for privacy purposes. There is no way to guarantee edit or deletion of any content once posted. 
 
 # Screenshots
 

app/build.gradle

@@ -1,7 +1,7 @@
 plugins {
     id 'com.android.application'
     id 'org.jetbrains.kotlin.android'
-    id 'org.jlleitschuh.gradle.ktlint' version "11.5.1"
+    id 'org.jlleitschuh.gradle.ktlint' version "11.6.1"
     id 'com.google.gms.google-services'
 }
 
@@ -13,8 +13,8 @@ android {
         applicationId "com.vitorpamplona.amethyst"
         minSdk 26
         targetSdk 34
-        versionCode 294
-        versionName "0.76.0"
+        versionCode 315
+        versionName "0.79.6"
 
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
         vectorDrawables {
@@ -89,7 +89,7 @@ android {
 dependencies {
     implementation project(path: ':quartz')
     implementation "androidx.core:core-ktx:$core_ktx_version"
-    implementation 'androidx.activity:activity-compose:1.7.2'
+    implementation 'androidx.activity:activity-compose:1.8.0'
     implementation "androidx.compose.ui:ui:$compose_ui_version"
     implementation "androidx.compose.ui:ui-tooling-preview:$compose_ui_version"
 
@@ -102,7 +102,7 @@ dependencies {
     // Observe Live data as State
     implementation "androidx.compose.runtime:runtime-livedata:$compose_ui_version"
 
-    implementation "androidx.compose.material:material:$compose_ui_version"
+    implementation "androidx.compose.material3:material3:${material3_version}"
     implementation "androidx.compose.material:material-icons-extended:$compose_ui_version"
 
     // Lifecycle
@@ -112,7 +112,7 @@ dependencies {
     implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version"
 
     // Zoomable images
-    implementation "net.engawapg.lib:zoomable:1.5.0"
+    implementation 'net.engawapg.lib:zoomable:1.5.1'
 
     // Biometrics
     implementation "androidx.biometric:biometric-ktx:1.2.0-alpha05"
@@ -155,7 +155,7 @@ dependencies {
 
     // Markdown (With fix for full-image bleeds)
     implementation('com.github.vitorpamplona.compose-richtext:richtext-ui:a0954aba63')
-    implementation('com.github.vitorpamplona.compose-richtext:richtext-ui-material:a0954aba63')
+    implementation('com.github.vitorpamplona.compose-richtext:richtext-ui-material3:a0954aba63')
     implementation('com.github.vitorpamplona.compose-richtext:richtext-commonmark:a0954aba63')
 
     // Language picker and Theme chooser
@@ -171,7 +171,7 @@ dependencies {
     playImplementation 'com.google.mlkit:translate:17.0.1'
 
     // PushNotifications
-    playImplementation platform('com.google.firebase:firebase-bom:32.2.3')
+    playImplementation platform('com.google.firebase:firebase-bom:32.3.1')
     playImplementation 'com.google.firebase:firebase-messaging-ktx'
 
     // Charts
@@ -192,7 +192,7 @@ dependencies {
     implementation 'id.zelory:compressor:3.0.1'
 
     testImplementation 'junit:junit:4.13.2'
-    testImplementation 'io.mockk:mockk:1.13.7'
+    testImplementation 'io.mockk:mockk:1.13.8'
     androidTestImplementation 'androidx.test.ext:junit:1.2.0-alpha01'
     androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'
     androidTestImplementation "androidx.compose.ui:ui-test-junit4:$compose_ui_version"
@@ -200,10 +200,6 @@ dependencies {
     debugImplementation "androidx.compose.ui:ui-test-manifest:$compose_ui_version"
 }
 
-ktlint {
-    disabledRules.set(["no-wildcard-imports"])
-}
-
 // https://gitlab.com/fdroid/wiki/-/wikis/HOWTO:-diff-&-fix-APKs-for-Reproducible-Builds#differing-assetsdexoptbaselineprofm-easy-to-fix
 // NB: Android Studio can't find the imports; this does not affect the
 // actual build since Gradle can find them just fine.

app/src/androidTest/java/com/vitorpamplona/amethyst/RichTextParserTest.kt

@@ -3,7 +3,7 @@ package com.vitorpamplona.amethyst
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.vitorpamplona.amethyst.service.RichTextParser
 import com.vitorpamplona.amethyst.service.RichTextViewerState
-import com.vitorpamplona.quartz.events.ImmutableListOfLists
+import com.vitorpamplona.quartz.events.EmptyTagList
 import org.junit.Assert
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -666,7 +666,7 @@ class RichTextParserTest {
 
     @Test
     fun testTextToParse() {
-        val state = RichTextParser().parseText(textToParse, ImmutableListOfLists())
+        val state = RichTextParser().parseText(textToParse, EmptyTagList)
         Assert.assertEquals(
             "relay.shitforce.one, relayable.org, universe.nostrich.land, nos.lol, universe.nostrich.land?lang=zh, universe.nostrich.land?lang=en, relay.damus.io, relay.nostr.wirednet.jp, offchain.pub, nostr.rocks, relay.wellorder.net, nostr.oxtr.dev, universe.nostrich.land?lang=ja, relay.mostr.pub, nostr.bitcoiner.social, Nostr-Check.com, MR.Rabbit, Ancap.su, zapper.lol, smies.me, baller.hodl",
             state.urlSet.joinToString(", ")
@@ -3989,7 +3989,7 @@ class RichTextParserTest {
 
     @Test
     fun testShortTextToParse() {
-        val state = RichTextParser().parseText("Hi, how are you doing? ", ImmutableListOfLists())
+        val state = RichTextParser().parseText("Hi, how are you doing? ", EmptyTagList)
         Assert.assertTrue(state.urlSet.isEmpty())
         Assert.assertTrue(state.imagesForPager.isEmpty())
         Assert.assertTrue(state.imageList.isEmpty())
@@ -3999,7 +3999,7 @@ class RichTextParserTest {
 
     @Test
     fun testShortNewLinesTextToParse() {
-        val state = RichTextParser().parseText("\nHi, \nhow\n\n\n are you doing? \n", ImmutableListOfLists())
+        val state = RichTextParser().parseText("\nHi, \nhow\n\n\n are you doing? \n", EmptyTagList)
         Assert.assertTrue(state.urlSet.isEmpty())
         Assert.assertTrue(state.imagesForPager.isEmpty())
         Assert.assertTrue(state.imageList.isEmpty())
@@ -4019,7 +4019,7 @@ See how it can be done here: https://lnshort.it/live-stream-embeds/
 https://nostr.build/i/fd53fcf5ad950fbe45127e4bcee1b59e8301d41de6beee211f45e344db214e8a.jpg
         """.trimIndent()
 
-        val state = RichTextParser().parseText(text, ImmutableListOfLists())
+        val state = RichTextParser().parseText(text, EmptyTagList)
         Assert.assertEquals("https://lnshort.it/live-stream-embeds/", state.urlSet.firstOrNull())
         Assert.assertEquals("https://nostr.build/i/fd53fcf5ad950fbe45127e4bcee1b59e8301d41de6beee211f45e344db214e8a.jpg", state.imagesForPager.keys.firstOrNull())
         Assert.assertEquals("https://nostr.build/i/fd53fcf5ad950fbe45127e4bcee1b59e8301d41de6beee211f45e344db214e8a.jpg", state.imageList.firstOrNull()?.url)
@@ -4080,7 +4080,7 @@ https://nostr.build/i/fd53fcf5ad950fbe45127e4bcee1b59e8301d41de6beee211f45e344db
     fun testNewLineAfterImage() {
         val text = "That’s it ! That’s the #note https://cdn.nostr.build/i/1dc0726b6cb0f94a92bd66765ffb90f6c67e90c17bb957fc3d5d4782cbd73de7.jpg "
 
-        val state = RichTextParser().parseText(text, ImmutableListOfLists())
+        val state = RichTextParser().parseText(text, EmptyTagList)
 
         printStateForDebug(state)
 
@@ -4106,7 +4106,7 @@ https://nostr.build/i/fd53fcf5ad950fbe45127e4bcee1b59e8301d41de6beee211f45e344db
     fun testSapceAfterImage() {
         val text = "That’s it! https://cdn.nostr.build/i/1dc0726b6cb0f94a92bd66765ffb90f6c67e90c17bb957fc3d5d4782cbd73de7.jpg That’s the #note"
 
-        val state = RichTextParser().parseText(text, ImmutableListOfLists())
+        val state = RichTextParser().parseText(text, EmptyTagList)
 
         printStateForDebug(state)
 

app/src/fdroid/java/com/vitorpamplona/amethyst/service/notifications/PushNotificationUtils.kt

@@ -2,7 +2,8 @@ package com.vitorpamplona.amethyst.service.notifications
 
 import com.vitorpamplona.amethyst.AccountInfo
 
-class PushNotificationUtils {
-    fun init(accounts: List<AccountInfo>) {
+object PushNotificationUtils {
+    var hasInit: Boolean = true
+    suspend fun init(accounts: List<AccountInfo>) {
     }
 }

app/src/main/AndroidManifest.xml

@@ -3,6 +3,8 @@
     xmlns:tools="http://schemas.android.com/tools">
     <queries>
         <package android:name="org.torproject.android"/>
+        <package android:name="com.greenart7c3.nostrsigner"/>
+        <package android:name="com.greenart7c3.nostrsigner.debug"/>
     </queries>
 
     <!-- Doesn't require a camera -->
@@ -106,7 +108,7 @@
             tools:replace="screenOrientation" />
 
         <service
-            android:name=".PlaybackService"
+            android:name=".service.playback.PlaybackService"
             android:foregroundServiceType="mediaPlayback"
             android:stopWithTask="true"
             android:exported="true">

app/src/main/java/androidx/compose/material3/pullrefresh/PullRefresh.kt

@@ -0,0 +1,120 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.material3.pullrefresh
+
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.input.nestedscroll.NestedScrollConnection
+import androidx.compose.ui.input.nestedscroll.NestedScrollSource
+import androidx.compose.ui.input.nestedscroll.NestedScrollSource.Companion.Drag
+import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.platform.debugInspectorInfo
+import androidx.compose.ui.platform.inspectable
+import androidx.compose.ui.unit.Velocity
+
+/**
+ * A nested scroll modifier that provides scroll events to [state].
+ *
+ * Note that this modifier must be added above a scrolling container, such as a lazy column, in
+ * order to receive scroll events. For example:
+ *
+ * @sample androidx.compose.material.samples.PullRefreshSample
+ *
+ * @param state The [PullRefreshState] associated with this pull-to-refresh component.
+ * The state will be updated by this modifier.
+ * @param enabled If not enabled, all scroll delta and fling velocity will be ignored.
+ */
+// TODO(b/244423199): Move pullRefresh into its own material library similar to material-ripple.
+fun Modifier.pullRefresh(
+    state: PullRefreshState,
+    enabled: Boolean = true
+) = inspectable(
+    inspectorInfo = debugInspectorInfo {
+        name = "pullRefresh"
+        properties["state"] = state
+        properties["enabled"] = enabled
+    }
+) {
+    Modifier.pullRefresh(state::onPull, state::onRelease, enabled)
+}
+
+/**
+ * A nested scroll modifier that provides [onPull] and [onRelease] callbacks to aid building custom
+ * pull refresh components.
+ *
+ * Note that this modifier must be added above a scrolling container, such as a lazy column, in
+ * order to receive scroll events. For example:
+ *
+ * @sample androidx.compose.material.samples.CustomPullRefreshSample
+ *
+ * @param onPull Callback for dispatching vertical scroll delta, takes float pullDelta as argument.
+ * Positive delta (pulling down) is dispatched only if the child does not consume it (i.e. pulling
+ * down despite being at the top of a scrollable component), whereas negative delta (swiping up) is
+ * dispatched first (in case it is needed to push the indicator back up), and then the unconsumed
+ * delta is passed on to the child. The callback returns how much delta was consumed.
+ * @param onRelease Callback for when drag is released, takes float flingVelocity as argument.
+ * The callback returns how much velocity was consumed - in most cases this should only consume
+ * velocity if pull refresh has been dragged already and the velocity is positive (the fling is
+ * downwards), as an upwards fling should typically still scroll a scrollable component beneath the
+ * pullRefresh. This is invoked before any remaining velocity is passed to the child.
+ * @param enabled If not enabled, all scroll delta and fling velocity will be ignored and neither
+ * [onPull] nor [onRelease] will be invoked.
+ */
+fun Modifier.pullRefresh(
+    onPull: (pullDelta: Float) -> Float,
+    onRelease: suspend (flingVelocity: Float) -> Float,
+    enabled: Boolean = true
+) = inspectable(
+    inspectorInfo = debugInspectorInfo {
+        name = "pullRefresh"
+        properties["onPull"] = onPull
+        properties["onRelease"] = onRelease
+        properties["enabled"] = enabled
+    }
+) {
+    Modifier.nestedScroll(PullRefreshNestedScrollConnection(onPull, onRelease, enabled))
+}
+
+private class PullRefreshNestedScrollConnection(
+    private val onPull: (pullDelta: Float) -> Float,
+    private val onRelease: suspend (flingVelocity: Float) -> Float,
+    private val enabled: Boolean
+) : NestedScrollConnection {
+
+    override fun onPreScroll(
+        available: Offset,
+        source: NestedScrollSource
+    ): Offset = when {
+        !enabled -> Offset.Zero
+        source == Drag && available.y < 0 -> Offset(0f, onPull(available.y)) // Swiping up
+        else -> Offset.Zero
+    }
+
+    override fun onPostScroll(
+        consumed: Offset,
+        available: Offset,
+        source: NestedScrollSource
+    ): Offset = when {
+        !enabled -> Offset.Zero
+        source == Drag && available.y > 0 -> Offset(0f, onPull(available.y)) // Pulling down
+        else -> Offset.Zero
+    }
+
+    override suspend fun onPreFling(available: Velocity): Velocity {
+        return Velocity(0f, onRelease(available.y))
+    }
+}

app/src/main/java/androidx/compose/material3/pullrefresh/PullRefreshIndicator.kt

@@ -0,0 +1,238 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.material3.pullrefresh
+
+import androidx.compose.animation.Crossfade
+import androidx.compose.animation.core.LinearEasing
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.material3.contentColorFor
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.derivedStateOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Rect
+import androidx.compose.ui.geometry.center
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Path
+import androidx.compose.ui.graphics.PathFillType
+import androidx.compose.ui.graphics.StrokeCap
+import androidx.compose.ui.graphics.drawscope.DrawScope
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.graphics.drawscope.rotate
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.unit.dp
+import kotlin.math.abs
+import kotlin.math.max
+import kotlin.math.min
+import kotlin.math.pow
+
+/**
+ * The default indicator for Compose pull-to-refresh, based on Android's SwipeRefreshLayout.
+ *
+ * @sample androidx.compose.material.samples.PullRefreshSample
+ *
+ * @param refreshing A boolean representing whether a refresh is occurring.
+ * @param state The [PullRefreshState] which controls where and how the indicator will be drawn.
+ * @param modifier Modifiers for the indicator.
+ * @param backgroundColor The color of the indicator's background.
+ * @param contentColor The color of the indicator's arc and arrow.
+ * @param scale A boolean controlling whether the indicator's size scales with pull progress or not.
+ */
+// TODO(b/244423199): Consider whether the state parameter should be replaced with lambdas to
+//  enable people to use this indicator with custom pull-to-refresh components.
+@Composable
+fun PullRefreshIndicator(
+    refreshing: Boolean,
+    state: PullRefreshState,
+    modifier: Modifier = Modifier,
+    backgroundColor: Color = MaterialTheme.colorScheme.surface,
+    contentColor: Color = contentColorFor(backgroundColor),
+    scale: Boolean = false
+) {
+    val showElevation by remember(refreshing, state) {
+        derivedStateOf { refreshing || state.position > 0.5f }
+    }
+
+    Surface(
+        modifier = modifier
+            .size(IndicatorSize)
+            .pullRefreshIndicatorTransform(state, scale),
+        shape = SpinnerShape,
+        color = backgroundColor,
+        shadowElevation = if (showElevation) Elevation else 0.dp
+    ) {
+        Crossfade(
+            targetState = refreshing,
+            animationSpec = tween(durationMillis = CrossfadeDurationMs)
+        ) { refreshing ->
+            Box(
+                modifier = Modifier.fillMaxSize(),
+                contentAlignment = Alignment.Center
+            ) {
+                val spinnerSize = (ArcRadius + StrokeWidth).times(2)
+
+                if (refreshing) {
+                    CircularProgressIndicator(
+                        color = contentColor,
+                        strokeWidth = StrokeWidth,
+                        modifier = Modifier.size(spinnerSize)
+                    )
+                } else {
+                    CircularArrowIndicator(state, contentColor, Modifier.size(spinnerSize))
+                }
+            }
+        }
+    }
+}
+
+/**
+ * Modifier.size MUST be specified.
+ */
+@Composable
+private fun CircularArrowIndicator(
+    state: PullRefreshState,
+    color: Color,
+    modifier: Modifier
+) {
+    val path = remember { Path().apply { fillType = PathFillType.EvenOdd } }
+
+    val targetAlpha by remember(state) {
+        derivedStateOf {
+            if (state.progress >= 1f) MaxAlpha else MinAlpha
+        }
+    }
+
+    val alphaState = animateFloatAsState(targetValue = targetAlpha, animationSpec = AlphaTween)
+
+    // Empty semantics for tests
+    Canvas(modifier.semantics {}) {
+        val values = ArrowValues(state.progress)
+        val alpha = alphaState.value
+
+        rotate(degrees = values.rotation) {
+            val arcRadius = ArcRadius.toPx() + StrokeWidth.toPx() / 2f
+            val arcBounds = Rect(
+                size.center.x - arcRadius,
+                size.center.y - arcRadius,
+                size.center.x + arcRadius,
+                size.center.y + arcRadius
+            )
+            drawArc(
+                color = color,
+                alpha = alpha,
+                startAngle = values.startAngle,
+                sweepAngle = values.endAngle - values.startAngle,
+                useCenter = false,
+                topLeft = arcBounds.topLeft,
+                size = arcBounds.size,
+                style = Stroke(
+                    width = StrokeWidth.toPx(),
+                    cap = StrokeCap.Square
+                )
+            )
+            drawArrow(path, arcBounds, color, alpha, values)
+        }
+    }
+}
+
+@Immutable
+private class ArrowValues(
+    val rotation: Float,
+    val startAngle: Float,
+    val endAngle: Float,
+    val scale: Float
+)
+
+private fun ArrowValues(progress: Float): ArrowValues {
+    // Discard first 40% of progress. Scale remaining progress to full range between 0 and 100%.
+    val adjustedPercent = max(min(1f, progress) - 0.4f, 0f) * 5 / 3
+    // How far beyond the threshold pull has gone, as a percentage of the threshold.
+    val overshootPercent = abs(progress) - 1.0f
+    // Limit the overshoot to 200%. Linear between 0 and 200.
+    val linearTension = overshootPercent.coerceIn(0f, 2f)
+    // Non-linear tension. Increases with linearTension, but at a decreasing rate.
+    val tensionPercent = linearTension - linearTension.pow(2) / 4
+
+    // Calculations based on SwipeRefreshLayout specification.
+    val endTrim = adjustedPercent * MaxProgressArc
+    val rotation = (-0.25f + 0.4f * adjustedPercent + tensionPercent) * 0.5f
+    val startAngle = rotation * 360
+    val endAngle = (rotation + endTrim) * 360
+    val scale = min(1f, adjustedPercent)
+
+    return ArrowValues(rotation, startAngle, endAngle, scale)
+}
+
+private fun DrawScope.drawArrow(
+    arrow: Path,
+    bounds: Rect,
+    color: Color,
+    alpha: Float,
+    values: ArrowValues
+) {
+    arrow.reset()
+    arrow.moveTo(0f, 0f) // Move to left corner
+    arrow.lineTo(x = ArrowWidth.toPx() * values.scale, y = 0f) // Line to right corner
+
+    // Line to tip of arrow
+    arrow.lineTo(
+        x = ArrowWidth.toPx() * values.scale / 2,
+        y = ArrowHeight.toPx() * values.scale
+    )
+
+    val radius = min(bounds.width, bounds.height) / 2f
+    val inset = ArrowWidth.toPx() * values.scale / 2f
+    arrow.translate(
+        Offset(
+            x = radius + bounds.center.x - inset,
+            y = bounds.center.y + StrokeWidth.toPx() / 2f
+        )
+    )
+    arrow.close()
+    rotate(degrees = values.endAngle) {
+        drawPath(path = arrow, color = color, alpha = alpha)
+    }
+}
+
+private const val CrossfadeDurationMs = 100
+private const val MaxProgressArc = 0.8f
+
+private val IndicatorSize = 40.dp
+private val SpinnerShape = CircleShape
+private val ArcRadius = 7.5.dp
+private val StrokeWidth = 2.5.dp
+private val ArrowWidth = 10.dp
+private val ArrowHeight = 5.dp
+private val Elevation = 6.dp
+
+// Values taken from SwipeRefreshLayout
+private const val MinAlpha = 0.3f
+private const val MaxAlpha = 1f
+private val AlphaTween = tween<Float>(300, easing = LinearEasing)

app/src/main/java/androidx/compose/material3/pullrefresh/PullRefreshIndicatorTransform.kt

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.material3.pullrefresh
+
+import androidx.compose.animation.core.LinearOutSlowInEasing
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.drawWithContent
+import androidx.compose.ui.graphics.drawscope.clipRect
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.platform.debugInspectorInfo
+import androidx.compose.ui.platform.inspectable
+
+/**
+ * A modifier for translating the position and scaling the size of a pull-to-refresh indicator
+ * based on the given [PullRefreshState].
+ *
+ * @sample androidx.compose.material.samples.PullRefreshIndicatorTransformSample
+ *
+ * @param state The [PullRefreshState] which determines the position of the indicator.
+ * @param scale A boolean controlling whether the indicator's size scales with pull progress or not.
+ */
+// TODO: Consider whether the state parameter should be replaced with lambdas.
+fun Modifier.pullRefreshIndicatorTransform(
+    state: PullRefreshState,
+    scale: Boolean = false
+) = inspectable(
+    inspectorInfo = debugInspectorInfo {
+        name = "pullRefreshIndicatorTransform"
+        properties["state"] = state
+        properties["scale"] = scale
+    }
+) {
+    Modifier
+        // Essentially we only want to clip the at the top, so the indicator will not appear when
+        // the position is 0. It is preferable to clip the indicator as opposed to the layout that
+        // contains the indicator, as this would also end up clipping shadows drawn by items in a
+        // list for example - so we leave the clipping to the scrolling container. We use MAX_VALUE
+        // for the other dimensions to allow for more room for elevation / arbitrary indicators - we
+        // only ever really want to clip at the top edge.
+        .drawWithContent {
+            clipRect(
+                top = 0f,
+                left = -Float.MAX_VALUE,
+                right = Float.MAX_VALUE,
+                bottom = Float.MAX_VALUE
+            ) {
+                this@drawWithContent.drawContent()
+            }
+        }
+        .graphicsLayer {
+            translationY = state.position - size.height
+
+            if (scale && !state.refreshing) {
+                val scaleFraction = LinearOutSlowInEasing
+                    .transform(state.position / state.threshold)
+                    .coerceIn(0f, 1f)
+                scaleX = scaleFraction
+                scaleY = scaleFraction
+            }
+        }
+}

app/src/main/java/androidx/compose/material3/pullrefresh/PullRefreshState.kt

@@ -0,0 +1,228 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.material3.pullrefresh
+
+import androidx.compose.animation.core.animate
+import androidx.compose.foundation.MutatorMutex
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.SideEffect
+import androidx.compose.runtime.State
+import androidx.compose.runtime.derivedStateOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import kotlin.math.abs
+import kotlin.math.pow
+
+/**
+ * Creates a [PullRefreshState] that is remembered across compositions.
+ *
+ * Changes to [refreshing] will result in [PullRefreshState] being updated.
+ *
+ * @sample androidx.compose.material.samples.PullRefreshSample
+ *
+ * @param refreshing A boolean representing whether a refresh is currently occurring.
+ * @param onRefresh The function to be called to trigger a refresh.
+ * @param refreshThreshold The threshold below which, if a release
+ * occurs, [onRefresh] will be called.
+ * @param refreshingOffset The offset at which the indicator will be drawn while refreshing. This
+ * offset corresponds to the position of the bottom of the indicator.
+ */
+@Composable
+fun rememberPullRefreshState(
+    refreshing: Boolean,
+    onRefresh: () -> Unit,
+    refreshThreshold: Dp = PullRefreshDefaults.RefreshThreshold,
+    refreshingOffset: Dp = PullRefreshDefaults.RefreshingOffset
+): PullRefreshState {
+    require(refreshThreshold > 0.dp) { "The refresh trigger must be greater than zero!" }
+
+    val scope = rememberCoroutineScope()
+    val onRefreshState = rememberUpdatedState(onRefresh)
+    val thresholdPx: Float
+    val refreshingOffsetPx: Float
+
+    with(LocalDensity.current) {
+        thresholdPx = refreshThreshold.toPx()
+        refreshingOffsetPx = refreshingOffset.toPx()
+    }
+
+    val state = remember(scope) {
+        PullRefreshState(scope, onRefreshState, refreshingOffsetPx, thresholdPx)
+    }
+
+    SideEffect {
+        state.setRefreshing(refreshing)
+        state.setThreshold(thresholdPx)
+        state.setRefreshingOffset(refreshingOffsetPx)
+    }
+
+    return state
+}
+
+/**
+ * A state object that can be used in conjunction with [pullRefresh] to add pull-to-refresh
+ * behaviour to a scroll component. Based on Android's SwipeRefreshLayout.
+ *
+ * Provides [progress], a float representing how far the user has pulled as a percentage of the
+ * refreshThreshold. Values of one or less indicate that the user has not yet pulled past the
+ * threshold. Values greater than one indicate how far past the threshold the user has pulled.
+ *
+ * Can be used in conjunction with [pullRefreshIndicatorTransform] to implement Android-like
+ * pull-to-refresh behaviour with a custom indicator.
+ *
+ * Should be created using [rememberPullRefreshState].
+ */
+class PullRefreshState internal constructor(
+    private val animationScope: CoroutineScope,
+    private val onRefreshState: State<() -> Unit>,
+    refreshingOffset: Float,
+    threshold: Float
+) {
+    /**
+     * A float representing how far the user has pulled as a percentage of the refreshThreshold.
+     *
+     * If the component has not been pulled at all, progress is zero. If the pull has reached
+     * halfway to the threshold, progress is 0.5f. A value greater than 1 indicates that pull has
+     * gone beyond the refreshThreshold - e.g. a value of 2f indicates that the user has pulled to
+     * two times the refreshThreshold.
+     */
+    val progress get() = adjustedDistancePulled / threshold
+
+    internal val refreshing get() = _refreshing
+    internal val position get() = _position
+    internal val threshold get() = _threshold
+
+    private val adjustedDistancePulled by derivedStateOf { distancePulled * DragMultiplier }
+
+    private var _refreshing by mutableStateOf(false)
+    private var _position by mutableStateOf(0f)
+    private var distancePulled by mutableStateOf(0f)
+    private var _threshold by mutableStateOf(threshold)
+    private var _refreshingOffset by mutableStateOf(refreshingOffset)
+
+    internal fun onPull(pullDelta: Float): Float {
+        if (_refreshing) return 0f // Already refreshing, do nothing.
+
+        val newOffset = (distancePulled + pullDelta).coerceAtLeast(0f)
+        val dragConsumed = newOffset - distancePulled
+        distancePulled = newOffset
+        _position = calculateIndicatorPosition()
+        return dragConsumed
+    }
+
+    internal fun onRelease(velocity: Float): Float {
+        if (refreshing) return 0f // Already refreshing, do nothing
+
+        if (adjustedDistancePulled > threshold) {
+            onRefreshState.value()
+        }
+        animateIndicatorTo(0f)
+        val consumed = when {
+            // We are flinging without having dragged the pull refresh (for example a fling inside
+            // a list) - don't consume
+            distancePulled == 0f -> 0f
+            // If the velocity is negative, the fling is upwards, and we don't want to prevent the
+            // the list from scrolling
+            velocity < 0f -> 0f
+            // We are showing the indicator, and the fling is downwards - consume everything
+            else -> velocity
+        }
+        distancePulled = 0f
+        return consumed
+    }
+
+    internal fun setRefreshing(refreshing: Boolean) {
+        if (_refreshing != refreshing) {
+            _refreshing = refreshing
+            distancePulled = 0f
+            animateIndicatorTo(if (refreshing) _refreshingOffset else 0f)
+        }
+    }
+
+    internal fun setThreshold(threshold: Float) {
+        _threshold = threshold
+    }
+
+    internal fun setRefreshingOffset(refreshingOffset: Float) {
+        if (_refreshingOffset != refreshingOffset) {
+            _refreshingOffset = refreshingOffset
+            if (refreshing) animateIndicatorTo(refreshingOffset)
+        }
+    }
+
+    // Make sure to cancel any existing animations when we launch a new one. We use this instead of
+    // Animatable as calling snapTo() on every drag delta has a one frame delay, and some extra
+    // overhead of running through the animation pipeline instead of directly mutating the state.
+    private val mutatorMutex = MutatorMutex()
+
+    private fun animateIndicatorTo(offset: Float) = animationScope.launch {
+        mutatorMutex.mutate {
+            animate(initialValue = _position, targetValue = offset) { value, _ ->
+                _position = value
+            }
+        }
+    }
+
+    private fun calculateIndicatorPosition(): Float = when {
+        // If drag hasn't gone past the threshold, the position is the adjustedDistancePulled.
+        adjustedDistancePulled <= threshold -> adjustedDistancePulled
+        else -> {
+            // How far beyond the threshold pull has gone, as a percentage of the threshold.
+            val overshootPercent = abs(progress) - 1.0f
+            // Limit the overshoot to 200%. Linear between 0 and 200.
+            val linearTension = overshootPercent.coerceIn(0f, 2f)
+            // Non-linear tension. Increases with linearTension, but at a decreasing rate.
+            val tensionPercent = linearTension - linearTension.pow(2) / 4
+            // The additional offset beyond the threshold.
+            val extraOffset = threshold * tensionPercent
+            threshold + extraOffset
+        }
+    }
+}
+
+/**
+ * Default parameter values for [rememberPullRefreshState].
+ */
+object PullRefreshDefaults {
+    /**
+     * If the indicator is below this threshold offset when it is released, a refresh
+     * will be triggered.
+     */
+    val RefreshThreshold = 80.dp
+
+    /**
+     * The offset at which the indicator should be rendered whilst a refresh is occurring.
+     */
+    val RefreshingOffset = 56.dp
+}
+
+/**
+ * The distance pulled is multiplied by this value to give us the adjusted distance pulled, which
+ * is used in calculating the indicator position (when the adjusted distance pulled is less than
+ * the refresh threshold, it is the indicator position, otherwise the indicator position is
+ * derived from the progress).
+ */
+private const val DragMultiplier = 0.5f

app/src/main/java/com/vitorpamplona/amethyst/Amethyst.kt

@@ -4,6 +4,7 @@ import android.app.Application
 import android.os.StrictMode
 import android.os.StrictMode.ThreadPolicy
 import android.os.StrictMode.VmPolicy
+import com.vitorpamplona.amethyst.service.playback.VideoCache
 
 class Amethyst : Application() {
     @androidx.annotation.OptIn(androidx.media3.common.util.UnstableApi::class)

app/src/main/java/com/vitorpamplona/amethyst/LocalPreferences.kt

@@ -3,23 +3,26 @@ package com.vitorpamplona.amethyst
 import android.annotation.SuppressLint
 import android.content.Context
 import android.content.SharedPreferences
+import android.util.Log
 import androidx.compose.runtime.Immutable
 import com.fasterxml.jackson.module.kotlin.readValue
 import com.vitorpamplona.amethyst.model.Account
+import com.vitorpamplona.amethyst.model.BooleanType
 import com.vitorpamplona.amethyst.model.ConnectivityType
+import com.vitorpamplona.amethyst.model.DefaultReactions
+import com.vitorpamplona.amethyst.model.DefaultZapAmounts
 import com.vitorpamplona.amethyst.model.GLOBAL_FOLLOWS
 import com.vitorpamplona.amethyst.model.KIND3_FOLLOWS
 import com.vitorpamplona.amethyst.model.Nip47URI
 import com.vitorpamplona.amethyst.model.RelaySetupInfo
 import com.vitorpamplona.amethyst.model.ServersAvailable
 import com.vitorpamplona.amethyst.model.Settings
+import com.vitorpamplona.amethyst.model.parseBooleanType
 import com.vitorpamplona.amethyst.model.parseConnectivityType
 import com.vitorpamplona.amethyst.service.HttpClient
 import com.vitorpamplona.quartz.crypto.KeyPair
-import com.vitorpamplona.quartz.encoders.Hex
 import com.vitorpamplona.quartz.encoders.hexToByteArray
 import com.vitorpamplona.quartz.encoders.toHexKey
-import com.vitorpamplona.quartz.encoders.toNpub
 import com.vitorpamplona.quartz.events.ContactListEvent
 import com.vitorpamplona.quartz.events.Event
 import com.vitorpamplona.quartz.events.LnZapEvent
@@ -35,7 +38,8 @@ private const val DEBUG_PREFERENCES_NAME = "debug_prefs"
 @Immutable
 data class AccountInfo(
     val npub: String,
-    val hasPrivKey: Boolean = false
+    val hasPrivKey: Boolean,
+    val loggedInWithExternalSigner: Boolean
 )
 
 private object PrefKeys {
@@ -74,15 +78,18 @@ private object PrefKeys {
     const val THEME = "theme"
     const val PREFERRED_LANGUAGE = "preferred_Language"
     const val AUTOMATICALLY_LOAD_URL_PREVIEW = "automatically_load_url_preview"
-    val LAST_READ: (String) -> String = { route -> "last_read_route_$route" }
+    const val AUTOMATICALLY_HIDE_NAV_BARS = "automatically_hide_nav_bars"
+    const val LOGIN_WITH_EXTERNAL_SIGNER = "login_with_external_signer"
+    const val AUTOMATICALLY_SHOW_PROFILE_PICTURE = "automatically_show_profile_picture"
 }
 
 object LocalPreferences {
     private const val comma = ","
 
     private var _currentAccount: String? = null
+    private var _savedAccounts: List<String>? = null
 
-    private fun currentAccount(): String? {
+    fun currentAccount(): String? {
         if (_currentAccount == null) {
             _currentAccount = encryptedPreferences().getString(PrefKeys.CURRENT_ACCOUNT, null)
         }
@@ -99,8 +106,6 @@ object LocalPreferences {
         }
     }
 
-    private var _savedAccounts: List<String>? = null
-
     private fun savedAccounts(): List<String> {
         if (_savedAccounts == null) {
             _savedAccounts = encryptedPreferences()
@@ -201,7 +206,11 @@ object LocalPreferences {
 
     fun allSavedAccounts(): List<AccountInfo> {
         return savedAccounts().map { npub ->
-            AccountInfo(npub = npub)
+            AccountInfo(
+                npub,
+                hasPrivKey(npub),
+                getLoggedInWithExternalSigner(npub)
+            )
         }
     }
 
@@ -245,6 +254,7 @@ object LocalPreferences {
             } else {
                 putBoolean(PrefKeys.SHOW_SENSITIVE_CONTENT, account.showSensitiveContent!!)
             }
+            putBoolean(PrefKeys.LOGIN_WITH_EXTERNAL_SIGNER, account.loginWithExternalSigner)
         }.apply()
 
         val globalPrefs = encryptedPreferences()
@@ -265,6 +275,17 @@ object LocalPreferences {
             } else {
                 putBoolean(PrefKeys.AUTOMATICALLY_LOAD_URL_PREVIEW, account.settings.automaticallyShowUrlPreview.prefCode!!)
             }
+            if (account.settings.automaticallyHideNavigationBars.prefCode == null) {
+                remove(PrefKeys.AUTOMATICALLY_HIDE_NAV_BARS)
+            } else {
+                putBoolean(PrefKeys.AUTOMATICALLY_HIDE_NAV_BARS, account.settings.automaticallyHideNavigationBars.prefCode!!)
+            }
+
+            if (account.settings.automaticallyShowProfilePictures.prefCode == null) {
+                remove(PrefKeys.AUTOMATICALLY_SHOW_PROFILE_PICTURE)
+            } else {
+                putBoolean(PrefKeys.AUTOMATICALLY_SHOW_PROFILE_PICTURE, account.settings.automaticallyShowProfilePictures.prefCode!!)
+            }
             putString(PrefKeys.PREFERRED_LANGUAGE, account.settings.preferredLanguage ?: "")
         }.apply()
     }
@@ -276,17 +297,19 @@ object LocalPreferences {
     }
 
     fun getTheme(): Int {
-        encryptedPreferences().apply {
-            return getInt(PrefKeys.THEME, 0)
-        }
+        return encryptedPreferences().getInt(PrefKeys.THEME, 0)
     }
 
     fun getPreferredLanguage(): String {
-        var language = ""
-        encryptedPreferences().apply {
-            language = getString(PrefKeys.PREFERRED_LANGUAGE, "") ?: ""
-        }
-        return language
+        return encryptedPreferences().getString(PrefKeys.PREFERRED_LANGUAGE, "") ?: ""
+    }
+
+    private fun getLoggedInWithExternalSigner(npub: String): Boolean {
+        return encryptedPreferences(npub).getBoolean(PrefKeys.LOGIN_WITH_EXTERNAL_SIGNER, false)
+    }
+
+    private fun hasPrivKey(npub: String): Boolean {
+        return (encryptedPreferences(npub).getString(PrefKeys.NOSTR_PRIVKEY, "") ?: "").isNotBlank()
     }
 
     fun loadFromEncryptedStorage(): Account? {
@@ -316,11 +339,11 @@ object LocalPreferences {
 
             val zapAmountChoices = getString(PrefKeys.ZAP_AMOUNTS, "[]")?.let {
                 Event.mapper.readValue<List<Long>?>(it)
-            }?.ifEmpty { listOf(500L, 1000L, 5000L) } ?: listOf(500L, 1000L, 5000L)
+            }?.ifEmpty { DefaultZapAmounts } ?: DefaultZapAmounts
 
             val reactionChoices = getString(PrefKeys.REACTION_CHOICES, "[]")?.let {
                 Event.mapper.readValue<List<String>?>(it)
-            }?.ifEmpty { listOf("+") } ?: listOf("+")
+            }?.ifEmpty { DefaultReactions } ?: DefaultReactions
 
             val defaultZapType = getString(PrefKeys.DEFAULT_ZAPTYPE, "")?.let { serverName ->
                 LnZapEvent.ZapType.values().firstOrNull() { it.name == serverName }
@@ -335,16 +358,22 @@ object LocalPreferences {
                     Event.mapper.readValue<Nip47URI?>(it)
                 }
             } catch (e: Throwable) {
+                Log.w("LocalPreferences", "Error Decoding Zap Payment Request Server ${getString(PrefKeys.ZAP_PAYMENT_REQUEST_SERVER, null)}", e)
                 e.printStackTrace()
                 null
             }
 
             val latestContactList = try {
                 getString(PrefKeys.LATEST_CONTACT_LIST, null)?.let {
-                    Event.fromJson(it) as ContactListEvent?
+                    println("Decoding Contact List: " + it)
+                    if (it != null) {
+                        Event.fromJson(it) as ContactListEvent?
+                    } else {
+                        null
+                    }
                 }
             } catch (e: Throwable) {
-                e.printStackTrace()
+                Log.w("LocalPreferences", "Error Decoding Contact List ${getString(PrefKeys.LATEST_CONTACT_LIST, null)}", e)
                 null
             }
 
@@ -353,6 +382,7 @@ object LocalPreferences {
                     Event.mapper.readValue<Map<String, String>?>(it)
                 } ?: mapOf()
             } catch (e: Throwable) {
+                Log.w("LocalPreferences", "Error Decoding Language Preferences ${getString(PrefKeys.LANGUAGE_PREFS, null)}", e)
                 e.printStackTrace()
                 mapOf()
             }
@@ -363,6 +393,7 @@ object LocalPreferences {
             val useProxy = getBoolean(PrefKeys.USE_PROXY, false)
             val proxyPort = getInt(PrefKeys.PROXY_PORT, 9050)
             val proxy = HttpClient.initProxy(useProxy, "127.0.0.1", proxyPort)
+            val loginWithExternalSigner = getBoolean(PrefKeys.LOGIN_WITH_EXTERNAL_SIGNER, false)
 
             val showSensitiveContent = if (contains(PrefKeys.SHOW_SENSITIVE_CONTENT)) {
                 getBoolean(PrefKeys.SHOW_SENSITIVE_CONTENT, false)
@@ -377,6 +408,7 @@ object LocalPreferences {
                     Event.mapper.readValue<Map<String, Long>?>(it)
                 } ?: mapOf()
             } catch (e: Throwable) {
+                Log.w("LocalPreferences", "Error Decoding Last Read per route ${getString(PrefKeys.LAST_READ_PER_ROUTE, null)}", e)
                 e.printStackTrace()
                 mapOf()
             }
@@ -399,6 +431,17 @@ object LocalPreferences {
                 } else {
                     ConnectivityType.ALWAYS
                 }
+                settings.automaticallyHideNavigationBars = if (contains(PrefKeys.AUTOMATICALLY_HIDE_NAV_BARS)) {
+                    parseBooleanType(getBoolean(PrefKeys.AUTOMATICALLY_HIDE_NAV_BARS, false))
+                } else {
+                    BooleanType.ALWAYS
+                }
+
+                settings.automaticallyShowProfilePictures = if (contains(PrefKeys.AUTOMATICALLY_SHOW_PROFILE_PICTURE)) {
+                    parseConnectivityType(getBoolean(PrefKeys.AUTOMATICALLY_SHOW_PROFILE_PICTURE, false))
+                } else {
+                    ConnectivityType.ALWAYS
+                }
 
                 settings.preferredLanguage = getString(PrefKeys.PREFERRED_LANGUAGE, "")
             }
@@ -431,51 +474,11 @@ object LocalPreferences {
                 warnAboutPostsWithReports = warnAboutReports,
                 filterSpamFromStrangers = filterSpam,
                 lastReadPerRoute = lastReadPerRoute,
-                settings = settings
+                settings = settings,
+                loginWithExternalSigner = loginWithExternalSigner
             )
 
             return a
         }
     }
-
-    fun migrateSingleUserPrefs() {
-        if (currentAccount() != null) return
-
-        val pubkey = encryptedPreferences().getString(PrefKeys.NOSTR_PUBKEY, null) ?: return
-        val npub = Hex.decode(pubkey).toNpub()
-
-        val stringPrefs = listOf(
-            PrefKeys.NOSTR_PRIVKEY,
-            PrefKeys.NOSTR_PUBKEY,
-            PrefKeys.RELAYS,
-            PrefKeys.LANGUAGE_PREFS,
-            PrefKeys.TRANSLATE_TO,
-            PrefKeys.ZAP_AMOUNTS,
-            PrefKeys.LATEST_CONTACT_LIST
-        )
-
-        val stringSetPrefs = listOf(
-            PrefKeys.FOLLOWING_CHANNELS,
-            PrefKeys.HIDDEN_USERS,
-            PrefKeys.DONT_TRANSLATE_FROM
-        )
-
-        encryptedPreferences().apply {
-            val appPrefs = this
-            encryptedPreferences(npub).edit().apply {
-                val userPrefs = this
-
-                stringPrefs.forEach { userPrefs.putString(it, appPrefs.getString(it, null)) }
-                stringSetPrefs.forEach { userPrefs.putStringSet(it, appPrefs.getStringSet(it, null)) }
-                userPrefs.putBoolean(
-                    PrefKeys.HIDE_DELETE_REQUEST_DIALOG,
-                    appPrefs.getBoolean(PrefKeys.HIDE_DELETE_REQUEST_DIALOG, false)
-                )
-            }.apply()
-        }
-
-        encryptedPreferences().edit().clear().apply()
-        addAccount(npub)
-        updateCurrentAccount(npub)
-    }
 }

app/src/main/java/com/vitorpamplona/amethyst/ServiceManager.kt

@@ -12,6 +12,7 @@ import coil.disk.DiskCache
 import coil.util.DebugLogger
 import com.vitorpamplona.amethyst.model.Account
 import com.vitorpamplona.amethyst.model.LocalCache
+import com.vitorpamplona.amethyst.service.ExternalSignerUtils
 import com.vitorpamplona.amethyst.service.HttpClient
 import com.vitorpamplona.amethyst.service.NostrAccountDataSource
 import com.vitorpamplona.amethyst.service.NostrChannelDataSource
@@ -32,18 +33,28 @@ import com.vitorpamplona.amethyst.service.NostrVideoDataSource
 import com.vitorpamplona.amethyst.service.relays.Client
 import com.vitorpamplona.amethyst.ui.actions.ImageUploader
 import com.vitorpamplona.quartz.encoders.decodePublicKeyAsHexOrNull
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
 import java.io.File
 
 object ServiceManager {
+    var shouldPauseService: Boolean = true // to not open amber in a loop trying to use auth relays and registering for notifications
+    private var isStarted: Boolean = false // to not open amber in a loop trying to use auth relays and registering for notifications
     private var account: Account? = null
 
     fun start(account: Account, context: Context) {
         this.account = account
+        ExternalSignerUtils.account = account
         start(context)
     }
 
     @Synchronized
     fun start(context: Context) {
+        if (isStarted && account != null) {
+            return
+        }
         Log.d("ServiceManager", "Starting Relay Services")
 
         val myAccount = account
@@ -80,14 +91,18 @@ object ServiceManager {
             // Notification Elements
             NostrHomeDataSource.start()
             NostrAccountDataSource.start()
-            NostrChatroomListDataSource.start()
-            NostrDiscoveryDataSource.start()
-            NostrVideoDataSource.start()
+            GlobalScope.launch(Dispatchers.IO) {
+                delay(3000)
+                NostrChatroomListDataSource.start()
+                NostrDiscoveryDataSource.start()
+                NostrVideoDataSource.start()
+            }
 
             // More Info Data Sources
             NostrSingleEventDataSource.start()
             NostrSingleChannelDataSource.start()
             NostrSingleUserDataSource.start()
+            isStarted = true
         }
     }
 
@@ -113,6 +128,7 @@ object ServiceManager {
         NostrVideoDataSource.stop()
 
         Client.disconnect()
+        isStarted = false
     }
 
     fun cleanObservers() {
@@ -126,6 +142,8 @@ object ServiceManager {
 
         account?.let {
             LocalCache.pruneOldAndHiddenMessages(it)
+            NostrChatroomDataSource.clearEOSEs(it)
+
             LocalCache.pruneHiddenMessages(it)
             LocalCache.pruneContactLists(accounts)
             LocalCache.pruneRepliesAndReactions(accounts)
@@ -133,6 +151,13 @@ object ServiceManager {
             LocalCache.pruneExpiredEvents()
         }
     }
+
+    fun restartIfDifferentAccount(account: Account, context: Context) {
+        if (this.account != account) {
+            pause()
+            start(account, context)
+        }
+    }
 }
 
 object SingletonDiskCache {

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

@@ -8,7 +8,7 @@ import com.vitorpamplona.amethyst.R
 fun checkForHashtagWithIcon(tag: String, primary: Color): HashtagIcon? {
     return when (tag.lowercase()) {
         "bitcoin", "btc", "timechain", "bitcoiner", "bitcoiners" -> HashtagIcon(R.drawable.ht_btc, "Bitcoin", Color.Unspecified, Modifier.padding(2.dp, 2.dp, 0.dp, 0.dp))
-        "nostr", "nostrich", "nostriches" -> HashtagIcon(R.drawable.ht_nostr, "Nostr", Color.Unspecified, Modifier.padding(1.dp, 2.dp, 0.dp, 0.dp))
+        "nostr", "nostrich", "nostriches", "thenostr" -> HashtagIcon(R.drawable.ht_nostr, "Nostr", Color.Unspecified, Modifier.padding(1.dp, 2.dp, 0.dp, 0.dp))
         "lightning", "lightningnetwork" -> HashtagIcon(R.drawable.ht_lightning, "Lightning", Color.Unspecified, Modifier.padding(1.dp, 3.dp, 0.dp, 0.dp))
         "zap", "zaps", "zapper", "zappers", "zapping", "zapped", "zapathon", "zapraiser", "zaplife", "zapchain" -> HashtagIcon(R.drawable.zap, "Zap", Color.Unspecified, Modifier.padding(1.dp, 3.dp, 0.dp, 0.dp))
         "amethyst" -> HashtagIcon(R.drawable.amethyst, "Amethyst", Color.Unspecified, Modifier.padding(3.dp, 2.dp, 0.dp, 0.dp))

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

@@ -3,6 +3,8 @@ package com.vitorpamplona.amethyst.model
 import android.util.Log
 import androidx.compose.runtime.Stable
 import com.vitorpamplona.amethyst.Amethyst
+import com.vitorpamplona.amethyst.LocalPreferences
+import com.vitorpamplona.amethyst.service.ExternalSignerUtils
 import com.vitorpamplona.amethyst.service.checkNotInMainThread
 import com.vitorpamplona.amethyst.service.relays.Relay
 import com.vitorpamplona.amethyst.ui.components.BundledInsert
@@ -11,14 +13,72 @@ import com.vitorpamplona.quartz.encoders.Hex
 import com.vitorpamplona.quartz.encoders.HexKey
 import com.vitorpamplona.quartz.encoders.HexValidator
 import com.vitorpamplona.quartz.encoders.Nip19
+import com.vitorpamplona.quartz.encoders.bechToBytes
 import com.vitorpamplona.quartz.encoders.decodePublicKeyAsHexOrNull
 import com.vitorpamplona.quartz.encoders.toHexKey
-import com.vitorpamplona.quartz.events.*
+import com.vitorpamplona.quartz.events.AddressableEvent
+import com.vitorpamplona.quartz.events.AdvertisedRelayListEvent
+import com.vitorpamplona.quartz.events.AppDefinitionEvent
+import com.vitorpamplona.quartz.events.AppRecommendationEvent
+import com.vitorpamplona.quartz.events.AudioHeaderEvent
+import com.vitorpamplona.quartz.events.AudioTrackEvent
+import com.vitorpamplona.quartz.events.BadgeAwardEvent
+import com.vitorpamplona.quartz.events.BadgeDefinitionEvent
+import com.vitorpamplona.quartz.events.BadgeProfilesEvent
+import com.vitorpamplona.quartz.events.BaseAddressableEvent
+import com.vitorpamplona.quartz.events.BookmarkListEvent
+import com.vitorpamplona.quartz.events.CalendarDateSlotEvent
+import com.vitorpamplona.quartz.events.CalendarEvent
+import com.vitorpamplona.quartz.events.CalendarRSVPEvent
+import com.vitorpamplona.quartz.events.CalendarTimeSlotEvent
+import com.vitorpamplona.quartz.events.ChannelCreateEvent
+import com.vitorpamplona.quartz.events.ChannelHideMessageEvent
+import com.vitorpamplona.quartz.events.ChannelMessageEvent
+import com.vitorpamplona.quartz.events.ChannelMetadataEvent
+import com.vitorpamplona.quartz.events.ChannelMuteUserEvent
+import com.vitorpamplona.quartz.events.ChatMessageEvent
+import com.vitorpamplona.quartz.events.ChatroomKey
+import com.vitorpamplona.quartz.events.ClassifiedsEvent
+import com.vitorpamplona.quartz.events.CommunityDefinitionEvent
+import com.vitorpamplona.quartz.events.CommunityPostApprovalEvent
+import com.vitorpamplona.quartz.events.ContactListEvent
+import com.vitorpamplona.quartz.events.DeletionEvent
+import com.vitorpamplona.quartz.events.EmojiPackEvent
+import com.vitorpamplona.quartz.events.EmojiPackSelectionEvent
+import com.vitorpamplona.quartz.events.Event
+import com.vitorpamplona.quartz.events.FileHeaderEvent
+import com.vitorpamplona.quartz.events.FileStorageEvent
+import com.vitorpamplona.quartz.events.FileStorageHeaderEvent
+import com.vitorpamplona.quartz.events.GenericRepostEvent
+import com.vitorpamplona.quartz.events.GiftWrapEvent
+import com.vitorpamplona.quartz.events.HighlightEvent
+import com.vitorpamplona.quartz.events.LiveActivitiesChatMessageEvent
+import com.vitorpamplona.quartz.events.LiveActivitiesEvent
+import com.vitorpamplona.quartz.events.LnZapEvent
+import com.vitorpamplona.quartz.events.LnZapPaymentRequestEvent
+import com.vitorpamplona.quartz.events.LnZapPaymentResponseEvent
+import com.vitorpamplona.quartz.events.LnZapRequestEvent
+import com.vitorpamplona.quartz.events.LongTextNoteEvent
+import com.vitorpamplona.quartz.events.MetadataEvent
+import com.vitorpamplona.quartz.events.NNSEvent
+import com.vitorpamplona.quartz.events.PeopleListEvent
+import com.vitorpamplona.quartz.events.PinListEvent
+import com.vitorpamplona.quartz.events.PollNoteEvent
+import com.vitorpamplona.quartz.events.PrivateDmEvent
+import com.vitorpamplona.quartz.events.ReactionEvent
+import com.vitorpamplona.quartz.events.RecommendRelayEvent
+import com.vitorpamplona.quartz.events.RelaySetEvent
+import com.vitorpamplona.quartz.events.ReportEvent
+import com.vitorpamplona.quartz.events.RepostEvent
+import com.vitorpamplona.quartz.events.SealedGossipEvent
+import com.vitorpamplona.quartz.events.StatusEvent
+import com.vitorpamplona.quartz.events.TextNoteEvent
 import kotlinx.collections.immutable.ImmutableList
 import kotlinx.collections.immutable.persistentSetOf
 import kotlinx.collections.immutable.toImmutableList
 import kotlinx.collections.immutable.toImmutableSet
-import kotlinx.coroutines.*
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.asSharedFlow
 import java.io.File
@@ -53,6 +113,10 @@ object LocalCache {
         // checkNotInMainThread()
 
         return users[key] ?: run {
+            require(isValidHex(key = key)) {
+                "$key is not a valid hex"
+            }
+
             val newObject = User(key)
             users.putIfAbsent(key, newObject) ?: newObject
         }
@@ -86,7 +150,15 @@ object LocalCache {
             val noteEvent = note.event
             return if (noteEvent is AddressableEvent) {
                 // upgrade to the latest
-                checkGetOrCreateAddressableNote(noteEvent.address().toTag())
+                val newNote = checkGetOrCreateAddressableNote(noteEvent.address().toTag())
+
+                if (newNote != null && noteEvent is Event && newNote.event == null) {
+                    val author = note.author ?: getOrCreateUser(noteEvent.pubKey)
+                    newNote.loadEvent(noteEvent as Event, author, emptyList())
+                    note.moveAllReferencesTo(newNote)
+                }
+
+                newNote
             } else {
                 note
             }
@@ -94,10 +166,26 @@ object LocalCache {
         return null
     }
 
+    fun getOrAddAliasNote(idHex: String, note: Note): Note {
+        checkNotInMainThread()
+
+        return notes.get(idHex) ?: run {
+            require(isValidHex(idHex)) {
+                "$idHex is not a valid hex"
+            }
+
+            notes.putIfAbsent(idHex, note) ?: note
+        }
+    }
+
     fun getOrCreateNote(idHex: String): Note {
         checkNotInMainThread()
 
         return notes.get(idHex) ?: run {
+            require(isValidHex(idHex)) {
+                "$idHex is not a valid hex"
+            }
+
             val newObject = Note(idHex)
             notes.putIfAbsent(idHex, newObject) ?: newObject
         }
@@ -198,6 +286,14 @@ object LocalCache {
         val user = getOrCreateUser(event.pubKey)
         if (user.latestBookmarkList == null || event.createdAt > user.latestBookmarkList!!.createdAt) {
             if (event.dTag() == "bookmark") {
+                val loggedInUser = LocalPreferences.currentAccount()
+                val hexKey = loggedInUser?.bechToBytes()
+                if (hexKey != null) {
+                    val pubKey = Hex.encode(hexKey)
+                    if (pubKey == event.pubKey) {
+                        ExternalSignerUtils.content.remove(event.id)
+                    }
+                }
                 user.updateBookmark(event)
             }
             // Log.d("MT", "New User Metadata ${oldUser.pubkeyDisplayHex} ${oldUser.toBestDisplayName()}")
@@ -329,7 +425,12 @@ object LocalCache {
             val channel = getOrCreateChannel(note.idHex) {
                 LiveActivitiesChannel(note.address)
             } as? LiveActivitiesChannel
-            channel?.updateChannelInfo(author, event, event.createdAt)
+
+            val creator = event.host()?.ifBlank { null }?.let {
+                checkGetOrCreateUser(it)
+            } ?: author
+
+            channel?.updateChannelInfo(creator, event, event.createdAt)
 
             refreshObservers(note)
         }
@@ -807,23 +908,23 @@ object LocalCache {
         // Already processed this event.
         if (note.event != null) return
 
-        val zapRequest = event.zapRequest?.id?.let { getOrCreateNote(it) }
+        val zapRequest = event.zapRequest?.id?.let { getNoteIfExists(it) }
+
+        if (zapRequest == null || zapRequest.event !is LnZapRequestEvent) {
+            Log.e("ZP", "Zap Request not found. Unable to process Zap {${event.toJson()}}")
+            return
+        }
 
         val author = getOrCreateUser(event.pubKey)
         val mentions = event.zappedAuthor().mapNotNull { checkGetOrCreateUser(it) }
         val repliesTo = event.zappedPost().mapNotNull { checkGetOrCreateNote(it) } +
             event.taggedAddresses().map { getOrCreateAddressableNote(it) } +
             (
-                (zapRequest?.event as? LnZapRequestEvent)?.taggedAddresses()?.map { getOrCreateAddressableNote(it) } ?: emptySet<Note>()
+                (zapRequest.event as? LnZapRequestEvent)?.taggedAddresses()?.map { getOrCreateAddressableNote(it) } ?: emptySet<Note>()
                 )
 
         note.loadEvent(event, author, repliesTo)
 
-        if (zapRequest == null) {
-            Log.e("ZP", "Zap Request not found. Unable to process Zap {${event.toJson()}}")
-            return
-        }
-
         // Log.d("ZP", "New ZapEvent ${event.content} (${notes.size},${users.size}) ${note.author?.toBestDisplayName()} ${formattedDateTime(event.createdAt)}")
 
         repliesTo.forEach {
@@ -1428,7 +1529,7 @@ object LocalCache {
             try {
                 event.checkSignature()
             } catch (e: Exception) {
-                Log.w("Event failed retest ${event.kind}", e.message ?: "")
+                Log.w("Event failed retest ${event.kind}", (e.message ?: "") + event.toJson())
             }
             false
         } else {
@@ -1529,7 +1630,7 @@ object LocalCache {
 
 @Stable
 class LocalCacheLiveData {
-    private val _newEventBundles = MutableSharedFlow<Set<Note>>()
+    private val _newEventBundles = MutableSharedFlow<Set<Note>>(0, 10, BufferOverflow.DROP_OLDEST)
     val newEventBundles = _newEventBundles.asSharedFlow() // read-only public view
 
     // Refreshes observers in batches.

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

@@ -20,7 +20,25 @@ import com.vitorpamplona.quartz.encoders.HexKey
 import com.vitorpamplona.quartz.encoders.LnInvoiceUtil
 import com.vitorpamplona.quartz.encoders.Nip19
 import com.vitorpamplona.quartz.encoders.toNote
-import com.vitorpamplona.quartz.events.*
+import com.vitorpamplona.quartz.events.AddressableEvent
+import com.vitorpamplona.quartz.events.BaseTextNoteEvent
+import com.vitorpamplona.quartz.events.ChannelCreateEvent
+import com.vitorpamplona.quartz.events.ChannelMessageEvent
+import com.vitorpamplona.quartz.events.ChannelMetadataEvent
+import com.vitorpamplona.quartz.events.CommunityPostApprovalEvent
+import com.vitorpamplona.quartz.events.Event
+import com.vitorpamplona.quartz.events.EventInterface
+import com.vitorpamplona.quartz.events.GenericRepostEvent
+import com.vitorpamplona.quartz.events.ImmutableListOfLists
+import com.vitorpamplona.quartz.events.LiveActivitiesChatMessageEvent
+import com.vitorpamplona.quartz.events.LiveActivitiesEvent
+import com.vitorpamplona.quartz.events.LnZapEvent
+import com.vitorpamplona.quartz.events.LnZapPaymentRequestEvent
+import com.vitorpamplona.quartz.events.LnZapPaymentResponseEvent
+import com.vitorpamplona.quartz.events.LongTextNoteEvent
+import com.vitorpamplona.quartz.events.PayInvoiceSuccessResponse
+import com.vitorpamplona.quartz.events.RepostEvent
+import com.vitorpamplona.quartz.events.WrappedEvent
 import com.vitorpamplona.quartz.utils.TimeUtils
 import kotlinx.collections.immutable.toImmutableList
 import kotlinx.coroutines.Dispatchers
@@ -43,6 +61,10 @@ class AddressableNote(val address: ATag) : Note(address.toTag()) {
 
         return minOf(publishedAt, lastCreatedAt)
     }
+
+    fun dTag(): String? {
+        return (event as? AddressableEvent)?.dTag()
+    }
 }
 
 @Stable
@@ -395,9 +417,16 @@ open class Note(val idHex: String) {
         }
     }
 
+    @Synchronized
+    fun addRelaySync(url: String) {
+        if (url !in relays) {
+            relays = relays + url
+        }
+    }
+
     fun addRelay(relay: Relay) {
         if (relay.url !in relays) {
-            relays = relays + relay.url
+            addRelaySync(relay.url)
             liveSet?.innerRelays?.invalidateData()
         }
     }
@@ -669,16 +698,24 @@ open class Note(val idHex: String) {
     }
 
     fun isHiddenFor(accountChoices: Account.LiveHiddenUsers): Boolean {
-        if (event == null) return false
+        val thisEvent = event ?: return false
 
-        val isBoostedNoteHidden = if (event is GenericRepostEvent || event is RepostEvent || event is CommunityPostApprovalEvent) {
+        val isBoostedNoteHidden = if (thisEvent is GenericRepostEvent || thisEvent is RepostEvent || thisEvent is CommunityPostApprovalEvent) {
             replyTo?.lastOrNull()?.isHiddenFor(accountChoices) ?: false
         } else {
             false
         }
 
-        val isSensitive = event?.isSensitive() ?: false
-        return isBoostedNoteHidden ||
+        val isHiddenByWord = if (thisEvent is BaseTextNoteEvent) {
+            accountChoices.hiddenWords.any {
+                thisEvent.content.contains(it, true)
+            }
+        } else {
+            false
+        }
+
+        val isSensitive = thisEvent.isSensitive()
+        return isBoostedNoteHidden || isHiddenByWord ||
             accountChoices.hiddenUsers.contains(author?.pubkeyHex) ||
             accountChoices.spammers.contains(author?.pubkeyHex) ||
             (isSensitive && accountChoices.showSensitiveContent == false)

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

@@ -8,7 +8,9 @@ class Settings(
     var preferredLanguage: String? = null,
     var automaticallyShowImages: ConnectivityType = ConnectivityType.ALWAYS,
     var automaticallyStartPlayback: ConnectivityType = ConnectivityType.ALWAYS,
-    var automaticallyShowUrlPreview: ConnectivityType = ConnectivityType.ALWAYS
+    var automaticallyShowUrlPreview: ConnectivityType = ConnectivityType.ALWAYS,
+    var automaticallyHideNavigationBars: BooleanType = BooleanType.ALWAYS,
+    var automaticallyShowProfilePictures: ConnectivityType = ConnectivityType.ALWAYS
 )
 
 enum class ConnectivityType(val prefCode: Boolean?, val screenCode: Int, val reourceId: Int) {
@@ -38,3 +40,28 @@ fun parseConnectivityType(screenCode: Int): ConnectivityType {
         }
     }
 }
+
+enum class BooleanType(val prefCode: Boolean?, val screenCode: Int, val reourceId: Int) {
+    ALWAYS(null, 0, R.string.connectivity_type_always),
+    NEVER(false, 1, R.string.connectivity_type_never)
+}
+
+fun parseBooleanType(code: Boolean?): BooleanType {
+    return when (code) {
+        BooleanType.ALWAYS.prefCode -> BooleanType.ALWAYS
+        BooleanType.NEVER.prefCode -> BooleanType.NEVER
+        else -> {
+            BooleanType.ALWAYS
+        }
+    }
+}
+
+fun parseBooleanType(screenCode: Int): BooleanType {
+    return when (screenCode) {
+        BooleanType.ALWAYS.screenCode -> BooleanType.ALWAYS
+        BooleanType.NEVER.screenCode -> BooleanType.NEVER
+        else -> {
+            BooleanType.ALWAYS
+        }
+    }
+}

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

@@ -5,16 +5,15 @@ import androidx.compose.runtime.Stable
 import androidx.lifecycle.LiveData
 import androidx.lifecycle.MediatorLiveData
 import androidx.lifecycle.distinctUntilChanged
-import androidx.lifecycle.map
 import com.vitorpamplona.amethyst.service.NostrSingleUserDataSource
 import com.vitorpamplona.amethyst.service.checkNotInMainThread
 import com.vitorpamplona.amethyst.service.relays.EOSETime
 import com.vitorpamplona.amethyst.service.relays.Relay
 import com.vitorpamplona.amethyst.ui.components.BundledUpdate
 import com.vitorpamplona.amethyst.ui.note.toShortenHex
-import com.vitorpamplona.quartz.encoders.Bech32
 import com.vitorpamplona.quartz.encoders.Hex
 import com.vitorpamplona.quartz.encoders.HexKey
+import com.vitorpamplona.quartz.encoders.Lud06
 import com.vitorpamplona.quartz.encoders.toNpub
 import com.vitorpamplona.quartz.events.BookmarkListEvent
 import com.vitorpamplona.quartz.events.ChatroomKey
@@ -27,9 +26,6 @@ import com.vitorpamplona.quartz.events.toImmutableListOfLists
 import kotlinx.collections.immutable.persistentSetOf
 import kotlinx.coroutines.Dispatchers
 import java.math.BigDecimal
-import java.util.regex.Pattern
-
-val lnurlpPattern = Pattern.compile("(?i:http|https):\\/\\/((.+)\\/)*\\.well-known\\/lnurlp\\/(.*)")
 
 @Stable
 class User(val pubkeyHex: String) {
@@ -268,19 +264,11 @@ class User(val pubkeyHex: String) {
         info?.updatedMetadataAt = latestMetadata.createdAt
         info?.tags = latestMetadata.tags.toImmutableListOfLists()
 
-        if (newUserInfo.lud16.isNullOrBlank() && newUserInfo.lud06?.lowercase()?.startsWith("lnurl") == true) {
-            try {
-                val url = String(Bech32.decodeBytes(newUserInfo.lud06!!, false).second)
-
-                val matcher = lnurlpPattern.matcher(url)
-                while (matcher.find()) {
-                    val domain = matcher.group(2)
-                    val username = matcher.group(3)
-
-                    info?.lud16 = "$username@$domain"
+        if (newUserInfo.lud16.isNullOrBlank()) {
+            info?.lud06?.let {
+                if (it.lowercase().startsWith("lnurl")) {
+                    info?.lud16 = Lud06().toLud16(it)
                 }
-            } catch (t: Throwable) {
-                // Doesn't create errors.
             }
         }
 
@@ -331,7 +319,7 @@ class User(val pubkeyHex: String) {
         return latestContactList?.verifiedFollowKeySet ?: emptySet()
     }
 
-    fun cachedFollowingTagSet(): Set<HexKey> {
+    fun cachedFollowingTagSet(): Set<String> {
         return latestContactList?.verifiedFollowTagSet ?: emptySet()
     }
 

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

@@ -11,7 +11,6 @@ import com.vitorpamplona.amethyst.ui.components.ZoomableUrlImage
 import com.vitorpamplona.amethyst.ui.components.ZoomableUrlVideo
 import com.vitorpamplona.amethyst.ui.components.hashTagsPattern
 import com.vitorpamplona.amethyst.ui.components.imageExtensions
-import com.vitorpamplona.amethyst.ui.components.startsWithNIP19Scheme
 import com.vitorpamplona.amethyst.ui.components.tagIndex
 import com.vitorpamplona.amethyst.ui.components.videoExtensions
 import com.vitorpamplona.quartz.events.ImmutableListOfLists
@@ -290,3 +289,9 @@ class SchemelessUrlSegment(segment: String, val url: String, val extras: String?
 
 @Immutable
 class RegularTextSegment(segment: String) : Segment(segment)
+
+fun startsWithNIP19Scheme(word: String): Boolean {
+    val cleaned = word.lowercase().removePrefix("@").removePrefix("nostr:").removePrefix("@")
+
+    return listOf("npub1", "naddr1", "note1", "nprofile1", "nevent1").any { cleaned.startsWith(it) }
+}

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

@@ -1,8 +1,10 @@
 package com.vitorpamplona.amethyst.service
 
+import android.content.Context
 import androidx.compose.runtime.Immutable
 import com.fasterxml.jackson.databind.JsonNode
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import com.vitorpamplona.amethyst.R
 import com.vitorpamplona.amethyst.service.lnurl.LightningAddressResolver
 import com.vitorpamplona.amethyst.ui.components.GenericLoadable
 import com.vitorpamplona.quartz.events.Event
@@ -45,7 +47,7 @@ class CashuProcessor {
         }
     }
 
-    suspend fun melt(token: CashuToken, lud16: String, onSuccess: (String) -> Unit, onError: (String) -> Unit) {
+    suspend fun melt(token: CashuToken, lud16: String, onSuccess: (String, String) -> Unit, onError: (String, String) -> Unit, context: Context) {
         checkNotInMainThread()
 
         runCatching {
@@ -54,16 +56,17 @@ class CashuProcessor {
                 milliSats = token.redeemInvoiceAmount * 1000, // Make invoice and leave room for fees
                 message = "Redeem Cashu",
                 onSuccess = { invoice ->
-                    meltInvoice(token, invoice, onSuccess, onError)
+                    meltInvoice(token, invoice, onSuccess, onError, context)
                 },
                 onProgress = {
                 },
-                onError = onError
+                onError = onError,
+                context = context
             )
         }
     }
 
-    private fun meltInvoice(token: CashuToken, invoice: String, onSuccess: (String) -> Unit, onError: (String) -> Unit) {
+    private fun meltInvoice(token: CashuToken, invoice: String, onSuccess: (String, String) -> Unit, onError: (String, String) -> Unit, context: Context) {
         try {
             val client = HttpClient.getHttpClient()
             val url = token.mint + "/melt" // Melt cashu tokens at Mint
@@ -88,13 +91,24 @@ class CashuProcessor {
                 val successful = tree?.get("paid")?.asText() == "true"
 
                 if (successful) {
-                    onSuccess("Redeemed ${token.totalAmount} Sats" + " (Fees: ${token.fees} Sats)")
+                    onSuccess(
+                        context.getString(R.string.cashu_sucessful_redemption),
+                        context.getString(R.string.cashu_sucessful_redemption_explainer, token.totalAmount.toString(), token.fees.toString())
+                    )
                 } else {
-                    onError(tree?.get("detail")?.asText()?.split('.')?.getOrNull(0) ?: "Cashu: Tokens already spent.")
+                    val msg = tree?.get("detail")?.asText()?.split('.')?.getOrNull(0)?.ifBlank { null }
+                    onError(
+                        context.getString(R.string.cashu_failed_redemption),
+                        if (msg != null) {
+                            context.getString(R.string.cashu_failed_redemption_explainer_error_msg, msg)
+                        } else {
+                            context.getString(R.string.cashu_failed_redemption_explainer_error_msg)
+                        }
+                    )
                 }
             }
         } catch (e: Exception) {
-            onError("Token melt failure: " + e.message)
+            onError(context.getString(R.string.cashu_sucessful_redemption), context.getString(R.string.cashu_failed_redemption_explainer_error_msg, e.message))
         }
     }
 }

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

@@ -0,0 +1,311 @@
+package com.vitorpamplona.amethyst.service
+
+import android.app.Activity
+import android.content.Intent
+import android.net.Uri
+import android.util.Log
+import android.util.LruCache
+import android.widget.Toast
+import androidx.activity.result.ActivityResultLauncher
+import androidx.activity.result.contract.ActivityResultContracts
+import com.vitorpamplona.amethyst.Amethyst
+import com.vitorpamplona.amethyst.R
+import com.vitorpamplona.amethyst.ServiceManager
+import com.vitorpamplona.amethyst.model.Account
+import com.vitorpamplona.amethyst.ui.MainActivity
+import com.vitorpamplona.quartz.encoders.HexKey
+import com.vitorpamplona.quartz.encoders.toNpub
+import com.vitorpamplona.quartz.events.EventInterface
+import com.vitorpamplona.quartz.events.LnZapRequestEvent
+import kotlinx.coroutines.DelicateCoroutinesApi
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
+
+enum class SignerType {
+    SIGN_EVENT,
+    NIP04_ENCRYPT,
+    NIP04_DECRYPT,
+    NIP44_ENCRYPT,
+    NIP44_DECRYPT,
+    GET_PUBLIC_KEY,
+    DECRYPT_ZAP_EVENT
+}
+
+object ExternalSignerUtils {
+    val content = LruCache<String, String>(10)
+    var isActivityRunning: Boolean = false
+    val cachedDecryptedContent = mutableMapOf<HexKey, String>()
+    lateinit var account: Account
+    private lateinit var activityResultLauncher: ActivityResultLauncher<Intent>
+    private lateinit var decryptResultLauncher: ActivityResultLauncher<Intent>
+    private lateinit var blockListResultLauncher: ActivityResultLauncher<Intent>
+
+    @OptIn(DelicateCoroutinesApi::class)
+    fun requestRejectedToast() {
+        GlobalScope.launch(Dispatchers.Main) {
+            Toast.makeText(
+                Amethyst.instance,
+                Amethyst.instance.getString(R.string.sign_request_rejected),
+                Toast.LENGTH_SHORT
+            ).show()
+        }
+    }
+
+    @OptIn(DelicateCoroutinesApi::class)
+    fun default() {
+        isActivityRunning = false
+        ServiceManager.shouldPauseService = true
+        GlobalScope.launch(Dispatchers.IO) {
+            isActivityRunning = false
+            ServiceManager.shouldPauseService = true
+        }
+    }
+
+    @OptIn(DelicateCoroutinesApi::class)
+    fun start(activity: MainActivity) {
+        activityResultLauncher = activity.registerForActivityResult(
+            ActivityResultContracts.StartActivityForResult()
+        ) {
+            if (it.resultCode != Activity.RESULT_OK) {
+                requestRejectedToast()
+            } else {
+                val event = it.data?.getStringExtra("signature") ?: ""
+                val id = it.data?.getStringExtra("id") ?: ""
+                if (id.isNotBlank()) {
+                    content.put(id, event)
+                }
+            }
+            default()
+        }
+
+        decryptResultLauncher = activity.registerForActivityResult(
+            ActivityResultContracts.StartActivityForResult()
+        ) {
+            if (it.resultCode != Activity.RESULT_OK) {
+                requestRejectedToast()
+            } else {
+                val event = it.data?.getStringExtra("signature") ?: ""
+                val id = it.data?.getStringExtra("id") ?: ""
+                if (id.isNotBlank()) {
+                    content.put(id, event)
+                    cachedDecryptedContent[id] = event
+                }
+            }
+            default()
+        }
+
+        blockListResultLauncher = activity.registerForActivityResult(
+            ActivityResultContracts.StartActivityForResult()
+        ) {
+            if (it.resultCode != Activity.RESULT_OK) {
+                requestRejectedToast()
+            } else {
+                val decryptedContent = it.data?.getStringExtra("signature") ?: ""
+                val id = it.data?.getStringExtra("id") ?: ""
+                if (id.isNotBlank()) {
+                    cachedDecryptedContent[id] = decryptedContent
+                    account.live.invalidateData()
+                }
+            }
+            default()
+        }
+    }
+
+    @OptIn(DelicateCoroutinesApi::class)
+    fun openSigner(
+        data: String,
+        type: SignerType,
+        intentResult: ActivityResultLauncher<Intent>,
+        pubKey: HexKey,
+        id: String
+    ) {
+        try {
+            ServiceManager.shouldPauseService = false
+            val intent = Intent(Intent.ACTION_VIEW, Uri.parse("nostrsigner:$data"))
+            val signerType = when (type) {
+                SignerType.SIGN_EVENT -> "sign_event"
+                SignerType.NIP04_ENCRYPT -> "nip04_encrypt"
+                SignerType.NIP04_DECRYPT -> "nip04_decrypt"
+                SignerType.NIP44_ENCRYPT -> "nip44_encrypt"
+                SignerType.NIP44_DECRYPT -> "nip44_decrypt"
+                SignerType.GET_PUBLIC_KEY -> "get_public_key"
+                SignerType.DECRYPT_ZAP_EVENT -> "decrypt_zap_event"
+            }
+            intent.putExtra("type", signerType)
+            intent.putExtra("pubKey", pubKey)
+            intent.putExtra("id", id)
+            if (type !== SignerType.GET_PUBLIC_KEY) {
+                intent.putExtra("current_user", account.keyPair.pubKey.toNpub())
+            }
+            intent.`package` = "com.greenart7c3.nostrsigner"
+            intentResult.launch(intent)
+        } catch (e: Exception) {
+            Log.e("Signer", "Error opening Signer app", e)
+            GlobalScope.launch(Dispatchers.Main) {
+                Toast.makeText(
+                    Amethyst.instance,
+                    Amethyst.instance.getString(R.string.error_opening_external_signer),
+                    Toast.LENGTH_SHORT
+                ).show()
+            }
+        }
+    }
+
+    fun openSigner(event: EventInterface, columnName: String = "signature") {
+        checkNotInMainThread()
+
+        val result = getDataFromResolver(SignerType.SIGN_EVENT, arrayOf(event.toJson(), event.pubKey()), columnName)
+        if (result == null) {
+            ServiceManager.shouldPauseService = false
+            isActivityRunning = true
+            openSigner(
+                event.toJson(),
+                SignerType.SIGN_EVENT,
+                activityResultLauncher,
+                "",
+                event.id()
+            )
+            while (isActivityRunning) {
+                Thread.sleep(100)
+            }
+        } else {
+            content.put(event.id(), result)
+        }
+    }
+
+    fun decryptBlockList(encryptedContent: String, pubKey: HexKey, id: String, signerType: SignerType = SignerType.NIP04_DECRYPT) {
+        val result = getDataFromResolver(signerType, arrayOf(encryptedContent, pubKey))
+        if (result == null) {
+            isActivityRunning = true
+            openSigner(
+                encryptedContent,
+                signerType,
+                blockListResultLauncher,
+                pubKey,
+                id
+            )
+        } else {
+            content.put(id, result)
+            cachedDecryptedContent[id] = result
+        }
+    }
+
+    fun getDataFromResolver(signerType: SignerType, data: Array<out String>, columnName: String = "signature"): String? {
+        val localData = if (signerType !== SignerType.GET_PUBLIC_KEY) {
+            data.toList().plus(account.keyPair.pubKey.toNpub()).toTypedArray()
+        } else {
+            data
+        }
+
+        Amethyst.instance.contentResolver.query(
+            Uri.parse("content://com.greenart7c3.nostrsigner.$signerType"),
+            localData,
+            null,
+            null,
+            null
+        ).use {
+            if (it == null) {
+                return null
+            }
+            if (it.moveToFirst()) {
+                val index = it.getColumnIndex(columnName)
+                if (index < 0) {
+                    Log.d("getDataFromResolver", "column '$columnName' not found")
+                    return null
+                }
+                return it.getString(index)
+            }
+        }
+        return null
+    }
+
+    fun decrypt(encryptedContent: String, pubKey: HexKey, id: String, signerType: SignerType = SignerType.NIP04_DECRYPT) {
+        val result = getDataFromResolver(signerType, arrayOf(encryptedContent, pubKey))
+        if (result == null) {
+            isActivityRunning = true
+            openSigner(
+                encryptedContent,
+                signerType,
+                decryptResultLauncher,
+                pubKey,
+                id
+            )
+            while (isActivityRunning) {
+                // do nothing
+            }
+        } else {
+            content.put(id, result)
+            cachedDecryptedContent[id] = result
+        }
+    }
+
+    fun decryptDM(encryptedContent: String, pubKey: HexKey, id: String, signerType: SignerType = SignerType.NIP04_DECRYPT) {
+        val result = getDataFromResolver(signerType, arrayOf(encryptedContent, pubKey))
+        if (result == null) {
+            openSigner(
+                encryptedContent,
+                signerType,
+                decryptResultLauncher,
+                pubKey,
+                id
+            )
+        } else {
+            content.put(id, result)
+            cachedDecryptedContent[id] = result
+        }
+    }
+
+    fun decryptBookmark(encryptedContent: String, pubKey: HexKey, id: String, signerType: SignerType = SignerType.NIP04_DECRYPT) {
+        val result = getDataFromResolver(signerType, arrayOf(encryptedContent, pubKey))
+        if (result == null) {
+            openSigner(
+                encryptedContent,
+                signerType,
+                decryptResultLauncher,
+                pubKey,
+                id
+            )
+        } else {
+            content.put(id, result)
+            cachedDecryptedContent[id] = result
+        }
+    }
+
+    fun encrypt(decryptedContent: String, pubKey: HexKey, id: String, signerType: SignerType = SignerType.NIP04_ENCRYPT) {
+        content.remove(id)
+        cachedDecryptedContent.remove(id)
+        val result = getDataFromResolver(signerType, arrayOf(decryptedContent, pubKey))
+        if (result == null) {
+            isActivityRunning = true
+            openSigner(
+                decryptedContent,
+                signerType,
+                activityResultLauncher,
+                pubKey,
+                id
+            )
+            while (isActivityRunning) {
+                Thread.sleep(100)
+            }
+        } else {
+            content.put(id, result)
+        }
+    }
+
+    fun decryptZapEvent(event: LnZapRequestEvent) {
+        val result = getDataFromResolver(SignerType.DECRYPT_ZAP_EVENT, arrayOf(event.toJson(), event.pubKey))
+        if (result == null) {
+            openSigner(
+                event.toJson(),
+                SignerType.DECRYPT_ZAP_EVENT,
+                decryptResultLauncher,
+                event.pubKey,
+                event.id
+            )
+        } else {
+            content.put(event.id, result)
+            cachedDecryptedContent[event.id] = result
+        }
+    }
+}

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

@@ -16,16 +16,16 @@ class FileHeader(
     val size: Int,
     val dim: String?,
     val blurHash: String?,
-    val description: String? = null,
+    val alt: String? = null,
     val sensitiveContent: Boolean = false
 ) {
     companion object {
-        suspend fun prepare(fileUrl: String, mimeType: String?, description: String?, sensitiveContent: Boolean, onReady: (FileHeader) -> Unit, onError: () -> Unit) {
+        suspend fun prepare(fileUrl: String, mimeType: String?, alt: String?, sensitiveContent: Boolean, onReady: (FileHeader) -> Unit, onError: () -> Unit) {
             try {
                 val imageData: ByteArray? = ImageDownloader().waitAndGetImage(fileUrl)
 
                 if (imageData != null) {
-                    prepare(imageData, fileUrl, mimeType, description, sensitiveContent, onReady, onError)
+                    prepare(imageData, fileUrl, mimeType, alt, sensitiveContent, onReady, onError)
                 } else {
                     onError()
                 }
@@ -39,7 +39,7 @@ class FileHeader(
             data: ByteArray,
             fileUrl: String,
             mimeType: String?,
-            description: String?,
+            alt: String?,
             sensitiveContent: Boolean,
             onReady: (FileHeader) -> Unit,
             onError: () -> Unit
@@ -79,7 +79,7 @@ class FileHeader(
                     Pair(null, null)
                 }
 
-                onReady(FileHeader(fileUrl, mimeType, hash, size, dim, blurHash, description, sensitiveContent))
+                onReady(FileHeader(fileUrl, mimeType, hash, size, dim, blurHash, alt, sensitiveContent))
             } catch (e: Exception) {
                 Log.e("ImageDownload", "Couldn't convert image in to File Header: ${e.message}")
                 onError()

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

@@ -2,29 +2,41 @@ package com.vitorpamplona.amethyst.service
 
 import com.vitorpamplona.amethyst.model.Account
 import com.vitorpamplona.amethyst.model.LocalCache
+import com.vitorpamplona.amethyst.model.User
 import com.vitorpamplona.amethyst.service.relays.COMMON_FEED_TYPES
 import com.vitorpamplona.amethyst.service.relays.Client
 import com.vitorpamplona.amethyst.service.relays.EOSEAccount
 import com.vitorpamplona.amethyst.service.relays.JsonFilter
 import com.vitorpamplona.amethyst.service.relays.Relay
 import com.vitorpamplona.amethyst.service.relays.TypedFilter
-import com.vitorpamplona.quartz.events.*
+import com.vitorpamplona.quartz.events.AdvertisedRelayListEvent
 import com.vitorpamplona.quartz.events.BadgeAwardEvent
 import com.vitorpamplona.quartz.events.BadgeProfilesEvent
 import com.vitorpamplona.quartz.events.BookmarkListEvent
 import com.vitorpamplona.quartz.events.ChannelMessageEvent
 import com.vitorpamplona.quartz.events.ContactListEvent
+import com.vitorpamplona.quartz.events.EmojiPackSelectionEvent
+import com.vitorpamplona.quartz.events.Event
+import com.vitorpamplona.quartz.events.EventInterface
+import com.vitorpamplona.quartz.events.GenericRepostEvent
+import com.vitorpamplona.quartz.events.GiftWrapEvent
 import com.vitorpamplona.quartz.events.LnZapEvent
+import com.vitorpamplona.quartz.events.LnZapPaymentResponseEvent
 import com.vitorpamplona.quartz.events.MetadataEvent
+import com.vitorpamplona.quartz.events.PeopleListEvent
+import com.vitorpamplona.quartz.events.PollNoteEvent
 import com.vitorpamplona.quartz.events.ReactionEvent
 import com.vitorpamplona.quartz.events.ReportEvent
 import com.vitorpamplona.quartz.events.RepostEvent
+import com.vitorpamplona.quartz.events.SealedGossipEvent
+import com.vitorpamplona.quartz.events.StatusEvent
 import com.vitorpamplona.quartz.events.TextNoteEvent
 
 object NostrAccountDataSource : NostrDataSource("AccountData") {
     lateinit var account: Account
 
     val latestEOSEs = EOSEAccount()
+    val hasLoadedTheBasics = mutableMapOf<User, Boolean>()
 
     fun createAccountContactListFilter(): TypedFilter {
         return TypedFilter(
@@ -132,10 +144,18 @@ object NostrAccountDataSource : NostrDataSource("AccountData") {
     )
 
     val accountChannel = requestNewChannel { time, relayUrl ->
-        latestEOSEs.addOrUpdate(account.userProfile(), account.defaultNotificationFollowList, relayUrl, time)
+        if (hasLoadedTheBasics[account.userProfile()] != null) {
+            latestEOSEs.addOrUpdate(account.userProfile(), account.defaultNotificationFollowList, relayUrl, time)
+        } else {
+            hasLoadedTheBasics[account.userProfile()] = true
+
+            invalidateFilters()
+        }
     }
 
     override fun consume(event: Event, relay: Relay) {
+        checkNotInMainThread()
+
         if (LocalCache.justVerify(event)) {
             if (event is GiftWrapEvent) {
                 val privateKey = account.keyPair.privKey
@@ -143,6 +163,20 @@ object NostrAccountDataSource : NostrDataSource("AccountData") {
                     event.cachedGift(privateKey)?.let {
                         this.consume(it, relay)
                     }
+                } else if (account.loginWithExternalSigner) {
+                    var cached = ExternalSignerUtils.cachedDecryptedContent[event.id]
+                    if (cached == null) {
+                        ExternalSignerUtils.decrypt(
+                            event.content,
+                            event.pubKey,
+                            event.id,
+                            SignerType.NIP44_DECRYPT
+                        )
+                        cached = ExternalSignerUtils.cachedDecryptedContent[event.id] ?: ""
+                    }
+                    event.cachedGift(account.keyPair.pubKey, cached)?.let {
+                        this.consume(it, relay)
+                    }
                 }
             }
 
@@ -152,6 +186,20 @@ object NostrAccountDataSource : NostrDataSource("AccountData") {
                     event.cachedGossip(privateKey)?.let {
                         LocalCache.justConsume(it, relay)
                     }
+                } else if (account.loginWithExternalSigner) {
+                    var cached = ExternalSignerUtils.cachedDecryptedContent[event.id]
+                    if (cached == null) {
+                        ExternalSignerUtils.decrypt(
+                            event.content,
+                            event.pubKey,
+                            event.id,
+                            SignerType.NIP44_DECRYPT
+                        )
+                        cached = ExternalSignerUtils.cachedDecryptedContent[event.id] ?: ""
+                    }
+                    event.cachedGossip(account.keyPair.pubKey, cached)?.let {
+                        LocalCache.justConsume(it, relay)
+                    }
                 }
 
                 // Don't store sealed gossips to avoid rebroadcasting by mistake.
@@ -161,19 +209,51 @@ object NostrAccountDataSource : NostrDataSource("AccountData") {
         }
     }
 
+    override fun markAsSeenOnRelay(eventId: String, relay: Relay) {
+        super.markAsSeenOnRelay(eventId, relay)
+
+        val note = LocalCache.getNoteIfExists(eventId) ?: return
+        val privKey = account.keyPair.privKey ?: return
+
+        val noteEvent = note.event ?: return
+        markInnerAsSeenOnRelay(noteEvent, privKey, relay)
+    }
+
+    private fun markInnerAsSeenOnRelay(noteEvent: EventInterface, privKey: ByteArray, relay: Relay) {
+        LocalCache.getNoteIfExists(noteEvent.id())?.addRelay(relay)
+
+        if (noteEvent is GiftWrapEvent) {
+            val gift = noteEvent.cachedGift(privKey) ?: return
+            markInnerAsSeenOnRelay(gift, privKey, relay)
+        } else if (noteEvent is SealedGossipEvent) {
+            val rumor = noteEvent.cachedGossip(privKey) ?: return
+            markInnerAsSeenOnRelay(rumor, privKey, relay)
+        }
+    }
+
     override fun updateChannelFilters() {
-        // gets everthing about the user logged in
-        accountChannel.typedFilters = listOf(
-            createAccountMetadataFilter(),
-            createAccountContactListFilter(),
-            createAccountRelayListFilter(),
-            createNotificationFilter(),
-            createGiftWrapsToMeFilter(),
-            createAccountReportsFilter(),
-            createAccountAcceptedAwardsFilter(),
-            createAccountBookmarkListFilter(),
-            createAccountLastPostsListFilter()
-        ).ifEmpty { null }
+        return if (hasLoadedTheBasics[account.userProfile()] != null) {
+            // gets everthing about the user logged in
+            accountChannel.typedFilters = listOf(
+                createAccountMetadataFilter(),
+                createAccountContactListFilter(),
+                createAccountRelayListFilter(),
+                createNotificationFilter(),
+                createGiftWrapsToMeFilter(),
+                createAccountReportsFilter(),
+                createAccountAcceptedAwardsFilter(),
+                createAccountBookmarkListFilter(),
+                createAccountLastPostsListFilter()
+            ).ifEmpty { null }
+        } else {
+            // just the basics.
+            accountChannel.typedFilters = listOf(
+                createAccountMetadataFilter(),
+                createAccountContactListFilter(),
+                createAccountRelayListFilter(),
+                createAccountBookmarkListFilter()
+            ).ifEmpty { null }
+        }
     }
 
     override fun auth(relay: Relay, challenge: String) {
@@ -181,7 +261,6 @@ object NostrAccountDataSource : NostrDataSource("AccountData") {
 
         if (this::account.isInitialized) {
             val event = account.createAuthEvent(relay, challenge)
-
             if (event != null) {
                 Client.send(
                     event,

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

@@ -56,6 +56,10 @@ object NostrChatroomDataSource : NostrDataSource("ChatroomFeed") {
         }
     }
 
+    fun clearEOSEs(account: Account) {
+        latestEOSEs.removeDataFor(account.userProfile())
+    }
+
     val inandoutChannel = requestNewChannel { time, relayUrl ->
         latestEOSEs.addOrUpdate(account.userProfile(), withRoom.hashCode().toString(), relayUrl, time)
     }

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

@@ -15,7 +15,6 @@ import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 import java.util.UUID
 import java.util.concurrent.atomic.AtomicBoolean
-import kotlin.Error
 
 abstract class NostrDataSource(val debugName: String) {
     private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())

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

@@ -44,7 +44,7 @@ class NostrLnZapPaymentResponseDataSource(
     override fun auth(relay: Relay, challenge: String) {
         super.auth(relay, challenge)
 
-        val event = RelayAuthEvent.create(relay.url, challenge, authSigningKey)
+        val event = RelayAuthEvent.create(relay.url, challenge, "", authSigningKey)
         Client.send(
             event,
             relay.url

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

@@ -7,7 +7,24 @@ import com.vitorpamplona.amethyst.service.relays.TypedFilter
 import com.vitorpamplona.quartz.encoders.Hex
 import com.vitorpamplona.quartz.encoders.Nip19
 import com.vitorpamplona.quartz.encoders.toHexKey
-import com.vitorpamplona.quartz.events.*
+import com.vitorpamplona.quartz.events.AudioHeaderEvent
+import com.vitorpamplona.quartz.events.AudioTrackEvent
+import com.vitorpamplona.quartz.events.BadgeDefinitionEvent
+import com.vitorpamplona.quartz.events.BookmarkListEvent
+import com.vitorpamplona.quartz.events.ChannelCreateEvent
+import com.vitorpamplona.quartz.events.ChannelMetadataEvent
+import com.vitorpamplona.quartz.events.ClassifiedsEvent
+import com.vitorpamplona.quartz.events.CommunityDefinitionEvent
+import com.vitorpamplona.quartz.events.EmojiPackEvent
+import com.vitorpamplona.quartz.events.HighlightEvent
+import com.vitorpamplona.quartz.events.LiveActivitiesEvent
+import com.vitorpamplona.quartz.events.LongTextNoteEvent
+import com.vitorpamplona.quartz.events.MetadataEvent
+import com.vitorpamplona.quartz.events.NNSEvent
+import com.vitorpamplona.quartz.events.PeopleListEvent
+import com.vitorpamplona.quartz.events.PinListEvent
+import com.vitorpamplona.quartz.events.PollNoteEvent
+import com.vitorpamplona.quartz.events.TextNoteEvent
 
 object NostrSearchEventOrUserDataSource : NostrDataSource("SearchEventFeed") {
     private var searchString: String? = null

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

@@ -6,7 +6,15 @@ import com.vitorpamplona.amethyst.service.relays.COMMON_FEED_TYPES
 import com.vitorpamplona.amethyst.service.relays.EOSETime
 import com.vitorpamplona.amethyst.service.relays.JsonFilter
 import com.vitorpamplona.amethyst.service.relays.TypedFilter
-import com.vitorpamplona.quartz.events.*
+import com.vitorpamplona.quartz.events.CommunityPostApprovalEvent
+import com.vitorpamplona.quartz.events.GenericRepostEvent
+import com.vitorpamplona.quartz.events.LiveActivitiesChatMessageEvent
+import com.vitorpamplona.quartz.events.LnZapEvent
+import com.vitorpamplona.quartz.events.PollNoteEvent
+import com.vitorpamplona.quartz.events.ReactionEvent
+import com.vitorpamplona.quartz.events.ReportEvent
+import com.vitorpamplona.quartz.events.RepostEvent
+import com.vitorpamplona.quartz.events.TextNoteEvent
 
 object NostrSingleEventDataSource : NostrDataSource("SingleEventFeed") {
     private var eventsToWatch = setOf<Note>()

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

@@ -4,7 +4,23 @@ import com.vitorpamplona.amethyst.model.User
 import com.vitorpamplona.amethyst.service.relays.COMMON_FEED_TYPES
 import com.vitorpamplona.amethyst.service.relays.JsonFilter
 import com.vitorpamplona.amethyst.service.relays.TypedFilter
-import com.vitorpamplona.quartz.events.*
+import com.vitorpamplona.quartz.events.AppRecommendationEvent
+import com.vitorpamplona.quartz.events.AudioHeaderEvent
+import com.vitorpamplona.quartz.events.AudioTrackEvent
+import com.vitorpamplona.quartz.events.BadgeAwardEvent
+import com.vitorpamplona.quartz.events.BadgeProfilesEvent
+import com.vitorpamplona.quartz.events.BookmarkListEvent
+import com.vitorpamplona.quartz.events.ContactListEvent
+import com.vitorpamplona.quartz.events.GenericRepostEvent
+import com.vitorpamplona.quartz.events.HighlightEvent
+import com.vitorpamplona.quartz.events.LnZapEvent
+import com.vitorpamplona.quartz.events.LongTextNoteEvent
+import com.vitorpamplona.quartz.events.MetadataEvent
+import com.vitorpamplona.quartz.events.PeopleListEvent
+import com.vitorpamplona.quartz.events.PinListEvent
+import com.vitorpamplona.quartz.events.PollNoteEvent
+import com.vitorpamplona.quartz.events.RepostEvent
+import com.vitorpamplona.quartz.events.TextNoteEvent
 
 object NostrUserProfileDataSource : NostrDataSource("UserProfileFeed") {
     var user: User? = null

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

@@ -0,0 +1,17 @@
+package com.vitorpamplona.amethyst.service
+
+import android.content.Context
+
+object PackageUtils {
+    private fun isPackageInstalled(context: Context, target: String): Boolean {
+        return context.packageManager.getInstalledApplications(0).find { info -> info.packageName == target } != null
+    }
+
+    fun isOrbotInstalled(context: Context): Boolean {
+        return isPackageInstalled(context, "org.torproject.android")
+    }
+
+    fun isAmberInstalled(context: Context): Boolean {
+        return isPackageInstalled(context, "com.greenart7c3.nostrsigner")
+    }
+}

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

@@ -0,0 +1,214 @@
+package com.vitorpamplona.amethyst.service
+
+import android.content.Context
+import androidx.compose.runtime.Immutable
+import com.vitorpamplona.amethyst.R
+import com.vitorpamplona.amethyst.model.Account
+import com.vitorpamplona.amethyst.model.LocalCache
+import com.vitorpamplona.amethyst.model.Note
+import com.vitorpamplona.amethyst.model.User
+import com.vitorpamplona.amethyst.service.lnurl.LightningAddressResolver
+import com.vitorpamplona.quartz.events.LnZapEvent
+import com.vitorpamplona.quartz.events.PayInvoiceErrorResponse
+import com.vitorpamplona.quartz.events.ZapSplitSetup
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.toImmutableList
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import kotlin.math.round
+
+class ZapPaymentHandler(val account: Account) {
+
+    @Immutable
+    data class Payable(
+        val info: ZapSplitSetup,
+        val user: User?,
+        val amountMilliSats: Long,
+        val invoice: String
+    )
+
+    suspend fun zap(
+        note: Note,
+        amountMilliSats: Long,
+        pollOption: Int?,
+        message: String,
+        context: Context,
+        onError: (String, String) -> Unit,
+        onProgress: (percent: Float) -> Unit,
+        onPayViaIntent: (ImmutableList<Payable>) -> Unit,
+        zapType: LnZapEvent.ZapType
+    ) = withContext(Dispatchers.IO) {
+        val zapSplitSetup = note.event?.zapSplitSetup()
+
+        val zapsToSend = if (!zapSplitSetup.isNullOrEmpty()) {
+            zapSplitSetup
+        } else {
+            val lud16 = note.author?.info?.lud16?.trim() ?: note.author?.info?.lud06?.trim()
+
+            if (lud16.isNullOrBlank()) {
+                onError(
+                    context.getString(R.string.missing_lud16),
+                    context.getString(R.string.user_does_not_have_a_lightning_address_setup_to_receive_sats)
+                )
+                return@withContext
+            }
+
+            listOf(ZapSplitSetup(lud16, null, weight = 1.0, true))
+        }
+
+        val totalWeight = zapsToSend.sumOf { it.weight }
+
+        val invoicesToPayOnIntent = mutableListOf<Payable>()
+
+        zapsToSend.forEachIndexed { index, value ->
+            val outerProgressMin = index / zapsToSend.size.toFloat()
+            val outerProgressMax = (index + 1) / zapsToSend.size.toFloat()
+
+            val zapValue =
+                round((amountMilliSats * value.weight / totalWeight) / 1000f).toLong() * 1000
+
+            if (value.isLnAddress) {
+                innerZap(
+                    lud16 = value.lnAddressOrPubKeyHex,
+                    note = note,
+                    amount = zapValue,
+                    pollOption = pollOption,
+                    message = message,
+                    context = context,
+                    onError = onError,
+                    onProgress = {
+                        onProgress((it * (outerProgressMax - outerProgressMin)) + outerProgressMin)
+                    },
+                    zapType = zapType,
+                    onPayInvoiceThroughIntent = {
+                        invoicesToPayOnIntent.add(
+                            Payable(
+                                info = value,
+                                user = null,
+                                amountMilliSats = zapValue,
+                                invoice = it
+                            )
+                        )
+                    }
+                )
+            } else {
+                val user = LocalCache.getUserIfExists(value.lnAddressOrPubKeyHex)
+                val lud16 = user?.info?.lnAddress()
+
+                if (lud16 != null) {
+                    innerZap(
+                        lud16 = lud16,
+                        note = note,
+                        amount = zapValue,
+                        pollOption = pollOption,
+                        message = message,
+                        context = context,
+                        onError = onError,
+                        onProgress = {
+                            onProgress((it * (outerProgressMax - outerProgressMin)) + outerProgressMin)
+                        },
+                        zapType = zapType,
+                        overrideUser = user,
+                        onPayInvoiceThroughIntent = {
+                            invoicesToPayOnIntent.add(
+                                Payable(
+                                    info = value,
+                                    user = user,
+                                    amountMilliSats = zapValue,
+                                    invoice = it
+                                )
+                            )
+                        }
+                    )
+                } else {
+                    onError(
+                        context.getString(
+                            R.string.missing_lud16
+                        ),
+                        context.getString(
+                            R.string.user_x_does_not_have_a_lightning_address_setup_to_receive_sats,
+                            user?.toBestDisplayName() ?: value.lnAddressOrPubKeyHex
+                        )
+                    )
+                }
+            }
+        }
+
+        if (invoicesToPayOnIntent.isNotEmpty()) {
+            onPayViaIntent(invoicesToPayOnIntent.toImmutableList())
+            onProgress(1f)
+        } else {
+            launch(Dispatchers.IO) {
+                // Awaits for the event to come back to LocalCache.
+                delay(5000)
+                onProgress(1f)
+            }
+        }
+    }
+
+    private suspend fun innerZap(
+        lud16: String,
+        note: Note,
+        amount: Long,
+        pollOption: Int?,
+        message: String,
+        context: Context,
+        onError: (String, String) -> Unit,
+        onProgress: (percent: Float) -> Unit,
+        onPayInvoiceThroughIntent: (String) -> Unit,
+        zapType: LnZapEvent.ZapType,
+        overrideUser: User? = null
+    ) {
+        var zapRequestJson = ""
+
+        if (zapType != LnZapEvent.ZapType.NONZAP) {
+            val zapRequest = account.createZapRequestFor(note, pollOption, message, zapType, overrideUser)
+            if (zapRequest != null) {
+                zapRequestJson = zapRequest.toJson()
+            }
+        }
+
+        onProgress(0.10f)
+
+        LightningAddressResolver().lnAddressInvoice(
+            lud16,
+            amount,
+            message,
+            zapRequestJson,
+            onSuccess = {
+                onProgress(0.7f)
+                if (account.hasWalletConnectSetup()) {
+                    account.sendZapPaymentRequestFor(
+                        bolt11 = it,
+                        note,
+                        onResponse = { response ->
+                            if (response is PayInvoiceErrorResponse) {
+                                onProgress(0.0f)
+                                onError(
+                                    context.getString(R.string.error_dialog_pay_invoice_error),
+                                    context.getString(
+                                        R.string.wallet_connect_pay_invoice_error_error,
+                                        response.error?.message
+                                            ?: response.error?.code?.toString()
+                                            ?: "Error parsing error message"
+                                    )
+                                )
+                            } else {
+                                onProgress(1f)
+                            }
+                        }
+                    )
+                    onProgress(0.8f)
+                } else {
+                    onPayInvoiceThroughIntent(it)
+                    onProgress(0f)
+                }
+            },
+            onError = onError,
+            onProgress = onProgress,
+            context = context
+        )
+    }
+}

app/src/main/java/com/vitorpamplona/amethyst/service/lnurl/LightningAddressResolver.kt

@@ -1,19 +1,19 @@
 package com.vitorpamplona.amethyst.service.lnurl
 
+import android.content.Context
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
 import com.vitorpamplona.amethyst.BuildConfig
+import com.vitorpamplona.amethyst.R
 import com.vitorpamplona.amethyst.service.HttpClient
 import com.vitorpamplona.amethyst.service.checkNotInMainThread
-import com.vitorpamplona.quartz.encoders.Bech32
 import com.vitorpamplona.quartz.encoders.LnInvoiceUtil
+import com.vitorpamplona.quartz.encoders.Lud06
 import com.vitorpamplona.quartz.encoders.toLnUrl
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
-import okhttp3.Call
-import okhttp3.Callback
 import okhttp3.Request
-import okhttp3.Response
 import java.math.BigDecimal
+import java.math.RoundingMode
 import java.net.URLEncoder
 
 class LightningAddressResolver() {
@@ -27,23 +27,30 @@ class LightningAddressResolver() {
         }
 
         if (lnaddress.lowercase().startsWith("lnurl")) {
-            return try {
-                String(Bech32.decodeBytes(lnaddress, false).second)
-            } catch (e: Exception) {
-                null
-            }
+            return Lud06().toLnUrlp(lnaddress)
         }
 
         return null
     }
 
-    private suspend fun fetchLightningAddressJson(lnaddress: String, onSuccess: suspend (String) -> Unit, onError: (String) -> Unit) = withContext(Dispatchers.IO) {
+    private suspend fun fetchLightningAddressJson(
+        lnaddress: String,
+        onSuccess: suspend (String) -> Unit,
+        onError: (String, String) -> Unit,
+        context: Context
+    ) = withContext(Dispatchers.IO) {
         checkNotInMainThread()
 
         val url = assembleUrl(lnaddress)
 
         if (url == null) {
-            onError("Could not assemble LNUrl from Lightning Address \"${lnaddress}\". Check the user's setup")
+            onError(
+                context.getString(R.string.error_unable_to_fetch_invoice),
+                context.getString(
+                    R.string.could_not_assemble_lnurl_from_lightning_address_check_the_user_s_setup,
+                    lnaddress
+                )
+            )
             return@withContext
         }
 
@@ -57,16 +64,39 @@ class LightningAddressResolver() {
                 if (it.isSuccessful) {
                     onSuccess(it.body.string())
                 } else {
-                    onError("The receiver's lightning service at $url is not available. It was calculated from the lightning address \"${lnaddress}\". Error: ${it.code}. Check if the server is up and if the lightning address is correct")
+                    onError(
+                        context.getString(R.string.error_unable_to_fetch_invoice),
+                        context.getString(
+                            R.string.the_receiver_s_lightning_service_at_is_not_available_it_was_calculated_from_the_lightning_address_error_check_if_the_server_is_up_and_if_the_lightning_address_is_correct,
+                            url,
+                            lnaddress,
+                            it.code.toString()
+                        )
+                    )
                 }
             }
         } catch (e: Exception) {
             e.printStackTrace()
-            onError("Could not resolve $url. Check if the server is up and if the lightning address $lnaddress is correct")
+            onError(
+                context.getString(R.string.error_unable_to_fetch_invoice),
+                context.getString(
+                    R.string.could_not_resolve_check_if_you_are_connected_if_the_server_is_up_and_if_the_lightning_address_is_correct,
+                    url,
+                    lnaddress
+                )
+            )
         }
     }
 
-    suspend fun fetchLightningInvoice(lnCallback: String, milliSats: Long, message: String, nostrRequest: String? = null, onSuccess: (String) -> Unit, onError: (String) -> Unit) = withContext(Dispatchers.IO) {
+    suspend fun fetchLightningInvoice(
+        lnCallback: String,
+        milliSats: Long,
+        message: String,
+        nostrRequest: String? = null,
+        onSuccess: suspend (String) -> Unit,
+        onError: (String, String) -> Unit,
+        context: Context
+    ) = withContext(Dispatchers.IO) {
         val encodedMessage = URLEncoder.encode(message, "utf-8")
 
         val urlBinder = if (lnCallback.contains("?")) "&" else "?"
@@ -82,31 +112,26 @@ class LightningAddressResolver() {
             .url(url)
             .build()
 
-        client.newCall(request).enqueue(object : Callback {
-            override fun onResponse(call: Call, response: Response) {
-                response.use {
-                    if (it.isSuccessful) {
-                        onSuccess(response.body.string())
-                    } else {
-                        onError("Could not fetch invoice from $lnCallback")
-                    }
-                }
+        client.newCall(request).execute().use {
+            if (it.isSuccessful) {
+                onSuccess(it.body.string())
+            } else {
+                onError(
+                    context.getString(R.string.error_unable_to_fetch_invoice),
+                    context.getString(R.string.could_not_fetch_invoice_from, lnCallback)
+                )
             }
-
-            override fun onFailure(call: Call, e: java.io.IOException) {
-                onError("Could not fetch an invoice from $lnCallback. Message ${e.message}")
-                e.printStackTrace()
-            }
-        })
+        }
     }
 
-    suspend fun lnAddressToLnUrl(lnaddress: String, onSuccess: (String) -> Unit, onError: (String) -> Unit) {
+    suspend fun lnAddressToLnUrl(lnaddress: String, onSuccess: (String) -> Unit, onError: (String, String) -> Unit, context: Context) {
         fetchLightningAddressJson(
             lnaddress,
             onSuccess = {
                 onSuccess(it.toByteArray().toLnUrl())
             },
-            onError = onError
+            onError = onError,
+            context = context
         )
     }
 
@@ -115,9 +140,10 @@ class LightningAddressResolver() {
         milliSats: Long,
         message: String,
         nostrRequest: String? = null,
-        onSuccess: (String) -> Unit,
-        onError: (String) -> Unit,
-        onProgress: (percent: Float) -> Unit
+        onSuccess: suspend (String) -> Unit,
+        onError: (String, String) -> Unit,
+        onProgress: (percent: Float) -> Unit,
+        context: Context
     ) {
         val mapper = jacksonObjectMapper()
 
@@ -129,14 +155,20 @@ class LightningAddressResolver() {
                 val lnurlp = try {
                     mapper.readTree(lnAddressJson)
                 } catch (t: Throwable) {
-                    onError("Error Parsing JSON from Lightning Address. Check the user's lightning setup")
+                    onError(
+                        context.getString(R.string.error_unable_to_fetch_invoice),
+                        context.getString(R.string.error_parsing_json_from_lightning_address_check_the_user_s_lightning_setup)
+                    )
                     null
                 }
 
                 val callback = lnurlp?.get("callback")?.asText()
 
                 if (callback == null) {
-                    onError("Callback URL not found in the User's lightning address server configuration")
+                    onError(
+                        context.getString(R.string.error_unable_to_fetch_invoice),
+                        context.getString(R.string.callback_url_not_found_in_the_user_s_lightning_address_server_configuration)
+                    )
                 }
 
                 val allowsNostr = lnurlp?.get("allowsNostr")?.asBoolean() ?: false
@@ -153,33 +185,56 @@ class LightningAddressResolver() {
                             val lnInvoice = try {
                                 mapper.readTree(it)
                             } catch (t: Throwable) {
-                                onError("Error Parsing JSON from Lightning Address's invoice fetch. Check the user's lightning setup")
+                                onError(
+                                    context.getString(R.string.error_unable_to_fetch_invoice),
+                                    context.getString(R.string.error_parsing_json_from_lightning_address_s_invoice_fetch_check_the_user_s_lightning_setup)
+                                )
                                 null
                             }
 
                             lnInvoice?.get("pr")?.asText()?.ifBlank { null }?.let { pr ->
                                 // Forces LN Invoice amount to be the requested amount.
+                                val expectedAmountInSats = BigDecimal(milliSats).divide(BigDecimal(1000), RoundingMode.HALF_UP).toLong()
                                 val invoiceAmount = LnInvoiceUtil.getAmountInSats(pr)
-                                if (invoiceAmount.multiply(BigDecimal(1000)).toLong() == BigDecimal(milliSats).toLong()) {
+                                if (invoiceAmount.toLong() == expectedAmountInSats) {
                                     onProgress(0.7f)
                                     onSuccess(pr)
                                 } else {
                                     onProgress(0.0f)
-                                    onError("Incorrect invoice amount (${invoiceAmount.toLong()} sats) from server")
+                                    onError(
+                                        context.getString(R.string.error_unable_to_fetch_invoice),
+                                        context.getString(
+                                            R.string.incorrect_invoice_amount_sats_from_it_should_have_been,
+                                            invoiceAmount.toLong().toString(),
+                                            lnaddress,
+                                            expectedAmountInSats.toString()
+                                        )
+                                    )
                                 }
                             } ?: lnInvoice?.get("reason")?.asText()?.ifBlank { null }?.let { reason ->
                                 onProgress(0.0f)
-                                onError("Unable to create a lightning invoice before sending the zap. The receiver's lightning wallet sent the following error: $reason")
+                                onError(
+                                    context.getString(R.string.error_unable_to_fetch_invoice),
+                                    context.getString(
+                                        R.string.unable_to_create_a_lightning_invoice_before_sending_the_zap_the_receiver_s_lightning_wallet_sent_the_following_error,
+                                        reason
+                                    )
+                                )
                             } ?: run {
                                 onProgress(0.0f)
-                                onError("nable to create a lightning invoice before sending the zap. Element pr not found in the resulting JSON.")
+                                onError(
+                                    context.getString(R.string.error_unable_to_fetch_invoice),
+                                    context.getString(R.string.unable_to_create_a_lightning_invoice_before_sending_the_zap_element_pr_not_found_in_the_resulting_json)
+                                )
                             }
                         },
-                        onError = onError
+                        onError = onError,
+                        context
                     )
                 }
             },
-            onError = onError
+            onError = onError,
+            context
         )
     }
 }

app/src/main/java/com/vitorpamplona/amethyst/service/notifications/EventNotificationConsumer.kt

@@ -7,6 +7,8 @@ import com.vitorpamplona.amethyst.LocalPreferences
 import com.vitorpamplona.amethyst.R
 import com.vitorpamplona.amethyst.model.Account
 import com.vitorpamplona.amethyst.model.LocalCache
+import com.vitorpamplona.amethyst.service.ExternalSignerUtils
+import com.vitorpamplona.amethyst.service.SignerType
 import com.vitorpamplona.amethyst.service.notifications.NotificationUtils.sendDMNotification
 import com.vitorpamplona.amethyst.service.notifications.NotificationUtils.sendZapNotification
 import com.vitorpamplona.amethyst.ui.note.showAmount
@@ -32,27 +34,57 @@ class EventNotificationConsumer(private val applicationContext: Context) {
         // Test with all logged in accounts
         LocalPreferences.allSavedAccounts().forEach {
             val acc = LocalPreferences.loadFromEncryptedStorage(it.npub)
-            if (acc != null && acc.keyPair.privKey != null) {
+            if (acc != null && (acc.keyPair.privKey != null || acc.loginWithExternalSigner)) {
                 consumeIfMatchesAccount(event, acc)
             }
         }
     }
 
     private suspend fun consumeIfMatchesAccount(pushWrappedEvent: GiftWrapEvent, account: Account) {
-        val key = account.keyPair.privKey ?: return
-        pushWrappedEvent.unwrap(key)?.let { notificationEvent ->
-            if (!LocalCache.justVerify(notificationEvent)) return // invalid event
-            if (LocalCache.notes[notificationEvent.id] != null) return // already processed
+        val key = account.keyPair.privKey
+        if (account.loginWithExternalSigner) {
+            ExternalSignerUtils.account = account
+            var cached = ExternalSignerUtils.cachedDecryptedContent[pushWrappedEvent.id]
+            if (cached == null) {
+                ExternalSignerUtils.decrypt(
+                    pushWrappedEvent.content,
+                    pushWrappedEvent.pubKey,
+                    pushWrappedEvent.id,
+                    SignerType.NIP44_DECRYPT
+                )
+                cached = ExternalSignerUtils.cachedDecryptedContent[pushWrappedEvent.id] ?: ""
+            }
+            pushWrappedEvent.unwrap(cached)?.let { notificationEvent ->
+                if (!LocalCache.justVerify(notificationEvent)) return // invalid event
+                if (LocalCache.notes[notificationEvent.id] != null) return // already processed
 
-            LocalCache.justConsume(notificationEvent, null)
+                LocalCache.justConsume(notificationEvent, null)
 
-            unwrapAndConsume(notificationEvent, account)?.let { innerEvent ->
-                if (innerEvent is PrivateDmEvent) {
-                    notify(innerEvent, account)
-                } else if (innerEvent is LnZapEvent) {
-                    notify(innerEvent, account)
-                } else if (innerEvent is ChatMessageEvent) {
-                    notify(innerEvent, account)
+                unwrapAndConsume(notificationEvent, account)?.let { innerEvent ->
+                    if (innerEvent is PrivateDmEvent) {
+                        notify(innerEvent, account)
+                    } else if (innerEvent is LnZapEvent) {
+                        notify(innerEvent, account)
+                    } else if (innerEvent is ChatMessageEvent) {
+                        notify(innerEvent, account)
+                    }
+                }
+            }
+        } else if (key != null) {
+            pushWrappedEvent.unwrap(key)?.let { notificationEvent ->
+                if (!LocalCache.justVerify(notificationEvent)) return // invalid event
+                if (LocalCache.notes[notificationEvent.id] != null) return // already processed
+
+                LocalCache.justConsume(notificationEvent, null)
+
+                unwrapAndConsume(notificationEvent, account)?.let { innerEvent ->
+                    if (innerEvent is PrivateDmEvent) {
+                        notify(innerEvent, account)
+                    } else if (innerEvent is LnZapEvent) {
+                        notify(innerEvent, account)
+                    } else if (innerEvent is ChatMessageEvent) {
+                        notify(innerEvent, account)
+                    }
                 }
             }
         }
@@ -63,17 +95,54 @@ class EventNotificationConsumer(private val applicationContext: Context) {
 
         return when (event) {
             is GiftWrapEvent -> {
-                val key = account.keyPair.privKey ?: return null
-                event.cachedGift(key)?.let {
-                    unwrapAndConsume(it, account)
+                val key = account.keyPair.privKey
+                if (key != null) {
+                    event.cachedGift(key)?.let {
+                        unwrapAndConsume(it, account)
+                    }
+                } else if (account.loginWithExternalSigner) {
+                    var cached = ExternalSignerUtils.cachedDecryptedContent[event.id]
+                    if (cached == null) {
+                        ExternalSignerUtils.decrypt(
+                            event.content,
+                            event.pubKey,
+                            event.id,
+                            SignerType.NIP44_DECRYPT
+                        )
+                        cached = ExternalSignerUtils.cachedDecryptedContent[event.id] ?: ""
+                    }
+                    event.cachedGift(account.keyPair.pubKey, cached)?.let {
+                        unwrapAndConsume(it, account)
+                    }
+                } else {
+                    null
                 }
             }
             is SealedGossipEvent -> {
-                val key = account.keyPair.privKey ?: return null
-                event.cachedGossip(key)?.let {
-                    // this is not verifiable
-                    LocalCache.justConsume(it, null)
-                    it
+                val key = account.keyPair.privKey
+                if (key != null) {
+                    event.cachedGossip(key)?.let {
+                        // this is not verifiable
+                        LocalCache.justConsume(it, null)
+                        it
+                    }
+                } else if (account.loginWithExternalSigner) {
+                    var cached = ExternalSignerUtils.cachedDecryptedContent[event.id]
+                    if (cached == null) {
+                        ExternalSignerUtils.decrypt(
+                            event.content,
+                            event.pubKey,
+                            event.id,
+                            SignerType.NIP44_DECRYPT
+                        )
+                        cached = ExternalSignerUtils.cachedDecryptedContent[event.id] ?: ""
+                    }
+                    event.cachedGossip(account.keyPair.pubKey, cached)?.let {
+                        LocalCache.justConsume(it, null)
+                        it
+                    }
+                } else {
+                    null
                 }
             }
             else -> {
@@ -154,7 +223,7 @@ class EventNotificationConsumer(private val applicationContext: Context) {
 
         if ((event.amount ?: BigDecimal.ZERO) < BigDecimal.TEN) return
 
-        if (acc != null && acc.userProfile().pubkeyHex == event.zappedAuthor().firstOrNull()) {
+        if (acc.userProfile().pubkeyHex == event.zappedAuthor().firstOrNull()) {
             val amount = showAmount(event.amount)
             val senderInfo = (noteZapRequest.event as? LnZapRequestEvent)?.let {
                 val decryptedContent = acc.decryptZapContentAuthor(noteZapRequest)

app/src/main/java/com/vitorpamplona/amethyst/service/notifications/RegisterAccounts.kt

@@ -4,6 +4,7 @@ import android.util.Log
 import com.vitorpamplona.amethyst.AccountInfo
 import com.vitorpamplona.amethyst.BuildConfig
 import com.vitorpamplona.amethyst.LocalPreferences
+import com.vitorpamplona.amethyst.service.ExternalSignerUtils
 import com.vitorpamplona.amethyst.service.HttpClient
 import com.vitorpamplona.quartz.events.RelayAuthEvent
 import kotlinx.coroutines.Dispatchers
@@ -23,7 +24,10 @@ class RegisterAccounts(
     ): List<RelayAuthEvent> {
         return accounts.mapNotNull {
             val acc = LocalPreferences.loadFromEncryptedStorage(it.npub)
-            if (acc != null) {
+            if (acc != null && (acc.isWriteable() || acc.loginWithExternalSigner)) {
+                if (acc.loginWithExternalSigner) {
+                    ExternalSignerUtils.account = acc
+                }
                 val relayToUse = acc.activeRelays()?.firstOrNull { it.read }
                 if (relayToUse != null) {
                     acc.createAuthEvent(relayToUse, notificationToken)
@@ -36,7 +40,7 @@ class RegisterAccounts(
         }
     }
 
-    private fun postRegistrationEvent(events: List<RelayAuthEvent>) {
+    fun postRegistrationEvent(events: List<RelayAuthEvent>) {
         try {
             val jsonObject = """{
                 "events": [ ${events.joinToString(", ") { it.toJson() }} ]
@@ -66,5 +70,6 @@ class RegisterAccounts(
         postRegistrationEvent(
             signEventsToProveControlOfAccounts(accounts, notificationToken)
         )
+        PushNotificationUtils.hasInit = true
     }
 }

app/src/main/java/com/vitorpamplona/amethyst/service/playback/MultiPlayerPlaybackManager.kt

@@ -1,4 +1,4 @@
-package com.vitorpamplona.amethyst
+package com.vitorpamplona.amethyst.service.playback
 
 import android.app.PendingIntent
 import android.content.Context
@@ -84,6 +84,7 @@ class MultiPlayerPlaybackManager(
                     playingMap.put(id, mediaSession)
                 } else {
                     player.setWakeMode(C.WAKE_MODE_NONE)
+                    cachedPositions.add(uri, player.currentPosition)
                     cache.put(id, mediaSession)
                     playingMap.remove(id, mediaSession)
                 }
@@ -92,7 +93,8 @@ class MultiPlayerPlaybackManager(
             override fun onPlaybackStateChanged(playbackState: Int) {
                 when (playbackState) {
                     STATE_IDLE -> {
-                        if (player.currentPosition > 5 * 60) { // 5 seconds
+                        // only saves if it wqs playing
+                        if (abs(player.currentPosition) > 1) {
                             cachedPositions.add(uri, player.currentPosition)
                         }
                     }
@@ -104,7 +106,8 @@ class MultiPlayerPlaybackManager(
                         }
                     }
                     else -> {
-                        if (player.currentPosition > 5 * 60) { // 5 seconds
+                        // only saves if it wqs playing
+                        if (abs(player.currentPosition) > 1) {
                             cachedPositions.add(uri, player.currentPosition)
                         }
                     }

app/src/main/java/com/vitorpamplona/amethyst/service/playback/PlaybackClientController.kt

@@ -1,4 +1,4 @@
-package com.vitorpamplona.amethyst
+package com.vitorpamplona.amethyst.service.playback
 
 import android.content.ComponentName
 import android.content.Context

app/src/main/java/com/vitorpamplona/amethyst/service/playback/PlaybackService.kt

@@ -1,4 +1,4 @@
-package com.vitorpamplona.amethyst
+package com.vitorpamplona.amethyst.service.playback
 
 import androidx.annotation.OptIn
 import androidx.media3.common.util.UnstableApi
@@ -8,6 +8,7 @@ import androidx.media3.exoplayer.source.MediaSource
 import androidx.media3.exoplayer.source.ProgressiveMediaSource
 import androidx.media3.session.MediaSession
 import androidx.media3.session.MediaSessionService
+import com.vitorpamplona.amethyst.Amethyst
 import com.vitorpamplona.amethyst.service.HttpClient
 
 @UnstableApi // Extend MediaSessionService
@@ -23,7 +24,12 @@ class PlaybackService : MediaSessionService() {
     }
 
     fun newProgressiveDataSource(): MediaSource.Factory {
-        return ProgressiveMediaSource.Factory(VideoCache.get(Amethyst.instance, HttpClient.getHttpClient()))
+        return ProgressiveMediaSource.Factory(
+            VideoCache.get(
+                Amethyst.instance,
+                HttpClient.getHttpClient()
+            )
+        )
     }
 
     fun lazyHlsDS(): MultiPlayerPlaybackManager {

app/src/main/java/com/vitorpamplona/amethyst/service/playback/VideoCache.kt

@@ -1,4 +1,4 @@
-package com.vitorpamplona.amethyst
+package com.vitorpamplona.amethyst.service.playback
 
 import android.content.Context
 import androidx.media3.common.util.UnstableApi
@@ -12,7 +12,7 @@ import java.io.File
 
 @UnstableApi object VideoCache {
 
-    var exoPlayerCacheSize: Long = 90 * 1024 * 1024 // 90MB
+    var exoPlayerCacheSize: Long = 150 * 1024 * 1024 // 90MB
 
     var leastRecentlyUsedCacheEvictor = LeastRecentlyUsedCacheEvictor(exoPlayerCacheSize)
 

app/src/main/java/com/vitorpamplona/amethyst/service/playback/VideoViewedPositionCache.kt

@@ -1,4 +1,4 @@
-package com.vitorpamplona.amethyst
+package com.vitorpamplona.amethyst.service.playback
 
 import android.util.LruCache
 

app/src/main/java/com/vitorpamplona/amethyst/service/previews/BahaUrlPreview.kt

@@ -1,8 +1,9 @@
 package com.vitorpamplona.amethyst.service.previews
 
 import android.net.Uri
-import kotlinx.coroutines.*
-import java.util.*
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.util.Locale
 
 class BahaUrlPreview(val url: String, var callback: IUrlPreviewCallback?) {
     private val imageExtensionArray = arrayOf(".gif", ".png", ".jpg", ".jpeg", ".bmp", ".webp")

app/src/main/java/com/vitorpamplona/amethyst/service/previews/UrlPreviewUtils.kt

@@ -64,7 +64,11 @@ suspend fun getDocument(url: String, timeOut: Int = 30000): Document =
     withContext(Dispatchers.IO) {
         val request: Request = Request.Builder().url(url).get().build()
         val html = HttpClient.getHttpClient().newCall(request).execute().use {
-            it.body.string()
+            if (it.isSuccessful) {
+                it.body.string()
+            } else {
+                throw IllegalArgumentException("Website returned: " + it.code)
+            }
         }
 
         Jsoup.parse(html)

app/src/main/java/com/vitorpamplona/amethyst/service/relays/EOSE.kt

@@ -43,4 +43,8 @@ class EOSEAccount(var users: Map<User, EOSEFollowList> = emptyMap()) {
             followList.addOrUpdate(listCode, relayUrl, time)
         }
     }
+
+    fun removeDataFor(user: User) {
+        users = users.minus(user)
+    }
 }

app/src/main/java/com/vitorpamplona/amethyst/service/relays/Relay.kt

@@ -3,6 +3,7 @@ package com.vitorpamplona.amethyst.service.relays
 import android.util.Log
 import com.vitorpamplona.amethyst.BuildConfig
 import com.vitorpamplona.amethyst.service.checkNotInMainThread
+import com.vitorpamplona.quartz.encoders.HexKey
 import com.vitorpamplona.quartz.events.Event
 import com.vitorpamplona.quartz.events.EventInterface
 import com.vitorpamplona.quartz.events.RelayAuthEvent
@@ -60,6 +61,8 @@ class Relay(
 
     var afterEOSE = false
 
+    val authResponse = mutableMapOf<HexKey, Boolean>()
+
     fun register(listener: Listener) {
         listeners = listeners.plus(listener)
     }
@@ -77,9 +80,7 @@ class Relay(
             checkNotInMainThread()
 
             // Sends everything.
-            Client.allSubscriptions().forEach {
-                sendFilter(requestId = it)
-            }
+            renewFilters()
         }
     }
 
@@ -224,8 +225,20 @@ class Relay(
                 it.onError(this@Relay, channel, Error("Relay sent notice: " + channel))
             }
             "OK" -> listeners.forEach {
-                Log.w("Relay", "Relay on OK $url, ${msgArray[1].asText()}, ${msgArray[2].asBoolean()}, ${msgArray[3].asText()}")
-                it.onSendResponse(this@Relay, msgArray[1].asText(), msgArray[2].asBoolean(), msgArray[3].asText())
+                val eventId = msgArray[1].asText()
+                val sucess = msgArray[2].asBoolean()
+                val message = msgArray[3].asText()
+
+                if (authResponse.containsKey(eventId)) {
+                    val wasAlreadyAuthenticated = authResponse.get(eventId)
+                    authResponse.put(eventId, sucess)
+                    if (wasAlreadyAuthenticated != true && sucess) {
+                        renewFilters()
+                    }
+                }
+
+                Log.w("Relay", "Relay on OK $url, $eventId, $sucess, $message")
+                it.onSendResponse(this@Relay, eventId, sucess, message)
             }
             "AUTH" -> listeners.forEach {
                 // Log.w("Relay", "Relay$url, ${msg[1].asString}")
@@ -290,10 +303,18 @@ class Relay(
         }
     }
 
+    fun renewFilters() {
+        // Force update all filters after AUTH.
+        Client.allSubscriptions().forEach {
+            sendFilter(requestId = it)
+        }
+    }
+
     fun send(signedEvent: EventInterface) {
         checkNotInMainThread()
 
         if (signedEvent is RelayAuthEvent) {
+            authResponse.put(signedEvent.id, false)
             // specific protocol for this event.
             val event = """["AUTH",${signedEvent.toJson()}]"""
             socket?.send(event)

app/src/main/java/com/vitorpamplona/amethyst/ui/MainActivity.kt

@@ -16,13 +16,14 @@ import androidx.annotation.RequiresApi
 import androidx.appcompat.app.AppCompatActivity
 import androidx.appcompat.app.AppCompatDelegate
 import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.Surface
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
 import androidx.compose.ui.Modifier
 import androidx.core.os.LocaleListCompat
 import androidx.lifecycle.viewmodel.compose.viewModel
 import com.vitorpamplona.amethyst.LocalPreferences
 import com.vitorpamplona.amethyst.ServiceManager
+import com.vitorpamplona.amethyst.service.ExternalSignerUtils
 import com.vitorpamplona.amethyst.service.connectivitystatus.ConnectivityStatus
 import com.vitorpamplona.amethyst.service.notifications.PushNotificationUtils
 import com.vitorpamplona.amethyst.ui.components.DefaultMutedSetting
@@ -51,9 +52,10 @@ import java.nio.charset.StandardCharsets
 class MainActivity : AppCompatActivity() {
     @RequiresApi(Build.VERSION_CODES.R)
     override fun onCreate(savedInstanceState: Bundle?) {
+        ExternalSignerUtils.start(this)
+
         super.onCreate(savedInstanceState)
 
-        LocalPreferences.migrateSingleUserPrefs()
         val language = LocalPreferences.getPreferredLanguage()
         if (language.isNotBlank()) {
             val appLocale: LocaleListCompat = LocaleListCompat.forLanguageTags(language)
@@ -68,7 +70,7 @@ class MainActivity : AppCompatActivity() {
                 // A surface container using the 'background' color from the theme
                 Surface(
                     modifier = Modifier.fillMaxSize(),
-                    color = MaterialTheme.colors.background
+                    color = MaterialTheme.colorScheme.background
                 ) {
                     val accountStateViewModel: AccountStateViewModel = viewModel {
                         AccountStateViewModel(this@MainActivity)
@@ -99,11 +101,13 @@ class MainActivity : AppCompatActivity() {
 
         // Only starts after login
         GlobalScope.launch(Dispatchers.IO) {
-            ServiceManager.start(this@MainActivity)
+            if (ServiceManager.shouldPauseService) {
+                ServiceManager.start(this@MainActivity)
+            }
         }
 
         GlobalScope.launch(Dispatchers.IO) {
-            PushNotificationUtils().init(LocalPreferences.allSavedAccounts())
+            PushNotificationUtils.init(LocalPreferences.allSavedAccounts())
         }
     }
 
@@ -113,7 +117,9 @@ class MainActivity : AppCompatActivity() {
         debugState(this)
         // }
 
-        ServiceManager.pause()
+        if (ServiceManager.shouldPauseService) {
+            ServiceManager.pause()
+        }
         super.onPause()
     }
 
@@ -145,8 +151,10 @@ class MainActivity : AppCompatActivity() {
             Log.d("NETWORKCALLBACK", "onAvailable: Disconnecting and connecting again")
             // Only starts after login
             GlobalScope.launch(Dispatchers.IO) {
-                ServiceManager.pause()
-                ServiceManager.start(this@MainActivity)
+                if (ServiceManager.shouldPauseService) {
+                    ServiceManager.pause()
+                    ServiceManager.start(this@MainActivity)
+                }
             }
         }
 
@@ -176,7 +184,9 @@ class MainActivity : AppCompatActivity() {
             Log.d("NETWORKCALLBACK", "onLost: Disconnecting and pausing relay's connection")
             // Only starts after login
             GlobalScope.launch(Dispatchers.IO) {
-                ServiceManager.pause()
+                if (ServiceManager.shouldPauseService) {
+                    ServiceManager.pause()
+                }
             }
         }
     }

app/src/main/java/com/vitorpamplona/amethyst/ui/actions/ImageSaver.kt

@@ -11,7 +11,10 @@ import android.webkit.MimeTypeMap
 import androidx.annotation.RequiresApi
 import com.vitorpamplona.amethyst.BuildConfig
 import com.vitorpamplona.amethyst.service.HttpClient
-import okhttp3.*
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.Request
+import okhttp3.Response
 import okio.BufferedSource
 import okio.IOException
 import okio.buffer

app/src/main/java/com/vitorpamplona/amethyst/ui/actions/ImageUploader.kt

@@ -10,8 +10,13 @@ import com.vitorpamplona.amethyst.BuildConfig
 import com.vitorpamplona.amethyst.model.Account
 import com.vitorpamplona.amethyst.model.ServersAvailable
 import com.vitorpamplona.amethyst.service.HttpClient
-import okhttp3.*
+import okhttp3.Call
+import okhttp3.Callback
 import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.MultipartBody
+import okhttp3.Request
+import okhttp3.RequestBody
+import okhttp3.Response
 import okio.BufferedSink
 import okio.IOException
 import okio.source

app/src/main/java/com/vitorpamplona/amethyst/ui/actions/InformationDialog.kt

@@ -0,0 +1,54 @@
+package com.vitorpamplona.amethyst.ui.actions
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.text.selection.SelectionContainer
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Done
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Button
+import androidx.compose.material3.ButtonColors
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.Icon
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.res.stringResource
+import com.vitorpamplona.amethyst.R
+import com.vitorpamplona.amethyst.ui.theme.Size16dp
+import com.vitorpamplona.amethyst.ui.theme.StdHorzSpacer
+
+@Composable
+fun InformationDialog(
+    title: String,
+    textContent: String,
+    buttonColors: ButtonColors = ButtonDefaults.buttonColors(),
+    onDismiss: () -> Unit
+) {
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = {
+            Text(title)
+        },
+        text = {
+            SelectionContainer {
+                Text(textContent)
+            }
+        },
+        confirmButton = {
+            Button(onClick = onDismiss, colors = buttonColors, contentPadding = PaddingValues(horizontal = Size16dp)) {
+                Row(
+                    verticalAlignment = Alignment.CenterVertically
+                ) {
+                    Icon(
+                        imageVector = Icons.Outlined.Done,
+                        contentDescription = null
+                    )
+                    Spacer(StdHorzSpacer)
+                    Text(stringResource(R.string.error_dialog_button_ok))
+                }
+            }
+        }
+    )
+}

app/src/main/java/com/vitorpamplona/amethyst/ui/actions/JoinUserOrChannelView.kt

@@ -16,15 +16,15 @@ import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.LazyListState
 import androidx.compose.foundation.lazy.itemsIndexed
 import androidx.compose.foundation.lazy.rememberLazyListState
-import androidx.compose.material.Divider
-import androidx.compose.material.Icon
-import androidx.compose.material.IconButton
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.OutlinedTextField
-import androidx.compose.material.Surface
-import androidx.compose.material.Text
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Clear
+import androidx.compose.material3.Divider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
@@ -54,10 +54,12 @@ import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleEventObserver
 import androidx.lifecycle.viewmodel.compose.viewModel
 import com.vitorpamplona.amethyst.R
+import com.vitorpamplona.amethyst.model.ConnectivityType
 import com.vitorpamplona.amethyst.model.LocalCache
 import com.vitorpamplona.amethyst.model.User
 import com.vitorpamplona.amethyst.service.NostrSearchEventOrUserDataSource
 import com.vitorpamplona.amethyst.service.checkNotInMainThread
+import com.vitorpamplona.amethyst.service.connectivitystatus.ConnectivityStatus
 import com.vitorpamplona.amethyst.ui.note.ChannelName
 import com.vitorpamplona.amethyst.ui.note.ClickableUserPicture
 import com.vitorpamplona.amethyst.ui.note.SearchIcon
@@ -133,7 +135,7 @@ fun JoinUserOrChannelView(searchBarViewModel: SearchBarViewModel, onClose: () ->
 
                     Text(
                         text = "",
-                        color = MaterialTheme.colors.placeholderText,
+                        color = MaterialTheme.colorScheme.placeholderText,
                         fontWeight = FontWeight.Bold
                     )
                 }
@@ -194,7 +196,7 @@ private fun RenderSearch(
         }
     }
 
-    DisposableEffect(Unit) {
+    DisposableEffect(lifeCycleOwner) {
         val observer = LifecycleEventObserver { _, event ->
             if (event == Lifecycle.Event.ON_RESUME) {
                 println("Join Start")
@@ -270,7 +272,7 @@ private fun SearchEditTextForJoin(
             placeholder = {
                 Text(
                     text = stringResource(R.string.channel_list_user_or_group_id_demo),
-                    color = MaterialTheme.colors.placeholderText
+                    color = MaterialTheme.colorScheme.placeholderText
                 )
             },
             trailingIcon = {
@@ -303,6 +305,13 @@ private fun RenderSearchResults(
         val users by searchBarViewModel.searchResultsUsers.collectAsState()
         val channels by searchBarViewModel.searchResultsChannels.collectAsState()
         val scope = rememberCoroutineScope()
+        val automaticallyShowProfilePicture = remember {
+            when (accountViewModel.account.settings.automaticallyShowProfilePictures) {
+                ConnectivityType.WIFI_ONLY -> !ConnectivityStatus.isOnMobileData.value
+                ConnectivityType.NEVER -> false
+                ConnectivityType.ALWAYS -> true
+            }
+        }
 
         Row(
             modifier = Modifier
@@ -337,7 +346,7 @@ private fun RenderSearchResults(
                     channels,
                     key = { _, item -> "c" + item.idHex }
                 ) { _, item ->
-                    RenderChannel(item) {
+                    RenderChannel(item, automaticallyShowProfilePicture) {
                         nav("Channel/${item.idHex}")
                         searchBarViewModel.clear()
                     }
@@ -350,6 +359,7 @@ private fun RenderSearchResults(
 @Composable
 private fun RenderChannel(
     item: com.vitorpamplona.amethyst.model.Channel,
+    loadProfilePicture: Boolean,
     onClick: () -> Unit
 ) {
     val hasNewMessages = remember {
@@ -368,7 +378,8 @@ private fun RenderChannel(
         channelLastTime = null,
         channelLastContent = item.summary(),
         hasNewMessages,
-        onClick = onClick
+        onClick = onClick,
+        loadProfilePicture = loadProfilePicture
     )
 }
 
@@ -426,7 +437,7 @@ private fun DisplayUserAboutInfo(baseUser: User) {
 
     Text(
         text = about,
-        color = MaterialTheme.colors.placeholderText,
+        color = MaterialTheme.colorScheme.placeholderText,
         maxLines = 1,
         overflow = TextOverflow.Ellipsis
     )

app/src/main/java/com/vitorpamplona/amethyst/ui/actions/NewChannelView.kt

@@ -10,11 +10,11 @@ import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.foundation.verticalScroll
-import androidx.compose.material.LocalTextStyle
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.OutlinedTextField
-import androidx.compose.material.Surface
-import androidx.compose.material.Text
+import androidx.compose.material3.LocalTextStyle
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@@ -75,7 +75,7 @@ fun NewChannelView(onClose: () -> Unit, accountViewModel: AccountViewModel, chan
                     placeholder = {
                         Text(
                             text = stringResource(R.string.my_awesome_group),
-                            color = MaterialTheme.colors.placeholderText
+                            color = MaterialTheme.colorScheme.placeholderText
                         )
                     },
                     keyboardOptions = KeyboardOptions.Default.copy(
@@ -94,7 +94,7 @@ fun NewChannelView(onClose: () -> Unit, accountViewModel: AccountViewModel, chan
                     placeholder = {
                         Text(
                             text = "http://mygroup.com/logo.jpg",
-                            color = MaterialTheme.colors.placeholderText
+                            color = MaterialTheme.colorScheme.placeholderText
                         )
                     }
                 )
@@ -111,7 +111,7 @@ fun NewChannelView(onClose: () -> Unit, accountViewModel: AccountViewModel, chan
                     placeholder = {
                         Text(
                             text = stringResource(R.string.about_us),
-                            color = MaterialTheme.colors.placeholderText
+                            color = MaterialTheme.colorScheme.placeholderText
                         )
                     },
                     keyboardOptions = KeyboardOptions.Default.copy(

app/src/main/java/com/vitorpamplona/amethyst/ui/actions/NewMediaModel.kt

@@ -9,11 +9,13 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.setValue
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
-import com.vitorpamplona.amethyst.model.*
+import com.vitorpamplona.amethyst.model.Account
+import com.vitorpamplona.amethyst.model.ServersAvailable
 import com.vitorpamplona.amethyst.service.FileHeader
 import com.vitorpamplona.amethyst.service.relays.Relay
 import com.vitorpamplona.amethyst.ui.components.MediaCompressor
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.launch
 
@@ -22,11 +24,11 @@ open class NewMediaModel : ViewModel() {
     var account: Account? = null
 
     var isUploadingImage by mutableStateOf(false)
-    val imageUploadingError = MutableSharedFlow<String?>()
+    val imageUploadingError = MutableSharedFlow<String?>(0, 3, onBufferOverflow = BufferOverflow.DROP_OLDEST)
     var mediaType by mutableStateOf<String?>(null)
 
     var selectedServer by mutableStateOf<ServersAvailable?>(null)
-    var description by mutableStateOf("")
+    var alt by mutableStateOf("")
     var sensitiveContent by mutableStateOf(false)
 
     // Images and Videos
@@ -79,7 +81,7 @@ open class NewMediaModel : ViewModel() {
                         uploadingPercentage.value = 0.2f
                         uploadingDescription.value = "Loading"
                         contentResolver.openInputStream(fileUri)?.use {
-                            createNIP95Record(it.readBytes(), contentType, description, sensitiveContent, relayList = relayList)
+                            createNIP95Record(it.readBytes(), contentType, alt, sensitiveContent, relayList = relayList)
                         }
                             ?: run {
                                 viewModelScope.launch {
@@ -92,24 +94,32 @@ open class NewMediaModel : ViewModel() {
                     } else {
                         uploadingPercentage.value = 0.2f
                         uploadingDescription.value = "Uploading"
-                        ImageUploader.uploadImage(
-                            uri = fileUri,
-                            contentType = contentType,
-                            size = size,
-                            server = serverToUse,
-                            contentResolver = contentResolver,
-                            onSuccess = { imageUrl, mimeType ->
-                                createNIP94Record(imageUrl, mimeType, description, sensitiveContent, relayList = relayList)
-                            },
-                            onError = {
-                                isUploadingImage = false
-                                uploadingPercentage.value = 0.00f
-                                uploadingDescription.value = null
-                                viewModelScope.launch {
-                                    imageUploadingError.emit("Failed to upload the image / video")
+                        viewModelScope.launch(Dispatchers.IO) {
+                            ImageUploader.uploadImage(
+                                uri = fileUri,
+                                contentType = contentType,
+                                size = size,
+                                server = serverToUse,
+                                contentResolver = contentResolver,
+                                onSuccess = { imageUrl, mimeType ->
+                                    createNIP94Record(
+                                        imageUrl,
+                                        mimeType,
+                                        alt,
+                                        sensitiveContent,
+                                        relayList = relayList
+                                    )
+                                },
+                                onError = {
+                                    isUploadingImage = false
+                                    uploadingPercentage.value = 0.00f
+                                    uploadingDescription.value = null
+                                    viewModelScope.launch {
+                                        imageUploadingError.emit("Failed to upload the image / video")
+                                    }
                                 }
-                            }
-                        )
+                            )
+                        }
                     }
                 },
                 onError = {
@@ -131,7 +141,7 @@ open class NewMediaModel : ViewModel() {
         uploadingDescription.value = null
         uploadingPercentage.value = 0.0f
 
-        description = ""
+        alt = ""
         selectedServer = account?.defaultFileServer
     }
 
@@ -139,7 +149,7 @@ open class NewMediaModel : ViewModel() {
         return !isUploadingImage && galleryUri != null && selectedServer != null
     }
 
-    fun createNIP94Record(imageUrl: String, mimeType: String?, description: String, sensitiveContent: Boolean, relayList: List<Relay>? = null) {
+    fun createNIP94Record(imageUrl: String, mimeType: String?, alt: String, sensitiveContent: Boolean, relayList: List<Relay>? = null) {
         uploadingPercentage.value = 0.40f
         viewModelScope.launch(Dispatchers.IO) {
             uploadingDescription.value = "Server Processing"
@@ -158,7 +168,7 @@ open class NewMediaModel : ViewModel() {
                     imageData,
                     imageUrl,
                     mimeType,
-                    description,
+                    alt,
                     sensitiveContent,
                     onReady = {
                         uploadingPercentage.value = 0.90f
@@ -192,7 +202,7 @@ open class NewMediaModel : ViewModel() {
         }
     }
 
-    fun createNIP95Record(bytes: ByteArray, mimeType: String?, description: String, sensitiveContent: Boolean, relayList: List<Relay>? = null) {
+    fun createNIP95Record(bytes: ByteArray, mimeType: String?, alt: String, sensitiveContent: Boolean, relayList: List<Relay>? = null) {
         uploadingPercentage.value = 0.30f
         uploadingDescription.value = "Hashing"
 
@@ -201,7 +211,7 @@ open class NewMediaModel : ViewModel() {
                 bytes,
                 "",
                 mimeType,
-                description,
+                alt,
                 sensitiveContent,
                 onReady = {
                     uploadingDescription.value = "Signing"

app/src/main/java/com/vitorpamplona/amethyst/ui/actions/NewMediaView.kt

@@ -21,12 +21,12 @@ import androidx.compose.foundation.layout.windowInsetsPadding
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.foundation.verticalScroll
-import androidx.compose.material.Icon
-import androidx.compose.material.IconButton
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.OutlinedTextField
-import androidx.compose.material.Surface
-import androidx.compose.material.Text
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
@@ -50,6 +50,7 @@ import com.vitorpamplona.amethyst.model.ServersAvailable
 import com.vitorpamplona.amethyst.ui.components.VideoView
 import com.vitorpamplona.amethyst.ui.screen.loggedIn.AccountViewModel
 import com.vitorpamplona.amethyst.ui.screen.loggedIn.TextSpinner
+import com.vitorpamplona.amethyst.ui.screen.loggedIn.TitleExplainer
 import com.vitorpamplona.amethyst.ui.theme.placeholderText
 import kotlinx.collections.immutable.toImmutableList
 import kotlinx.coroutines.Dispatchers
@@ -134,7 +135,7 @@ fun NewMediaView(uri: Uri, onClose: () -> Unit, postViewModel: NewMediaModel, ac
                                 painter = painterResource(R.drawable.relays),
                                 contentDescription = null,
                                 modifier = Modifier.height(25.dp),
-                                tint = MaterialTheme.colors.onBackground
+                                tint = MaterialTheme.colorScheme.onBackground
                             )
                         }
                     }
@@ -186,8 +187,7 @@ fun ImageVideoPost(postViewModel: NewMediaModel, accountViewModel: AccountViewMo
         Triple(ServersAvailable.NIP95, stringResource(id = R.string.upload_server_relays_nip95), stringResource(id = R.string.upload_server_relays_nip95_explainer))
     )
 
-    val fileServerOptions = remember { fileServers.map { it.second }.toImmutableList() }
-    val fileServerExplainers = remember { fileServers.map { it.third }.toImmutableList() }
+    val fileServerOptions = remember { fileServers.map { TitleExplainer(it.second, it.third) }.toImmutableList() }
     val resolver = LocalContext.current.contentResolver
 
     Row(
@@ -252,7 +252,6 @@ fun ImageVideoPost(postViewModel: NewMediaModel, accountViewModel: AccountViewMo
             label = stringResource(id = R.string.file_server),
             placeholder = fileServers.firstOrNull { it.first == accountViewModel.account.defaultFileServer }?.second ?: fileServers[0].second,
             options = fileServerOptions,
-            explainers = fileServerExplainers,
             onSelect = {
                 postViewModel.selectedServer = fileServers[it].first
             },
@@ -288,12 +287,12 @@ fun ImageVideoPost(postViewModel: NewMediaModel, accountViewModel: AccountViewMo
                 modifier = Modifier
                     .fillMaxWidth()
                     .windowInsetsPadding(WindowInsets(0.dp, 0.dp, 0.dp, 0.dp)),
-                value = postViewModel.description,
-                onValueChange = { postViewModel.description = it },
+                value = postViewModel.alt,
+                onValueChange = { postViewModel.alt = it },
                 placeholder = {
                     Text(
                         text = stringResource(R.string.content_description_example),
-                        color = MaterialTheme.colors.placeholderText
+                        color = MaterialTheme.colorScheme.placeholderText
                     )
                 },
                 keyboardOptions = KeyboardOptions.Default.copy(

app/src/main/java/com/vitorpamplona/amethyst/ui/actions/NewMessageTagger.kt

@@ -1,6 +1,6 @@
 package com.vitorpamplona.amethyst.ui.actions
 
-import com.vitorpamplona.amethyst.model.LocalCache
+import androidx.compose.runtime.Immutable
 import com.vitorpamplona.amethyst.model.Note
 import com.vitorpamplona.amethyst.model.User
 import com.vitorpamplona.quartz.crypto.KeyPair
@@ -13,7 +13,8 @@ class NewMessageTagger(
     var message: String,
     var mentions: List<User>? = null,
     var replyTos: List<Note>? = null,
-    var channelHex: String? = null
+    var channelHex: String? = null,
+    var dao: Dao
 ) {
 
     val directMentions = mutableSetOf<HexKey>()
@@ -40,20 +41,20 @@ class NewMessageTagger(
         return (if (channelHex != null) 1 else 0) + (replyTos?.indexOf(note) ?: 0)
     }
 
-    fun run() {
+    suspend fun run() {
         // adds all references to mentions and reply tos
         message.split('\n').forEach { paragraph: String ->
             paragraph.split(' ').forEach { word: String ->
                 val results = parseDirtyWordForKey(word)
 
                 if (results?.key?.type == Nip19.Type.USER) {
-                    addUserToMentions(LocalCache.getOrCreateUser(results.key.hex))
+                    addUserToMentions(dao.getOrCreateUser(results.key.hex))
                 } else if (results?.key?.type == Nip19.Type.NOTE) {
-                    addNoteToReplyTos(LocalCache.getOrCreateNote(results.key.hex))
+                    addNoteToReplyTos(dao.getOrCreateNote(results.key.hex))
                 } else if (results?.key?.type == Nip19.Type.EVENT) {
-                    addNoteToReplyTos(LocalCache.getOrCreateNote(results.key.hex))
+                    addNoteToReplyTos(dao.getOrCreateNote(results.key.hex))
                 } else if (results?.key?.type == Nip19.Type.ADDRESS) {
-                    val note = LocalCache.checkGetOrCreateAddressableNote(results.key.hex)
+                    val note = dao.checkGetOrCreateAddressableNote(results.key.hex)
                     if (note != null) {
                         addNoteToReplyTos(note)
                     }
@@ -66,19 +67,19 @@ class NewMessageTagger(
             paragraph.split(' ').map { word: String ->
                 val results = parseDirtyWordForKey(word)
                 if (results?.key?.type == Nip19.Type.USER) {
-                    val user = LocalCache.getOrCreateUser(results.key.hex)
+                    val user = dao.getOrCreateUser(results.key.hex)
 
                     "nostr:${user.pubkeyNpub()}${results.restOfWord}"
                 } else if (results?.key?.type == Nip19.Type.NOTE) {
-                    val note = LocalCache.getOrCreateNote(results.key.hex)
+                    val note = dao.getOrCreateNote(results.key.hex)
 
                     "nostr:${note.toNEvent()}${results.restOfWord}"
                 } else if (results?.key?.type == Nip19.Type.EVENT) {
-                    val note = LocalCache.getOrCreateNote(results.key.hex)
+                    val note = dao.getOrCreateNote(results.key.hex)
 
                     "nostr:${note.toNEvent()}${results.restOfWord}"
                 } else if (results?.key?.type == Nip19.Type.ADDRESS) {
-                    val note = LocalCache.checkGetOrCreateAddressableNote(results.key.hex)
+                    val note = dao.checkGetOrCreateAddressableNote(results.key.hex)
                     if (note != null) {
                         "nostr:${note.idNote()}${results.restOfWord}"
                     } else {
@@ -91,6 +92,7 @@ class NewMessageTagger(
         }.joinToString("\n")
     }
 
+    @Immutable
     data class DirtyKeyInfo(val key: Nip19.Return, val restOfWord: String)
 
     fun parseDirtyWordForKey(mightBeAKey: String): DirtyKeyInfo? {
@@ -101,37 +103,50 @@ class NewMessageTagger(
 
         key = key.removePrefix("@")
 
-        if (key.length < 63) {
-            return null
-        }
-
         try {
-            val keyB32 = key.substring(0, 63)
-            val restOfWord = key.substring(63)
-
             if (key.startsWith("nsec1", true)) {
+                if (key.length < 63) {
+                    return null
+                }
+
+                val keyB32 = key.substring(0, 63)
+                val restOfWord = key.substring(63)
                 // Converts to npub
                 val pubkey = Nip19.uriToRoute(KeyPair(privKey = keyB32.bechToBytes()).pubKey.toNpub()) ?: return null
 
                 return DirtyKeyInfo(pubkey, restOfWord)
             } else if (key.startsWith("npub1", true)) {
+                if (key.length < 63) {
+                    return null
+                }
+
+                val keyB32 = key.substring(0, 63)
+                val restOfWord = key.substring(63)
+
                 val pubkey = Nip19.uriToRoute(keyB32) ?: return null
 
                 return DirtyKeyInfo(pubkey, restOfWord)
             } else if (key.startsWith("note1", true)) {
+                if (key.length < 63) {
+                    return null
+                }
+
+                val keyB32 = key.substring(0, 63)
+                val restOfWord = key.substring(63)
+
                 val noteId = Nip19.uriToRoute(keyB32) ?: return null
 
                 return DirtyKeyInfo(noteId, restOfWord)
             } else if (key.startsWith("nprofile", true)) {
-                val pubkeyRelay = Nip19.uriToRoute(keyB32 + restOfWord) ?: return null
+                val pubkeyRelay = Nip19.uriToRoute(key) ?: return null
 
                 return DirtyKeyInfo(pubkeyRelay, pubkeyRelay.additionalChars)
             } else if (key.startsWith("nevent1", true)) {
-                val noteRelayId = Nip19.uriToRoute(keyB32 + restOfWord) ?: return null
+                val noteRelayId = Nip19.uriToRoute(key) ?: return null
 
                 return DirtyKeyInfo(noteRelayId, noteRelayId.additionalChars)
             } else if (key.startsWith("naddr1", true)) {
-                val address = Nip19.uriToRoute(keyB32 + restOfWord) ?: return null
+                val address = Nip19.uriToRoute(key) ?: return null
 
                 return DirtyKeyInfo(address, address.additionalChars) // no way to know when they address ends and dirt begins
             }
@@ -142,3 +157,9 @@ class NewMessageTagger(
         return null
     }
 }
+
+interface Dao {
+    suspend fun getOrCreateUser(hex: String): User
+    suspend fun getOrCreateNote(hex: String): Note
+    suspend fun checkGetOrCreateAddressableNote(hex: String): Note?
+}

app/src/main/java/com/vitorpamplona/amethyst/ui/actions/NewPollClosing.kt

@@ -5,10 +5,10 @@ import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.text.KeyboardOptions
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.OutlinedTextField
-import androidx.compose.material.Text
-import androidx.compose.material.TextFieldDefaults
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.OutlinedTextFieldDefaults
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -38,13 +38,13 @@ fun NewPollClosing(pollViewModel: NewPostViewModel) {
         } catch (e: Exception) { pollViewModel.isValidClosedAt.value = false }
     }
 
-    val colorInValid = TextFieldDefaults.outlinedTextFieldColors(
-        focusedBorderColor = MaterialTheme.colors.error,
+    val colorInValid = OutlinedTextFieldDefaults.colors(
+        focusedBorderColor = MaterialTheme.colorScheme.error,
         unfocusedBorderColor = Color.Red
     )
-    val colorValid = TextFieldDefaults.outlinedTextFieldColors(
-        focusedBorderColor = MaterialTheme.colors.primary,
-        unfocusedBorderColor = MaterialTheme.colors.placeholderText
+    val colorValid = OutlinedTextFieldDefaults.colors(
+        focusedBorderColor = MaterialTheme.colorScheme.primary,
+        unfocusedBorderColor = MaterialTheme.colorScheme.placeholderText
     )
 
     Row(
@@ -60,13 +60,13 @@ fun NewPollClosing(pollViewModel: NewPostViewModel) {
             label = {
                 Text(
                     text = stringResource(R.string.poll_closing_time),
-                    color = MaterialTheme.colors.placeholderText
+                    color = MaterialTheme.colorScheme.placeholderText
                 )
             },
             placeholder = {
                 Text(
                     text = stringResource(R.string.poll_closing_time_days),
-                    color = MaterialTheme.colors.placeholderText
+                    color = MaterialTheme.colorScheme.placeholderText
                 )
             }
         )

app/src/main/java/com/vitorpamplona/amethyst/ui/actions/NewPollConsensusThreshold.kt

@@ -5,10 +5,10 @@ import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.text.KeyboardOptions
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.OutlinedTextField
-import androidx.compose.material.Text
-import androidx.compose.material.TextFieldDefaults
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.OutlinedTextFieldDefaults
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -38,13 +38,13 @@ fun NewPollConsensusThreshold(pollViewModel: NewPostViewModel) {
         } catch (e: Exception) { pollViewModel.isValidConsensusThreshold.value = false }
     }
 
-    val colorInValid = TextFieldDefaults.outlinedTextFieldColors(
-        focusedBorderColor = MaterialTheme.colors.error,
+    val colorInValid = OutlinedTextFieldDefaults.colors(
+        focusedBorderColor = MaterialTheme.colorScheme.error,
         unfocusedBorderColor = Color.Red
     )
-    val colorValid = TextFieldDefaults.outlinedTextFieldColors(
-        focusedBorderColor = MaterialTheme.colors.primary,
-        unfocusedBorderColor = MaterialTheme.colors.placeholderText
+    val colorValid = OutlinedTextFieldDefaults.colors(
+        focusedBorderColor = MaterialTheme.colorScheme.primary,
+        unfocusedBorderColor = MaterialTheme.colorScheme.placeholderText
     )
 
     Row(
@@ -60,13 +60,13 @@ fun NewPollConsensusThreshold(pollViewModel: NewPostViewModel) {
             label = {
                 Text(
                     text = stringResource(R.string.poll_consensus_threshold),
-                    color = MaterialTheme.colors.placeholderText
+                    color = MaterialTheme.colorScheme.placeholderText
                 )
             },
             placeholder = {
                 Text(
                     text = stringResource(R.string.poll_consensus_threshold_percent),
-                    color = MaterialTheme.colors.placeholderText
+                    color = MaterialTheme.colorScheme.placeholderText
                 )
             }
         )

app/src/main/java/com/vitorpamplona/amethyst/ui/actions/NewPollOption.kt

@@ -1,10 +1,14 @@
 package com.vitorpamplona.amethyst.ui.actions
 
-import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.text.KeyboardOptions
-import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Delete
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
@@ -36,13 +40,13 @@ fun NewPollOption(pollViewModel: NewPostViewModel, optionIndex: Int) {
             label = {
                 Text(
                     text = stringResource(R.string.poll_option_index).format(optionIndex + 1),
-                    color = MaterialTheme.colors.placeholderText
+                    color = MaterialTheme.colorScheme.placeholderText
                 )
             },
             placeholder = {
                 Text(
                     text = stringResource(R.string.poll_option_description),
-                    color = MaterialTheme.colors.placeholderText
+                    color = MaterialTheme.colorScheme.placeholderText
                 )
             },
             keyboardOptions = KeyboardOptions.Default.copy(

app/src/main/java/com/vitorpamplona/amethyst/ui/actions/NewPollPrimaryDescription.kt

@@ -3,8 +3,13 @@ package com.vitorpamplona.amethyst.ui.components
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.text.KeyboardOptions
-import androidx.compose.material.*
-import androidx.compose.runtime.*
+import androidx.compose.material3.LocalTextStyle
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.OutlinedTextFieldDefaults
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
 import androidx.compose.ui.ExperimentalComposeUiApi
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.FocusRequester
@@ -33,13 +38,13 @@ fun NewPollPrimaryDescription(pollViewModel: NewPostViewModel) {
         isInputValid = false
     }
 
-    val colorInValid = TextFieldDefaults.outlinedTextFieldColors(
-        focusedBorderColor = MaterialTheme.colors.error,
+    val colorInValid = OutlinedTextFieldDefaults.colors(
+        focusedBorderColor = MaterialTheme.colorScheme.error,
         unfocusedBorderColor = Color.Red
     )
-    val colorValid = TextFieldDefaults.outlinedTextFieldColors(
-        focusedBorderColor = MaterialTheme.colors.primary,
-        unfocusedBorderColor = MaterialTheme.colors.placeholderText
+    val colorValid = OutlinedTextFieldDefaults.colors(
+        focusedBorderColor = MaterialTheme.colorScheme.primary,
+        unfocusedBorderColor = MaterialTheme.colorScheme.placeholderText
     )
 
     OutlinedTextField(
@@ -50,7 +55,7 @@ fun NewPollPrimaryDescription(pollViewModel: NewPostViewModel) {
         label = {
             Text(
                 text = stringResource(R.string.poll_primary_description),
-                color = MaterialTheme.colors.placeholderText
+                color = MaterialTheme.colorScheme.placeholderText
             )
         },
         keyboardOptions = KeyboardOptions.Default.copy(
@@ -68,11 +73,11 @@ fun NewPollPrimaryDescription(pollViewModel: NewPostViewModel) {
         placeholder = {
             Text(
                 text = stringResource(R.string.poll_primary_description),
-                color = MaterialTheme.colors.placeholderText
+                color = MaterialTheme.colorScheme.placeholderText
             )
         },
         colors = if (isInputValid) colorValid else colorInValid,
-        visualTransformation = UrlUserTagTransformation(MaterialTheme.colors.primary),
+        visualTransformation = UrlUserTagTransformation(MaterialTheme.colorScheme.primary),
         textStyle = LocalTextStyle.current.copy(textDirection = TextDirection.Content)
     )
 }

app/src/main/java/com/vitorpamplona/amethyst/ui/actions/NewPollRecipientsField.kt

@@ -1,9 +1,9 @@
 package com.vitorpamplona.amethyst.ui.components
 
 import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.OutlinedTextField
-import androidx.compose.material.Text
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
@@ -30,13 +30,13 @@ fun NewPollRecipientsField(pollViewModel: NewPostViewModel, account: Account) {
         label = {
             Text(
                 text = stringResource(R.string.poll_zap_recipients),
-                color = MaterialTheme.colors.placeholderText
+                color = MaterialTheme.colorScheme.placeholderText
             )
         },
         placeholder = {
             Text(
                 text = stringResource(R.string.poll_zap_recipients),
-                color = MaterialTheme.colors.placeholderText
+                color = MaterialTheme.colorScheme.placeholderText
             )
         }
 

app/src/main/java/com/vitorpamplona/amethyst/ui/actions/NewPollVoteValueRange.kt

@@ -7,13 +7,11 @@ import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.text.KeyboardOptions
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.OutlinedTextField
-import androidx.compose.material.Text
-import androidx.compose.material.TextFieldDefaults
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.OutlinedTextFieldDefaults
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.res.stringResource
@@ -26,13 +24,13 @@ import com.vitorpamplona.amethyst.ui.theme.placeholderText
 
 @Composable
 fun NewPollVoteValueRange(pollViewModel: NewPostViewModel) {
-    val colorInValid = TextFieldDefaults.outlinedTextFieldColors(
-        focusedBorderColor = MaterialTheme.colors.error,
+    val colorInValid = OutlinedTextFieldDefaults.colors(
+        focusedBorderColor = MaterialTheme.colorScheme.error,
         unfocusedBorderColor = Color.Red
     )
-    val colorValid = TextFieldDefaults.outlinedTextFieldColors(
-        focusedBorderColor = MaterialTheme.colors.primary,
-        unfocusedBorderColor = MaterialTheme.colors.placeholderText
+    val colorValid = OutlinedTextFieldDefaults.colors(
+        focusedBorderColor = MaterialTheme.colorScheme.primary,
+        unfocusedBorderColor = MaterialTheme.colorScheme.placeholderText
     )
 
     Row(
@@ -48,13 +46,13 @@ fun NewPollVoteValueRange(pollViewModel: NewPostViewModel) {
             label = {
                 Text(
                     text = stringResource(R.string.poll_zap_value_min),
-                    color = MaterialTheme.colors.placeholderText
+                    color = MaterialTheme.colorScheme.placeholderText
                 )
             },
             placeholder = {
                 Text(
                     text = stringResource(R.string.sats),
-                    color = MaterialTheme.colors.placeholderText
+                    color = MaterialTheme.colorScheme.placeholderText
                 )
             }
         )
@@ -70,13 +68,13 @@ fun NewPollVoteValueRange(pollViewModel: NewPostViewModel) {
             label = {
                 Text(
                     text = stringResource(R.string.poll_zap_value_max),
-                    color = MaterialTheme.colors.placeholderText
+                    color = MaterialTheme.colorScheme.placeholderText
                 )
             },
             placeholder = {
                 Text(
                     text = stringResource(R.string.sats),
-                    color = MaterialTheme.colors.placeholderText
+                    color = MaterialTheme.colorScheme.placeholderText
                 )
             }
         )
@@ -88,7 +86,7 @@ fun NewPollVoteValueRange(pollViewModel: NewPostViewModel) {
     ) {
         Text(
             text = stringResource(R.string.poll_zap_value_min_max_explainer),
-            color = MaterialTheme.colors.placeholderText,
+            color = MaterialTheme.colorScheme.placeholderText,
             modifier = Modifier.padding(vertical = 10.dp)
         )
     }

app/src/main/java/com/vitorpamplona/amethyst/ui/actions/NewPostView.kt

@@ -10,7 +10,25 @@ import android.widget.Toast
 import androidx.compose.foundation.BorderStroke
 import androidx.compose.foundation.Image
 import androidx.compose.foundation.border
-import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.imePadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.layout.windowInsetsPadding
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.itemsIndexed
 import androidx.compose.foundation.rememberScrollState
@@ -18,7 +36,6 @@ import androidx.compose.foundation.selection.toggleable
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.foundation.verticalScroll
-import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.ArrowForwardIos
 import androidx.compose.material.icons.filled.Bolt
@@ -31,6 +48,24 @@ import androidx.compose.material.icons.filled.VisibilityOff
 import androidx.compose.material.icons.outlined.ArrowForwardIos
 import androidx.compose.material.icons.outlined.Bolt
 import androidx.compose.material.icons.rounded.Warning
+import androidx.compose.material3.Button
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.Divider
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.LocalTextStyle
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.OutlinedTextFieldDefaults
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Slider
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Switch
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
@@ -45,7 +80,6 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Alignment.Companion.CenterVertically
 import androidx.compose.ui.ExperimentalComposeUiApi
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusRequester
@@ -81,21 +115,36 @@ import com.vitorpamplona.amethyst.model.User
 import com.vitorpamplona.amethyst.service.NostrSearchEventOrUserDataSource
 import com.vitorpamplona.amethyst.service.ReverseGeoLocationUtil
 import com.vitorpamplona.amethyst.service.noProtocolUrlValidator
-import com.vitorpamplona.amethyst.ui.components.*
+import com.vitorpamplona.amethyst.service.startsWithNIP19Scheme
+import com.vitorpamplona.amethyst.ui.components.BechLink
+import com.vitorpamplona.amethyst.ui.components.CreateTextWithEmoji
+import com.vitorpamplona.amethyst.ui.components.InvoiceRequest
+import com.vitorpamplona.amethyst.ui.components.UrlPreview
+import com.vitorpamplona.amethyst.ui.components.VideoView
+import com.vitorpamplona.amethyst.ui.components.ZapRaiserRequest
+import com.vitorpamplona.amethyst.ui.components.imageExtensions
+import com.vitorpamplona.amethyst.ui.components.isValidURL
+import com.vitorpamplona.amethyst.ui.components.videoExtensions
+import com.vitorpamplona.amethyst.ui.note.BaseUserPicture
 import com.vitorpamplona.amethyst.ui.note.CancelIcon
 import com.vitorpamplona.amethyst.ui.note.CloseIcon
 import com.vitorpamplona.amethyst.ui.note.NoteCompose
 import com.vitorpamplona.amethyst.ui.note.PollIcon
 import com.vitorpamplona.amethyst.ui.note.RegularPostIcon
+import com.vitorpamplona.amethyst.ui.note.UsernameDisplay
 import com.vitorpamplona.amethyst.ui.screen.loggedIn.AccountViewModel
 import com.vitorpamplona.amethyst.ui.screen.loggedIn.MyTextField
 import com.vitorpamplona.amethyst.ui.screen.loggedIn.TextSpinner
+import com.vitorpamplona.amethyst.ui.screen.loggedIn.TitleExplainer
 import com.vitorpamplona.amethyst.ui.screen.loggedIn.UserLine
 import com.vitorpamplona.amethyst.ui.theme.BitcoinOrange
 import com.vitorpamplona.amethyst.ui.theme.ButtonBorder
+import com.vitorpamplona.amethyst.ui.theme.DoubleHorzSpacer
 import com.vitorpamplona.amethyst.ui.theme.Font14SP
 import com.vitorpamplona.amethyst.ui.theme.QuoteBorder
 import com.vitorpamplona.amethyst.ui.theme.Size10dp
+import com.vitorpamplona.amethyst.ui.theme.Size18Modifier
+import com.vitorpamplona.amethyst.ui.theme.Size55dp
 import com.vitorpamplona.amethyst.ui.theme.Size5dp
 import com.vitorpamplona.amethyst.ui.theme.StdHorzSpacer
 import com.vitorpamplona.amethyst.ui.theme.StdVertSpacer
@@ -111,7 +160,9 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
+import java.lang.Math.round
 
+@OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun NewPostView(
     onClose: () -> Unit,
@@ -136,7 +187,7 @@ fun NewPostView(
     var relayList = account.activeWriteRelays()
 
     LaunchedEffect(Unit) {
-        postViewModel.load(account, baseReplyTo, quote)
+        postViewModel.load(accountViewModel, baseReplyTo, quote)
 
         launch(Dispatchers.IO) {
             postViewModel.imageUploadingError.collect { error ->
@@ -180,9 +231,7 @@ fun NewPostView(
                 TopAppBar(
                     title = {
                         Row(
-                            modifier = Modifier
-                                .fillMaxWidth()
-                                .padding(end = 10.dp),
+                            modifier = Modifier.fillMaxWidth(),
                             horizontalArrangement = Arrangement.SpaceBetween,
                             verticalAlignment = Alignment.CenterVertically
                         ) {
@@ -199,14 +248,15 @@ fun NewPostView(
                                         painter = painterResource(R.drawable.relays),
                                         contentDescription = null,
                                         modifier = Modifier.height(25.dp),
-                                        tint = MaterialTheme.colors.onBackground
+                                        tint = MaterialTheme.colorScheme.onBackground
                                     )
                                 }
                             }
                             PostButton(
                                 onPost = {
-                                    scope.launch(Dispatchers.IO) {
-                                        postViewModel.sendPost(relayList = relayList)
+                                    postViewModel.sendPost(relayList = relayList)
+                                    scope.launch {
+                                        delay(100)
                                         onClose()
                                     }
                                 },
@@ -215,14 +265,20 @@ fun NewPostView(
                         }
                     },
                     navigationIcon = {
-                        Spacer(modifier = StdHorzSpacer)
-                        CloseButton(onPress = {
-                            postViewModel.cancel()
-                            onClose()
-                        })
+                        Row() {
+                            Spacer(modifier = StdHorzSpacer)
+                            CloseButton(onPress = {
+                                postViewModel.cancel()
+                                scope.launch {
+                                    delay(100)
+                                    onClose()
+                                }
+                            })
+                        }
                     },
-                    backgroundColor = MaterialTheme.colors.surface,
-                    elevation = 0.dp
+                    colors = TopAppBarDefaults.topAppBarColors(
+                        containerColor = MaterialTheme.colorScheme.surface
+                    )
                 )
             }
         ) { pad ->
@@ -243,7 +299,6 @@ fun NewPostView(
                 ) {
                     Column(
                         modifier = Modifier
-                            .padding(top = 10.dp)
                             .imePadding()
                             .weight(1f)
                     ) {
@@ -264,7 +319,7 @@ fun NewPostView(
                                             makeItShort = true,
                                             unPackReply = false,
                                             isQuotedNote = true,
-                                            modifier = MaterialTheme.colors.replyModifier,
+                                            modifier = MaterialTheme.colorScheme.replyModifier,
                                             accountViewModel = accountViewModel,
                                             nav = nav
                                         )
@@ -321,9 +376,9 @@ fun NewPostView(
                                 if (postViewModel.wantsForwardZapTo) {
                                     Row(
                                         verticalAlignment = Alignment.CenterVertically,
-                                        modifier = Modifier.padding(vertical = Size5dp, horizontal = Size10dp)
+                                        modifier = Modifier.padding(top = Size5dp, bottom = Size5dp, start = Size10dp)
                                     ) {
-                                        FowardZapTo(postViewModel)
+                                        FowardZapTo(postViewModel, accountViewModel)
                                     }
                                 }
 
@@ -333,8 +388,8 @@ fun NewPostView(
                                         ImageVideoDescription(
                                             url,
                                             account.defaultFileServer,
-                                            onAdd = { description, server, sensitiveContent ->
-                                                postViewModel.upload(url, description, sensitiveContent, server, context, relayList)
+                                            onAdd = { alt, server, sensitiveContent ->
+                                                postViewModel.upload(url, alt, sensitiveContent, server, context, relayList)
                                                 account.changeDefaultFileServer(server)
                                             },
                                             onCancel = {
@@ -368,6 +423,9 @@ fun NewPostView(
                                                 },
                                                 onClose = {
                                                     postViewModel.wantsInvoice = false
+                                                },
+                                                onError = { title, message ->
+                                                    accountViewModel.toast(title, message)
                                                 }
                                             )
                                         }
@@ -400,7 +458,7 @@ fun NewPostView(
                                                         .clip(shape = QuoteBorder)
                                                         .border(
                                                             1.dp,
-                                                            MaterialTheme.colors.subtleBorder,
+                                                            MaterialTheme.colorScheme.subtleBorder,
                                                             QuoteBorder
                                                         )
                                                 )
@@ -410,7 +468,7 @@ fun NewPostView(
                                                 UrlPreview(myUrlPreview, myUrlPreview, accountViewModel)
                                             }
                                         } else if (startsWithNIP19Scheme(myUrlPreview)) {
-                                            val bgColor = MaterialTheme.colors.background
+                                            val bgColor = MaterialTheme.colorScheme.background
                                             val backgroundColor = remember {
                                                 mutableStateOf(bgColor)
                                             }
@@ -457,7 +515,7 @@ fun NewPostView(
                         ) {
                             UploadFromGallery(
                                 isUploading = postViewModel.isUploadingImage,
-                                tint = MaterialTheme.colors.onBackground,
+                                tint = MaterialTheme.colorScheme.onBackground,
                                 modifier = Modifier
                             ) {
                                 postViewModel.selectImage(it)
@@ -521,22 +579,22 @@ private fun PollField(postViewModel: NewPostViewModel) {
             },
             border = BorderStroke(
                 1.dp,
-                MaterialTheme.colors.placeholderText
+                MaterialTheme.colorScheme.placeholderText
             ),
             colors = ButtonDefaults.outlinedButtonColors(
-                contentColor = MaterialTheme.colors.placeholderText
+                containerColor = MaterialTheme.colorScheme.placeholderText
             )
         ) {
             Image(
                 painterResource(id = android.R.drawable.ic_input_add),
                 contentDescription = "Add poll option button",
-                modifier = Modifier.size(18.dp)
+                modifier = Size18Modifier
             )
         }
     }
 }
 
-@OptIn(ExperimentalComposeUiApi::class)
+@OptIn(ExperimentalComposeUiApi::class, ExperimentalMaterial3Api::class)
 @Composable
 private fun MessageField(
     postViewModel: NewPostViewModel
@@ -563,7 +621,7 @@ private fun MessageField(
             .fillMaxWidth()
             .border(
                 width = 1.dp,
-                color = MaterialTheme.colors.surface,
+                color = MaterialTheme.colorScheme.surface,
                 shape = RoundedCornerShape(8.dp)
             )
             .focusRequester(focusRequester)
@@ -575,15 +633,14 @@ private fun MessageField(
         placeholder = {
             Text(
                 text = stringResource(R.string.what_s_on_your_mind),
-                color = MaterialTheme.colors.placeholderText
+                color = MaterialTheme.colorScheme.placeholderText
             )
         },
-        colors = TextFieldDefaults
-            .outlinedTextFieldColors(
-                unfocusedBorderColor = Color.Transparent,
-                focusedBorderColor = Color.Transparent
-            ),
-        visualTransformation = UrlUserTagTransformation(MaterialTheme.colors.primary),
+        colors = OutlinedTextFieldDefaults.colors(
+            focusedBorderColor = Color.Transparent,
+            unfocusedBorderColor = Color.Transparent
+        ),
+        visualTransformation = UrlUserTagTransformation(MaterialTheme.colorScheme.primary),
         textStyle = LocalTextStyle.current.copy(textDirection = TextDirection.Content)
     )
 }
@@ -634,7 +691,7 @@ fun ContentSensitivityExplainer(postViewModel: NewPostViewModel) {
 
         Text(
             text = stringResource(R.string.add_sensitive_content_explainer),
-            color = MaterialTheme.colors.placeholderText,
+            color = MaterialTheme.colorScheme.placeholderText,
             modifier = Modifier.padding(vertical = 10.dp)
         )
     }
@@ -664,18 +721,16 @@ fun SendDirectMessageTo(postViewModel: NewPostViewModel) {
                 placeholder = {
                     Text(
                         text = stringResource(R.string.messages_new_message_to_caption),
-                        color = MaterialTheme.colors.placeholderText
+                        color = MaterialTheme.colorScheme.placeholderText
                     )
                 },
                 visualTransformation = UrlUserTagTransformation(
-                    MaterialTheme.colors.primary
+                    MaterialTheme.colorScheme.primary
                 ),
-                colors = TextFieldDefaults
-                    .outlinedTextFieldColors(
-                        unfocusedBorderColor = Color.Transparent,
-                        focusedBorderColor = Color.Transparent
-                    ),
-                textStyle = LocalTextStyle.current.copy(textDirection = TextDirection.Content)
+                colors = OutlinedTextFieldDefaults.colors(
+                    unfocusedBorderColor = Color.Transparent,
+                    focusedBorderColor = Color.Transparent
+                )
             )
         }
 
@@ -701,18 +756,16 @@ fun SendDirectMessageTo(postViewModel: NewPostViewModel) {
                 placeholder = {
                     Text(
                         text = stringResource(R.string.messages_new_message_subject_caption),
-                        color = MaterialTheme.colors.placeholderText
+                        color = MaterialTheme.colorScheme.placeholderText
                     )
                 },
                 visualTransformation = UrlUserTagTransformation(
-                    MaterialTheme.colors.primary
+                    MaterialTheme.colorScheme.primary
                 ),
-                colors = TextFieldDefaults
-                    .outlinedTextFieldColors(
-                        unfocusedBorderColor = Color.Transparent,
-                        focusedBorderColor = Color.Transparent
-                    ),
-                textStyle = LocalTextStyle.current.copy(textDirection = TextDirection.Content)
+                colors = OutlinedTextFieldDefaults.colors(
+                    unfocusedBorderColor = Color.Transparent,
+                    focusedBorderColor = Color.Transparent
+                )
             )
         }
 
@@ -721,7 +774,7 @@ fun SendDirectMessageTo(postViewModel: NewPostViewModel) {
 }
 
 @Composable
-fun FowardZapTo(postViewModel: NewPostViewModel) {
+fun FowardZapTo(postViewModel: NewPostViewModel, accountViewModel: AccountViewModel) {
     Column(
         modifier = Modifier.fillMaxWidth()
     ) {
@@ -755,7 +808,7 @@ fun FowardZapTo(postViewModel: NewPostViewModel) {
             }
 
             Text(
-                text = stringResource(R.string.zap_forward_title),
+                text = stringResource(R.string.zap_split_title),
                 fontSize = 20.sp,
                 fontWeight = FontWeight.W500,
                 modifier = Modifier.padding(start = 10.dp)
@@ -765,28 +818,58 @@ fun FowardZapTo(postViewModel: NewPostViewModel) {
         Divider()
 
         Text(
-            text = stringResource(R.string.zap_forward_explainer),
-            color = MaterialTheme.colors.placeholderText,
+            text = stringResource(R.string.zap_split_explainer),
+            color = MaterialTheme.colorScheme.placeholderText,
             modifier = Modifier.padding(vertical = 10.dp)
         )
 
+        postViewModel.forwardZapTo.items.forEachIndexed { index, splitItem ->
+            Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.padding(vertical = Size10dp)) {
+                BaseUserPicture(splitItem.key, Size55dp, accountViewModel = accountViewModel)
+
+                Spacer(modifier = DoubleHorzSpacer)
+
+                Column(modifier = Modifier.weight(1f)) {
+                    UsernameDisplay(splitItem.key, showPlayButton = false)
+                    Text(
+                        text = String.format("%.0f%%", splitItem.percentage * 100),
+                        maxLines = 1,
+                        overflow = TextOverflow.Ellipsis,
+                        fontWeight = FontWeight.Bold,
+                        fontSize = 18.sp
+                    )
+                }
+
+                Spacer(modifier = DoubleHorzSpacer)
+
+                Slider(
+                    value = splitItem.percentage,
+                    onValueChange = { sliderValue ->
+                        val rounded = (round(sliderValue * 20)) / 20.0f
+                        postViewModel.updateZapPercentage(index, rounded)
+                    },
+                    modifier = Modifier
+                        .weight(1.5f)
+                )
+            }
+        }
+
         OutlinedTextField(
             value = postViewModel.forwardZapToEditting,
             onValueChange = {
                 postViewModel.updateZapForwardTo(it)
             },
-
-            label = { Text(text = stringResource(R.string.zap_forward_lnAddress)) },
+            label = { Text(text = stringResource(R.string.zap_split_serarch_and_add_user)) },
             modifier = Modifier.fillMaxWidth(),
             placeholder = {
                 Text(
-                    text = stringResource(R.string.zap_forward_lnAddress),
-                    color = MaterialTheme.colors.placeholderText
+                    text = stringResource(R.string.zap_split_serarch_and_add_user_placeholder),
+                    color = MaterialTheme.colorScheme.placeholderText
                 )
             },
             singleLine = true,
             visualTransformation = UrlUserTagTransformation(
-                MaterialTheme.colors.primary
+                MaterialTheme.colorScheme.primary
             ),
             textStyle = LocalTextStyle.current.copy(textDirection = TextDirection.Content)
         )
@@ -834,7 +917,7 @@ fun LocationAsHash(postViewModel: NewPostViewModel) {
                         imageVector = Icons.Default.LocationOn,
                         null,
                         modifier = Modifier.size(20.dp),
-                        tint = MaterialTheme.colors.primary
+                        tint = MaterialTheme.colorScheme.primary
                     )
                 }
 
@@ -854,7 +937,7 @@ fun LocationAsHash(postViewModel: NewPostViewModel) {
 
             Text(
                 text = stringResource(R.string.geohash_explainer),
-                color = MaterialTheme.colors.placeholderText,
+                color = MaterialTheme.colorScheme.placeholderText,
                 modifier = Modifier.padding(vertical = 10.dp)
             )
         }
@@ -915,7 +998,7 @@ fun Notifying(baseMentions: ImmutableList<User>?, onClick: (User) -> Unit) {
             Text(
                 stringResource(R.string.reply_notify),
                 fontWeight = FontWeight.Bold,
-                color = MaterialTheme.colors.placeholderText,
+                color = MaterialTheme.colorScheme.placeholderText,
                 modifier = Modifier.align(CenterVertically)
             )
 
@@ -929,7 +1012,7 @@ fun Notifying(baseMentions: ImmutableList<User>?, onClick: (User) -> Unit) {
                     Button(
                         shape = ButtonBorder,
                         colors = ButtonDefaults.buttonColors(
-                            backgroundColor = MaterialTheme.colors.mediumImportanceLink
+                            containerColor = MaterialTheme.colorScheme.mediumImportanceLink
                         ),
                         onClick = {
                             onClick(myUser)
@@ -988,7 +1071,7 @@ private fun AddZapraiserButton(
                     modifier = Modifier
                         .size(20.dp)
                         .align(Alignment.TopStart),
-                    tint = MaterialTheme.colors.onBackground
+                    tint = MaterialTheme.colorScheme.onBackground
                 )
                 Icon(
                     imageVector = Icons.Default.Bolt,
@@ -996,7 +1079,7 @@ private fun AddZapraiserButton(
                     modifier = Modifier
                         .size(13.dp)
                         .align(Alignment.BottomEnd),
-                    tint = MaterialTheme.colors.onBackground
+                    tint = MaterialTheme.colorScheme.onBackground
                 )
             } else {
                 Icon(
@@ -1032,14 +1115,14 @@ fun AddGeoHash(postViewModel: NewPostViewModel, onClick: () -> Unit) {
                 imageVector = Icons.Default.LocationOff,
                 null,
                 modifier = Modifier.size(20.dp),
-                tint = MaterialTheme.colors.onBackground
+                tint = MaterialTheme.colorScheme.onBackground
             )
         } else {
             Icon(
                 imageVector = Icons.Default.LocationOn,
                 null,
                 modifier = Modifier.size(20.dp),
-                tint = MaterialTheme.colors.primary
+                tint = MaterialTheme.colorScheme.primary
             )
         }
     }
@@ -1060,7 +1143,7 @@ private fun AddLnInvoiceButton(
                 imageVector = Icons.Default.CurrencyBitcoin,
                 null,
                 modifier = Modifier.size(20.dp),
-                tint = MaterialTheme.colors.onBackground
+                tint = MaterialTheme.colorScheme.onBackground
             )
         } else {
             Icon(
@@ -1095,7 +1178,7 @@ private fun ForwardZapTo(
                     modifier = Modifier
                         .size(20.dp)
                         .align(Alignment.CenterStart),
-                    tint = MaterialTheme.colors.onBackground
+                    tint = MaterialTheme.colorScheme.onBackground
                 )
                 Icon(
                     imageVector = Icons.Default.ArrowForwardIos,
@@ -1103,7 +1186,7 @@ private fun ForwardZapTo(
                     modifier = Modifier
                         .size(13.dp)
                         .align(Alignment.CenterEnd),
-                    tint = MaterialTheme.colors.onBackground
+                    tint = MaterialTheme.colorScheme.onBackground
                 )
             } else {
                 Icon(
@@ -1149,7 +1232,7 @@ private fun MarkAsSensitive(
                     modifier = Modifier
                         .size(18.dp)
                         .align(Alignment.BottomStart),
-                    tint = MaterialTheme.colors.onBackground
+                    tint = MaterialTheme.colorScheme.onBackground
                 )
                 Icon(
                     imageVector = Icons.Rounded.Warning,
@@ -1157,7 +1240,7 @@ private fun MarkAsSensitive(
                     modifier = Modifier
                         .size(10.dp)
                         .align(Alignment.TopEnd),
-                    tint = MaterialTheme.colors.onBackground
+                    tint = MaterialTheme.colorScheme.onBackground
                 )
             } else {
                 Icon(
@@ -1183,15 +1266,9 @@ private fun MarkAsSensitive(
 
 @Composable
 fun CloseButton(onPress: () -> Unit) {
-    Button(
-        onClick = {
-            onPress()
-        },
-        shape = ButtonBorder,
-        colors = ButtonDefaults
-            .buttonColors(
-                backgroundColor = Color.Gray
-            )
+    OutlinedButton(
+        onClick = onPress,
+        contentPadding = PaddingValues(horizontal = Size5dp)
     ) {
         CloseIcon()
     }
@@ -1201,17 +1278,11 @@ fun CloseButton(onPress: () -> Unit) {
 fun PostButton(onPost: () -> Unit = {}, isActive: Boolean, modifier: Modifier = Modifier) {
     Button(
         modifier = modifier,
+        enabled = isActive,
         onClick = {
-            if (isActive) {
-                onPost()
-            }
+            onPost()
         },
-        shape = ButtonBorder,
-        colors = ButtonDefaults
-            .buttonColors(
-                backgroundColor = if (isActive) MaterialTheme.colors.primary else Color.Gray
-            ),
-        contentPadding = PaddingValues(0.dp)
+        shape = ButtonBorder
     ) {
         Text(text = stringResource(R.string.post), color = Color.White)
     }
@@ -1220,19 +1291,11 @@ fun PostButton(onPost: () -> Unit = {}, isActive: Boolean, modifier: Modifier =
 @Composable
 fun SaveButton(onPost: () -> Unit = {}, isActive: Boolean, modifier: Modifier = Modifier) {
     Button(
+        enabled = isActive,
         modifier = modifier,
-        onClick = {
-            if (isActive) {
-                onPost()
-            }
-        },
-        shape = ButtonBorder,
-        colors = ButtonDefaults
-            .buttonColors(
-                backgroundColor = if (isActive) MaterialTheme.colors.primary else Color.Gray
-            )
+        onClick = onPost
     ) {
-        Text(text = stringResource(R.string.save), color = Color.White)
+        Text(text = stringResource(R.string.save))
     }
 }
 
@@ -1246,10 +1309,9 @@ fun CreateButton(onPost: () -> Unit = {}, isActive: Boolean, modifier: Modifier
             }
         },
         shape = ButtonBorder,
-        colors = ButtonDefaults
-            .buttonColors(
-                backgroundColor = if (isActive) MaterialTheme.colors.primary else Color.Gray
-            )
+        colors = ButtonDefaults.buttonColors(
+            containerColor = if (isActive) MaterialTheme.colorScheme.primary else Color.Gray
+        )
     ) {
         Text(text = stringResource(R.string.create), color = Color.White)
     }
@@ -1284,8 +1346,7 @@ fun ImageVideoDescription(
         Triple(ServersAvailable.NIP95, stringResource(id = R.string.upload_server_relays_nip95), stringResource(id = R.string.upload_server_relays_nip95_explainer))
     )
 
-    val fileServerOptions = remember { fileServers.map { it.second }.toImmutableList() }
-    val fileServerExplainers = remember { fileServers.map { it.third }.toImmutableList() }
+    val fileServerOptions = remember { fileServers.map { TitleExplainer(it.second, it.third) }.toImmutableList() }
 
     var selectedServer by remember { mutableStateOf(defaultServer) }
     var message by remember { mutableStateOf("") }
@@ -1298,7 +1359,7 @@ fun ImageVideoDescription(
             .clip(shape = QuoteBorder)
             .border(
                 1.dp,
-                MaterialTheme.colors.subtleBorder,
+                MaterialTheme.colorScheme.subtleBorder,
                 QuoteBorder
             )
     ) {
@@ -1399,7 +1460,6 @@ fun ImageVideoDescription(
                     label = stringResource(id = R.string.file_server),
                     placeholder = fileServers.filter { it.first == defaultServer }.firstOrNull()?.second ?: fileServers[0].second,
                     options = fileServerOptions,
-                    explainers = fileServerExplainers,
                     onSelect = {
                         selectedServer = fileServers[it].first
                     },
@@ -1440,7 +1500,7 @@ fun ImageVideoDescription(
                         placeholder = {
                             Text(
                                 text = stringResource(R.string.content_description_example),
-                                color = MaterialTheme.colors.placeholderText
+                                color = MaterialTheme.colorScheme.placeholderText
                             )
                         },
                         keyboardOptions = KeyboardOptions.Default.copy(
@@ -1459,7 +1519,7 @@ fun ImageVideoDescription(
                 },
                 shape = QuoteBorder,
                 colors = ButtonDefaults.buttonColors(
-                    backgroundColor = MaterialTheme.colors.primary
+                    containerColor = MaterialTheme.colorScheme.primary
                 )
             ) {
                 Text(text = stringResource(R.string.add_content), color = Color.White, fontSize = 20.sp)
@@ -1493,21 +1553,17 @@ fun SettingSwitchItem(
             modifier = Modifier.weight(1.0f),
             verticalArrangement = Arrangement.spacedBy(3.dp)
         ) {
-            val contentAlpha = if (enabled) ContentAlpha.high else ContentAlpha.disabled
-
             Text(
                 text = stringResource(id = title),
                 maxLines = 1,
-                overflow = TextOverflow.Ellipsis,
-                modifier = Modifier.alpha(contentAlpha)
+                overflow = TextOverflow.Ellipsis
             )
             Text(
                 text = stringResource(id = description),
-                style = MaterialTheme.typography.caption,
+                style = MaterialTheme.typography.bodySmall,
                 color = Color.Gray,
                 maxLines = 2,
-                overflow = TextOverflow.Ellipsis,
-                modifier = Modifier.alpha(contentAlpha)
+                overflow = TextOverflow.Ellipsis
             )
         }
 

app/src/main/java/com/vitorpamplona/amethyst/ui/actions/NewPostViewModel.kt

@@ -14,14 +14,20 @@ import androidx.compose.ui.text.input.TextFieldValue
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.fonfon.kgeohash.toGeoHash
-import com.vitorpamplona.amethyst.model.*
+import com.vitorpamplona.amethyst.model.Account
+import com.vitorpamplona.amethyst.model.LocalCache
+import com.vitorpamplona.amethyst.model.Note
+import com.vitorpamplona.amethyst.model.ServersAvailable
+import com.vitorpamplona.amethyst.model.User
 import com.vitorpamplona.amethyst.service.FileHeader
 import com.vitorpamplona.amethyst.service.LocationUtil
 import com.vitorpamplona.amethyst.service.NostrSearchEventOrUserDataSource
 import com.vitorpamplona.amethyst.service.noProtocolUrlValidator
 import com.vitorpamplona.amethyst.service.relays.Relay
 import com.vitorpamplona.amethyst.ui.components.MediaCompressor
+import com.vitorpamplona.amethyst.ui.components.Split
 import com.vitorpamplona.amethyst.ui.components.isValidURL
+import com.vitorpamplona.amethyst.ui.screen.loggedIn.AccountViewModel
 import com.vitorpamplona.quartz.encoders.HexKey
 import com.vitorpamplona.quartz.events.AddressableEvent
 import com.vitorpamplona.quartz.events.BaseTextNoteEvent
@@ -29,7 +35,9 @@ import com.vitorpamplona.quartz.events.ChatMessageEvent
 import com.vitorpamplona.quartz.events.CommunityDefinitionEvent
 import com.vitorpamplona.quartz.events.PrivateDmEvent
 import com.vitorpamplona.quartz.events.TextNoteEvent
+import com.vitorpamplona.quartz.events.ZapSplitSetup
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.mapLatest
@@ -43,6 +51,7 @@ enum class UserSuggestionAnchor {
 
 @Stable
 open class NewPostViewModel() : ViewModel() {
+    var accountViewModel: AccountViewModel? = null
     var account: Account? = null
     var requiresNIP24: Boolean = false
 
@@ -54,7 +63,7 @@ open class NewPostViewModel() : ViewModel() {
     var message by mutableStateOf(TextFieldValue(""))
     var urlPreview by mutableStateOf<String?>(null)
     var isUploadingImage by mutableStateOf(false)
-    val imageUploadingError = MutableSharedFlow<String?>()
+    val imageUploadingError = MutableSharedFlow<String?>(0, 3, onBufferOverflow = BufferOverflow.DROP_OLDEST)
 
     var userSuggestions by mutableStateOf<List<User>>(emptyList())
     var userSuggestionAnchor: TextRange? = null
@@ -88,9 +97,13 @@ open class NewPostViewModel() : ViewModel() {
     var canAddInvoice by mutableStateOf(false)
     var wantsInvoice by mutableStateOf(false)
 
+    data class ForwardZapSetup(val user: User) {
+        var percentage by mutableStateOf(100)
+    }
+
     // Forward Zap to
     var wantsForwardZapTo by mutableStateOf(false)
-    var forwardZapTo by mutableStateOf<User?>(null)
+    var forwardZapTo by mutableStateOf<Split<User>>(Split())
     var forwardZapToEditting by mutableStateOf(TextFieldValue(""))
 
     // NSFW, Sensitive
@@ -109,7 +122,7 @@ open class NewPostViewModel() : ViewModel() {
     // NIP24 Wrapped DMs / Group messages
     var nip24 by mutableStateOf(false)
 
-    open fun load(account: Account, replyingTo: Note?, quote: Note?) {
+    open fun load(accountViewModel: AccountViewModel, replyingTo: Note?, quote: Note?) {
         originalNote = replyingTo
         replyingTo?.let { replyNote ->
             if (replyNote.event is BaseTextNoteEvent) {
@@ -141,8 +154,8 @@ open class NewPostViewModel() : ViewModel() {
             urlPreview = findUrlInMessage()
         }
 
-        canAddInvoice = account.userProfile().info?.lnAddress() != null
-        canAddZapRaiser = account.userProfile().info?.lnAddress() != null
+        canAddInvoice = accountViewModel.userProfile().info?.lnAddress() != null
+        canAddZapRaiser = accountViewModel.userProfile().info?.lnAddress() != null
         canUsePoll = originalNote?.event !is PrivateDmEvent && originalNote?.channelHex() == null
         contentToAddUrl = null
 
@@ -151,25 +164,40 @@ open class NewPostViewModel() : ViewModel() {
         wantsToAddGeoHash = false
         wantsZapraiser = false
         zapRaiserAmount = null
-        forwardZapTo = null
+        forwardZapTo = Split()
         forwardZapToEditting = TextFieldValue("")
 
-        this.account = account
+        this.accountViewModel = accountViewModel
+        this.account = accountViewModel.account
     }
 
     fun sendPost(relayList: List<Relay>? = null) {
-        val tagger = NewMessageTagger(message.text, mentions, replyTos, originalNote?.channelHex())
+        viewModelScope.launch(Dispatchers.IO) {
+            innerSendPost(relayList)
+        }
+    }
+
+    suspend fun innerSendPost(relayList: List<Relay>? = null) {
+        if (accountViewModel == null) {
+            cancel()
+            return
+        }
+
+        val tagger = NewMessageTagger(message.text, mentions, replyTos, originalNote?.channelHex(), accountViewModel!!)
         tagger.run()
 
-        val toUsersTagger = NewMessageTagger(toUsers.text, null, null, null)
+        val toUsersTagger = NewMessageTagger(toUsers.text, null, null, null, accountViewModel!!)
         toUsersTagger.run()
         val dmUsers = toUsersTagger.mentions
 
         val zapReceiver = if (wantsForwardZapTo) {
-            if (forwardZapTo != null) {
-                forwardZapTo?.info?.lud16 ?: forwardZapTo?.info?.lud06
-            } else {
-                forwardZapToEditting.text
+            forwardZapTo?.items?.map {
+                ZapSplitSetup(
+                    lnAddressOrPubKeyHex = it.key.pubkeyHex,
+                    relay = it.key.relaysBeingUsed.keys.firstOrNull(),
+                    weight = it.percentage.toDouble(),
+                    isLnAddress = false
+                )
             }
         } else {
             null
@@ -276,7 +304,7 @@ open class NewPostViewModel() : ViewModel() {
         cancel()
     }
 
-    fun upload(galleryUri: Uri, description: String, sensitiveContent: Boolean, server: ServersAvailable, context: Context, relayList: List<Relay>? = null) {
+    fun upload(galleryUri: Uri, alt: String, sensitiveContent: Boolean, server: ServersAvailable, context: Context, relayList: List<Relay>? = null) {
         isUploadingImage = true
         contentToAddUrl = null
 
@@ -291,7 +319,7 @@ open class NewPostViewModel() : ViewModel() {
                 onReady = { fileUri, contentType, size ->
                     if (server == ServersAvailable.NIP95) {
                         contentResolver.openInputStream(fileUri)?.use {
-                            createNIP95Record(it.readBytes(), contentType, description, sensitiveContent, relayList = relayList)
+                            createNIP95Record(it.readBytes(), contentType, alt, sensitiveContent, relayList = relayList)
                         }
                     } else {
                         ImageUploader.uploadImage(
@@ -302,7 +330,7 @@ open class NewPostViewModel() : ViewModel() {
                             contentResolver = contentResolver,
                             onSuccess = { imageUrl, mimeType ->
                                 if (isNIP94Server(server)) {
-                                    createNIP94Record(imageUrl, mimeType, description, sensitiveContent)
+                                    createNIP94Record(imageUrl, mimeType, alt, sensitiveContent)
                                 } else {
                                     isUploadingImage = false
                                     message = TextFieldValue(message.text + "\n\n" + imageUrl)
@@ -355,7 +383,7 @@ open class NewPostViewModel() : ViewModel() {
         wantsForwardZapTo = false
         wantsToMarkAsSensitive = false
         wantsToAddGeoHash = false
-        forwardZapTo = null
+        forwardZapTo = Split()
         forwardZapToEditting = TextFieldValue("")
 
         userSuggestions = emptyList()
@@ -427,10 +455,10 @@ open class NewPostViewModel() : ViewModel() {
     open fun updateZapForwardTo(it: TextFieldValue) {
         forwardZapToEditting = it
         if (it.selection.collapsed) {
-            val lastWord = it.text.substring(0, it.selection.end).substringAfterLast("\n").substringAfterLast(" ")
+            val lastWord = it.text
             userSuggestionAnchor = it.selection
             userSuggestionsMainMessage = UserSuggestionAnchor.FORWARD_ZAPS
-            if (lastWord.startsWith("@") && lastWord.length > 2) {
+            if (lastWord.length > 2) {
                 NostrSearchEventOrUserDataSource.search(lastWord.removePrefix("@"))
                 viewModelScope.launch(Dispatchers.IO) {
                     userSuggestions = LocalCache.findUsersStartingWith(lastWord.removePrefix("@"))
@@ -460,6 +488,9 @@ open class NewPostViewModel() : ViewModel() {
                     TextRange(lastWordStart + wordToInsert.length, lastWordStart + wordToInsert.length)
                 )
             } else if (userSuggestionsMainMessage == UserSuggestionAnchor.FORWARD_ZAPS) {
+                forwardZapTo?.addItem(item)
+                forwardZapToEditting = TextFieldValue("")
+                /*
                 val lastWord = forwardZapToEditting.text.substring(0, it.end).substringAfterLast("\n").substringAfterLast(" ")
                 val lastWordStart = it.end - lastWord.length
                 val wordToInsert = "@${item.pubkeyNpub()}"
@@ -468,7 +499,7 @@ open class NewPostViewModel() : ViewModel() {
                 forwardZapToEditting = TextFieldValue(
                     forwardZapToEditting.text.replaceRange(lastWordStart, it.end, wordToInsert),
                     TextRange(lastWordStart + wordToInsert.length, lastWordStart + wordToInsert.length)
-                )
+                )*/
             } else if (userSuggestionsMainMessage == UserSuggestionAnchor.TO_USERS) {
                 val lastWord = toUsers.text.substring(0, it.end).substringAfterLast("\n").substringAfterLast(" ")
                 val lastWordStart = it.end - lastWord.length
@@ -511,13 +542,13 @@ open class NewPostViewModel() : ViewModel() {
         }
     }
 
-    fun createNIP94Record(imageUrl: String, mimeType: String?, description: String, sensitiveContent: Boolean, relayList: List<Relay>? = null) {
+    fun createNIP94Record(imageUrl: String, mimeType: String?, alt: String, sensitiveContent: Boolean, relayList: List<Relay>? = null) {
         viewModelScope.launch(Dispatchers.IO) {
             // Images don't seem to be ready immediately after upload
             FileHeader.prepare(
                 imageUrl,
                 mimeType,
-                description,
+                alt,
                 sensitiveContent,
                 onReady = {
                     val note = account?.sendHeader(it, relayList = relayList)
@@ -542,13 +573,13 @@ open class NewPostViewModel() : ViewModel() {
         }
     }
 
-    fun createNIP95Record(bytes: ByteArray, mimeType: String?, description: String, sensitiveContent: Boolean, relayList: List<Relay>? = null) {
+    fun createNIP95Record(bytes: ByteArray, mimeType: String?, alt: String, sensitiveContent: Boolean, relayList: List<Relay>? = null) {
         viewModelScope.launch(Dispatchers.IO) {
             FileHeader.prepare(
                 bytes,
                 "",
                 mimeType,
-                description,
+                alt,
                 sensitiveContent,
                 onReady = {
                     val nip95 = account?.createNip95(bytes, headerInfo = it)
@@ -656,6 +687,10 @@ open class NewPostViewModel() : ViewModel() {
             isValidvalueMaximum.value = true
         }
     }
+
+    fun updateZapPercentage(index: Int, sliderValue: Float) {
+        forwardZapTo?.updatePercentage(index, sliderValue)
+    }
 }
 
 enum class GeohashPrecision(val digits: Int) {

app/src/main/java/com/vitorpamplona/amethyst/ui/actions/NewRelayListView.kt

@@ -14,16 +14,6 @@ import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.itemsIndexed
-import androidx.compose.material.Button
-import androidx.compose.material.ButtonDefaults
-import androidx.compose.material.Divider
-import androidx.compose.material.Icon
-import androidx.compose.material.IconButton
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.OutlinedTextField
-import androidx.compose.material.Scaffold
-import androidx.compose.material.Text
-import androidx.compose.material.TopAppBar
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Cancel
 import androidx.compose.material.icons.filled.DeleteSweep
@@ -34,6 +24,18 @@ import androidx.compose.material.icons.filled.Public
 import androidx.compose.material.icons.filled.Search
 import androidx.compose.material.icons.filled.SyncProblem
 import androidx.compose.material.icons.filled.Upload
+import androidx.compose.material3.Button
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.Divider
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.collectAsState
@@ -56,9 +58,11 @@ import androidx.compose.ui.window.Dialog
 import androidx.compose.ui.window.DialogProperties
 import androidx.lifecycle.viewmodel.compose.viewModel
 import com.vitorpamplona.amethyst.R
+import com.vitorpamplona.amethyst.model.ConnectivityType
 import com.vitorpamplona.amethyst.model.RelayBriefInfo
 import com.vitorpamplona.amethyst.model.RelaySetupInfo
 import com.vitorpamplona.amethyst.service.Nip11Retriever
+import com.vitorpamplona.amethyst.service.connectivitystatus.ConnectivityStatus
 import com.vitorpamplona.amethyst.service.relays.Constants
 import com.vitorpamplona.amethyst.service.relays.Constants.defaultRelays
 import com.vitorpamplona.amethyst.service.relays.FeedType
@@ -81,6 +85,7 @@ import com.vitorpamplona.amethyst.ui.theme.warningColor
 import kotlinx.coroutines.launch
 import java.lang.Math.round
 
+@OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun NewRelayListView(onClose: () -> Unit, accountViewModel: AccountViewModel, relayToAdd: String = "", nav: (String) -> Unit) {
     val postViewModel: NewRelayListViewModel = viewModel()
@@ -135,8 +140,9 @@ fun NewRelayListView(onClose: () -> Unit, accountViewModel: AccountViewModel, re
                             onClose()
                         })
                     },
-                    backgroundColor = MaterialTheme.colors.surface,
-                    elevation = 0.dp
+                    colors = TopAppBarDefaults.topAppBarColors(
+                        containerColor = MaterialTheme.colorScheme.surface
+                    )
                 )
             }
         ) { pad ->
@@ -210,7 +216,7 @@ fun ServerConfigHeader() {
                         maxLines = 1,
                         fontSize = Font14SP,
                         modifier = Modifier.weight(1.2f),
-                        color = MaterialTheme.colors.placeholderText
+                        color = MaterialTheme.colorScheme.placeholderText
                     )
 
                     Spacer(modifier = Modifier.size(5.dp))
@@ -220,7 +226,7 @@ fun ServerConfigHeader() {
                         maxLines = 1,
                         fontSize = Font14SP,
                         modifier = Modifier.weight(1.2f),
-                        color = MaterialTheme.colors.placeholderText
+                        color = MaterialTheme.colorScheme.placeholderText
                     )
 
                     Spacer(modifier = Modifier.size(5.dp))
@@ -230,7 +236,7 @@ fun ServerConfigHeader() {
                         maxLines = 1,
                         fontSize = Font14SP,
                         modifier = Modifier.weight(1f),
-                        color = MaterialTheme.colors.placeholderText
+                        color = MaterialTheme.colorScheme.placeholderText
                     )
 
                     Spacer(modifier = Modifier.size(5.dp))
@@ -240,7 +246,7 @@ fun ServerConfigHeader() {
                         maxLines = 1,
                         fontSize = Font14SP,
                         modifier = Modifier.weight(1f),
-                        color = MaterialTheme.colors.placeholderText
+                        color = MaterialTheme.colorScheme.placeholderText
                     )
 
                     Spacer(modifier = Modifier.size(2.dp))
@@ -258,6 +264,7 @@ fun ServerConfigHeader() {
 @Composable
 fun ServerConfigPreview() {
     ServerConfigClickableLine(
+        loadProfilePicture = true,
         item = RelaySetupInfo(
             url = "nostr.mom",
             read = true,
@@ -310,7 +317,16 @@ fun ServerConfig(
         )
     }
 
+    val automaticallyShowProfilePicture = remember {
+        when (accountViewModel.account.settings.automaticallyShowProfilePictures) {
+            ConnectivityType.WIFI_ONLY -> !ConnectivityStatus.isOnMobileData.value
+            ConnectivityType.NEVER -> false
+            ConnectivityType.ALWAYS -> true
+        }
+    }
+
     ServerConfigClickableLine(
+        loadProfilePicture = automaticallyShowProfilePicture,
         item = item,
         onToggleDownload = onToggleDownload,
         onToggleUpload = onToggleUpload,
@@ -334,15 +350,10 @@ fun ServerConfig(
                         Nip11Retriever.ErrorCode.FAIL_WITH_HTTP_STATUS -> context.getString(R.string.relay_information_document_error_assemble_url, url, exceptionMessage)
                     }
 
-                    scope.launch {
-                        Toast
-                            .makeText(
-                                context,
-                                msg,
-                                Toast.LENGTH_SHORT
-                            )
-                            .show()
-                    }
+                    accountViewModel.toast(
+                        context.getString(R.string.unable_to_download_relay_document),
+                        msg
+                    )
                 }
             )
         }
@@ -351,6 +362,7 @@ fun ServerConfig(
 
 @Composable
 fun ServerConfigClickableLine(
+    loadProfilePicture: Boolean,
     item: RelaySetupInfo,
     onToggleDownload: (RelaySetupInfo) -> Unit,
     onToggleUpload: (RelaySetupInfo) -> Unit,
@@ -368,7 +380,7 @@ fun ServerConfigClickableLine(
             modifier = Modifier.padding(vertical = 5.dp)
         ) {
             Column(Modifier.clickable(onClick = onClick)) {
-                RenderRelayIcon(iconUrl = item.briefInfo.favIcon, Size55dp)
+                RenderRelayIcon(iconUrl = item.briefInfo.favIcon, loadProfilePicture, Size55dp)
             }
 
             Spacer(modifier = HalfHorzPadding)
@@ -441,9 +453,9 @@ private fun RenderStatusRow(
                 }
             ),
         tint = if (item.read) {
-            MaterialTheme.colors.allGoodColor
+            MaterialTheme.colorScheme.allGoodColor
         } else {
-            MaterialTheme.colors.onSurface.copy(
+            MaterialTheme.colorScheme.onSurface.copy(
                 alpha = 0.32f
             )
         }
@@ -454,7 +466,7 @@ private fun RenderStatusRow(
         maxLines = 1,
         fontSize = 12.sp,
         modifier = modifier,
-        color = MaterialTheme.colors.placeholderText
+        color = MaterialTheme.colorScheme.placeholderText
     )
 
     Icon(
@@ -477,9 +489,9 @@ private fun RenderStatusRow(
                 }
             ),
         tint = if (item.write) {
-            MaterialTheme.colors.allGoodColor
+            MaterialTheme.colorScheme.allGoodColor
         } else {
-            MaterialTheme.colors.onSurface.copy(
+            MaterialTheme.colorScheme.onSurface.copy(
                 alpha = 0.32f
             )
         }
@@ -490,7 +502,7 @@ private fun RenderStatusRow(
         maxLines = 1,
         fontSize = 12.sp,
         modifier = modifier,
-        color = MaterialTheme.colors.placeholderText
+        color = MaterialTheme.colorScheme.placeholderText
     )
 
     Icon(
@@ -512,7 +524,7 @@ private fun RenderStatusRow(
                     }
                 }
             ),
-        tint = if (item.errorCount > 0) MaterialTheme.colors.warningColor else MaterialTheme.colors.allGoodColor
+        tint = if (item.errorCount > 0) MaterialTheme.colorScheme.warningColor else MaterialTheme.colorScheme.allGoodColor
     )
 
     Text(
@@ -520,7 +532,7 @@ private fun RenderStatusRow(
         maxLines = 1,
         fontSize = 12.sp,
         modifier = modifier,
-        color = MaterialTheme.colors.placeholderText
+        color = MaterialTheme.colorScheme.placeholderText
     )
 
     Icon(
@@ -542,7 +554,7 @@ private fun RenderStatusRow(
                     }
                 }
             ),
-        tint = if (item.spamCount > 0) MaterialTheme.colors.warningColor else MaterialTheme.colors.allGoodColor
+        tint = if (item.spamCount > 0) MaterialTheme.colorScheme.warningColor else MaterialTheme.colorScheme.allGoodColor
     )
 
     Text(
@@ -550,7 +562,7 @@ private fun RenderStatusRow(
         maxLines = 1,
         fontSize = 12.sp,
         modifier = modifier,
-        color = MaterialTheme.colors.placeholderText
+        color = MaterialTheme.colorScheme.placeholderText
     )
 }
 
@@ -571,7 +583,7 @@ private fun RenderActiveToggles(
         text = stringResource(id = R.string.active_for),
         maxLines = 1,
         overflow = TextOverflow.Ellipsis,
-        color = MaterialTheme.colors.placeholderText,
+        color = MaterialTheme.colorScheme.placeholderText,
         modifier = Modifier.padding(start = 2.dp, end = 5.dp),
         fontSize = 14.sp
     )
@@ -601,9 +613,9 @@ private fun RenderActiveToggles(
                     }
                 ),
             tint = if (item.feedTypes.contains(FeedType.FOLLOWS)) {
-                MaterialTheme.colors.allGoodColor
+                MaterialTheme.colorScheme.allGoodColor
             } else {
-                MaterialTheme.colors.onSurface.copy(
+                MaterialTheme.colorScheme.onSurface.copy(
                     alpha = 0.32f
                 )
             }
@@ -634,9 +646,9 @@ private fun RenderActiveToggles(
                     }
                 ),
             tint = if (item.feedTypes.contains(FeedType.PRIVATE_DMS)) {
-                MaterialTheme.colors.allGoodColor
+                MaterialTheme.colorScheme.allGoodColor
             } else {
-                MaterialTheme.colors.onSurface.copy(
+                MaterialTheme.colorScheme.onSurface.copy(
                     alpha = 0.32f
                 )
             }
@@ -667,9 +679,9 @@ private fun RenderActiveToggles(
                     }
                 ),
             tint = if (item.feedTypes.contains(FeedType.PUBLIC_CHATS)) {
-                MaterialTheme.colors.allGoodColor
+                MaterialTheme.colorScheme.allGoodColor
             } else {
-                MaterialTheme.colors.onSurface.copy(
+                MaterialTheme.colorScheme.onSurface.copy(
                     alpha = 0.32f
                 )
             }
@@ -700,9 +712,9 @@ private fun RenderActiveToggles(
                     }
                 ),
             tint = if (item.feedTypes.contains(FeedType.GLOBAL)) {
-                MaterialTheme.colors.allGoodColor
+                MaterialTheme.colorScheme.allGoodColor
             } else {
-                MaterialTheme.colors.onSurface.copy(
+                MaterialTheme.colorScheme.onSurface.copy(
                     alpha = 0.32f
                 )
             }
@@ -734,9 +746,9 @@ private fun RenderActiveToggles(
                     }
                 ),
             tint = if (item.feedTypes.contains(FeedType.SEARCH)) {
-                MaterialTheme.colors.allGoodColor
+                MaterialTheme.colorScheme.allGoodColor
             } else {
-                MaterialTheme.colors.onSurface.copy(
+                MaterialTheme.colorScheme.onSurface.copy(
                     alpha = 0.32f
                 )
             }
@@ -767,7 +779,7 @@ private fun FirstLine(
                     modifier = Modifier
                         .padding(start = 5.dp, top = 1.dp)
                         .size(14.dp),
-                    tint = MaterialTheme.colors.allGoodColor
+                    tint = MaterialTheme.colorScheme.allGoodColor
                 )
             }
         }
@@ -803,7 +815,7 @@ fun EditableServerConfig(relayToAdd: String, onNewRelay: (RelaySetupInfo) -> Uni
             placeholder = {
                 Text(
                     text = "server.com",
-                    color = MaterialTheme.colors.placeholderText,
+                    color = MaterialTheme.colorScheme.placeholderText,
                     maxLines = 1
                 )
             },
@@ -817,7 +829,7 @@ fun EditableServerConfig(relayToAdd: String, onNewRelay: (RelaySetupInfo) -> Uni
                 modifier = Modifier
                     .size(Size35dp)
                     .padding(horizontal = 5.dp),
-                tint = if (read) MaterialTheme.colors.allGoodColor else MaterialTheme.colors.placeholderText
+                tint = if (read) MaterialTheme.colorScheme.allGoodColor else MaterialTheme.colorScheme.placeholderText
             )
         }
 
@@ -828,7 +840,7 @@ fun EditableServerConfig(relayToAdd: String, onNewRelay: (RelaySetupInfo) -> Uni
                 modifier = Modifier
                     .size(Size35dp)
                     .padding(horizontal = 5.dp),
-                tint = if (write) MaterialTheme.colors.allGoodColor else MaterialTheme.colors.placeholderText
+                tint = if (write) MaterialTheme.colorScheme.allGoodColor else MaterialTheme.colorScheme.placeholderText
             )
         }
 
@@ -846,7 +858,7 @@ fun EditableServerConfig(relayToAdd: String, onNewRelay: (RelaySetupInfo) -> Uni
             shape = ButtonBorder,
             colors = ButtonDefaults
                 .buttonColors(
-                    backgroundColor = if (url.isNotBlank()) MaterialTheme.colors.primary else MaterialTheme.colors.placeholderText
+                    containerColor = if (url.isNotBlank()) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.placeholderText
                 )
         ) {
             Text(text = stringResource(id = R.string.add), color = Color.White)

app/src/main/java/com/vitorpamplona/amethyst/ui/actions/NewRelayListViewModel.kt

@@ -57,21 +57,30 @@ class NewRelayListViewModel : ViewModel() {
         _relays.update {
             var relayFile = account.userProfile().latestContactList?.relays()
 
-            // Ugly, but forces nostr.band as the only search-supporting relay today.
-            // TODO: Remove when search becomes more available.
-            if (relayFile?.none { it.key.removeSuffix("/") in Constants.forcedRelaysForSearchSet } == true) {
-                relayFile = relayFile + Constants.forcedRelayForSearch.map {
-                    Pair(
-                        it.url,
-                        ContactListEvent.ReadWrite(it.read, it.write)
-                    )
-                }
-            }
-
             if (relayFile != null) {
+                // Ugly, but forces nostr.band as the only search-supporting relay today.
+                // TODO: Remove when search becomes more available.
+
+                val needsSearchRelay = relayFile.none {
+                    it.key.removeSuffix("/") in Constants.forcedRelaysForSearchSet
+                } && relayFile.none {
+                    account.localRelays.filter { localRelay -> localRelay.url == it.key }.firstOrNull()?.feedTypes?.contains(FeedType.SEARCH) ?: false
+                }
+
+                if (needsSearchRelay) {
+                    relayFile = relayFile + Constants.forcedRelayForSearch.map {
+                        Pair(
+                            it.url,
+                            ContactListEvent.ReadWrite(it.read, it.write)
+                        )
+                    }
+                }
+
                 relayFile.map {
                     val liveRelay = RelayPool.getRelay(it.key)
-                    val localInfoFeedTypes = account.localRelays.filter { localRelay -> localRelay.url == it.key }.firstOrNull()?.feedTypes ?: FeedType.values().toSet().toImmutableSet()
+                    val localInfoFeedTypes = account.localRelays.filter { localRelay -> localRelay.url == it.key }.firstOrNull()?.feedTypes
+                        ?: Constants.defaultRelays.filter { defaultRelay -> defaultRelay.url == it.key }.firstOrNull()?.feedTypes
+                        ?: FeedType.values().toSet().toImmutableSet()
 
                     val errorCounter = liveRelay?.errorCounter ?: 0
                     val eventDownloadCounter = liveRelay?.eventDownloadCounterInBytes ?: 0

app/src/main/java/com/vitorpamplona/amethyst/ui/actions/NewUserMetadataView.kt

@@ -11,10 +11,10 @@ import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.foundation.verticalScroll
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.OutlinedTextField
-import androidx.compose.material.Surface
-import androidx.compose.material.Text
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.ui.Alignment
@@ -82,45 +82,26 @@ fun NewUserMetadataView(onClose: () -> Unit, account: Account) {
                 }
 
                 Column(
-                    modifier = Modifier.padding(10.dp).verticalScroll(rememberScrollState())
+                    modifier = Modifier
+                        .padding(10.dp)
+                        .verticalScroll(rememberScrollState())
                 ) {
-                    Row(
-                        modifier = Modifier.fillMaxWidth(1f),
-                        verticalAlignment = Alignment.CenterVertically
-                    ) {
-                        OutlinedTextField(
-                            label = { Text(text = stringResource(R.string.display_name)) },
-                            modifier = Modifier.weight(1f),
-                            value = postViewModel.displayName.value,
-                            onValueChange = { postViewModel.displayName.value = it },
-                            placeholder = {
-                                Text(
-                                    text = stringResource(R.string.my_display_name),
-                                    color = MaterialTheme.colors.placeholderText
-                                )
-                            },
-                            keyboardOptions = KeyboardOptions.Default.copy(
-                                capitalization = KeyboardCapitalization.Sentences
-                            ),
-                            singleLine = true
-                        )
-
-                        Text("@", Modifier.padding(5.dp))
-
-                        OutlinedTextField(
-                            label = { Text(text = stringResource(R.string.username)) },
-                            modifier = Modifier.weight(1f),
-                            value = postViewModel.userName.value,
-                            onValueChange = { postViewModel.userName.value = it },
-                            placeholder = {
-                                Text(
-                                    text = stringResource(R.string.my_username),
-                                    color = MaterialTheme.colors.placeholderText
-                                )
-                            },
-                            singleLine = true
-                        )
-                    }
+                    OutlinedTextField(
+                        label = { Text(text = stringResource(R.string.display_name)) },
+                        modifier = Modifier.fillMaxWidth(),
+                        value = postViewModel.displayName.value,
+                        onValueChange = { postViewModel.displayName.value = it },
+                        placeholder = {
+                            Text(
+                                text = stringResource(R.string.my_display_name),
+                                color = MaterialTheme.colorScheme.placeholderText
+                            )
+                        },
+                        keyboardOptions = KeyboardOptions.Default.copy(
+                            capitalization = KeyboardCapitalization.Sentences
+                        ),
+                        singleLine = true
+                    )
 
                     Spacer(modifier = Modifier.height(10.dp))
 
@@ -134,7 +115,7 @@ fun NewUserMetadataView(onClose: () -> Unit, account: Account) {
                         placeholder = {
                             Text(
                                 text = stringResource(id = R.string.about_me),
-                                color = MaterialTheme.colors.placeholderText
+                                color = MaterialTheme.colorScheme.placeholderText
                             )
                         },
                         keyboardOptions = KeyboardOptions.Default.copy(
@@ -153,13 +134,13 @@ fun NewUserMetadataView(onClose: () -> Unit, account: Account) {
                         placeholder = {
                             Text(
                                 text = "https://mywebsite.com/me.jpg",
-                                color = MaterialTheme.colors.placeholderText
+                                color = MaterialTheme.colorScheme.placeholderText
                             )
                         },
                         leadingIcon = {
                             UploadFromGallery(
                                 isUploading = postViewModel.isUploadingImageForPicture,
-                                tint = MaterialTheme.colors.placeholderText,
+                                tint = MaterialTheme.colorScheme.placeholderText,
                                 modifier = Modifier.padding(start = 5.dp)
                             ) {
                                 postViewModel.uploadForPicture(it, context)
@@ -178,13 +159,13 @@ fun NewUserMetadataView(onClose: () -> Unit, account: Account) {
                         placeholder = {
                             Text(
                                 text = "https://mywebsite.com/mybanner.jpg",
-                                color = MaterialTheme.colors.placeholderText
+                                color = MaterialTheme.colorScheme.placeholderText
                             )
                         },
                         leadingIcon = {
                             UploadFromGallery(
                                 isUploading = postViewModel.isUploadingImageForBanner,
-                                tint = MaterialTheme.colors.placeholderText,
+                                tint = MaterialTheme.colorScheme.placeholderText,
                                 modifier = Modifier.padding(start = 5.dp)
                             ) {
                                 postViewModel.uploadForBanner(it, context)
@@ -203,7 +184,7 @@ fun NewUserMetadataView(onClose: () -> Unit, account: Account) {
                         placeholder = {
                             Text(
                                 text = "https://mywebsite.com",
-                                color = MaterialTheme.colors.placeholderText
+                                color = MaterialTheme.colorScheme.placeholderText
                             )
                         },
                         singleLine = true
@@ -219,7 +200,7 @@ fun NewUserMetadataView(onClose: () -> Unit, account: Account) {
                         placeholder = {
                             Text(
                                 text = "_@mywebsite.com",
-                                color = MaterialTheme.colors.placeholderText
+                                color = MaterialTheme.colorScheme.placeholderText
                             )
                         },
                         singleLine = true
@@ -234,7 +215,7 @@ fun NewUserMetadataView(onClose: () -> Unit, account: Account) {
                         placeholder = {
                             Text(
                                 text = "me@mylightiningnode.com",
-                                color = MaterialTheme.colors.placeholderText
+                                color = MaterialTheme.colorScheme.placeholderText
                             )
                         },
                         singleLine = true
@@ -250,7 +231,7 @@ fun NewUserMetadataView(onClose: () -> Unit, account: Account) {
                         placeholder = {
                             Text(
                                 text = stringResource(R.string.lnurl),
-                                color = MaterialTheme.colors.placeholderText
+                                color = MaterialTheme.colorScheme.placeholderText
                             )
                         }
                     )
@@ -265,7 +246,7 @@ fun NewUserMetadataView(onClose: () -> Unit, account: Account) {
                         placeholder = {
                             Text(
                                 text = stringResource(R.string.twitter_proof_url_template),
-                                color = MaterialTheme.colors.placeholderText
+                                color = MaterialTheme.colorScheme.placeholderText
                             )
                         }
                     )
@@ -280,7 +261,7 @@ fun NewUserMetadataView(onClose: () -> Unit, account: Account) {
                         placeholder = {
                             Text(
                                 text = stringResource(R.string.mastodon_proof_url_template),
-                                color = MaterialTheme.colors.placeholderText
+                                color = MaterialTheme.colorScheme.placeholderText
                             )
                         }
                     )
@@ -295,7 +276,7 @@ fun NewUserMetadataView(onClose: () -> Unit, account: Account) {
                         placeholder = {
                             Text(
                                 text = stringResource(R.string.github_proof_url_template),
-                                color = MaterialTheme.colors.placeholderText
+                                color = MaterialTheme.colorScheme.placeholderText
                             )
                         }
                     )

app/src/main/java/com/vitorpamplona/amethyst/ui/actions/NewUserMetadataViewModel.kt

@@ -15,6 +15,7 @@ import com.vitorpamplona.quartz.events.GitHubIdentity
 import com.vitorpamplona.quartz.events.MastodonIdentity
 import com.vitorpamplona.quartz.events.TwitterIdentity
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.launch
 import java.io.ByteArrayInputStream
@@ -23,7 +24,7 @@ import java.io.StringWriter
 class NewUserMetadataViewModel : ViewModel() {
     private lateinit var account: Account
 
-    val userName = mutableStateOf("")
+    // val userName = mutableStateOf("")
     val displayName = mutableStateOf("")
     val about = mutableStateOf("")
 
@@ -41,13 +42,13 @@ class NewUserMetadataViewModel : ViewModel() {
 
     var isUploadingImageForPicture by mutableStateOf(false)
     var isUploadingImageForBanner by mutableStateOf(false)
-    val imageUploadingError = MutableSharedFlow<String?>()
+    val imageUploadingError = MutableSharedFlow<String?>(0, 3, onBufferOverflow = BufferOverflow.DROP_OLDEST)
 
     fun load(account: Account) {
         this.account = account
 
         account.userProfile().let {
-            userName.value = it.bestUsername() ?: ""
+            // userName.value = it.bestUsername() ?: ""
             displayName.value = it.bestDisplayName() ?: ""
             about.value = it.info?.about ?: ""
             picture.value = it.info?.picture ?: ""
@@ -82,8 +83,8 @@ class NewUserMetadataViewModel : ViewModel() {
         } else {
             ObjectMapper().createObjectNode()
         }
-        currentJson.put("name", userName.value.trim())
-        currentJson.put("username", userName.value.trim())
+        // currentJson.put("username", userName.value.trim())
+        currentJson.put("name", displayName.value.trim())
         currentJson.put("display_name", displayName.value.trim())
         currentJson.put("displayName", displayName.value.trim())
         currentJson.put("picture", picture.value.trim())
@@ -124,12 +125,11 @@ class NewUserMetadataViewModel : ViewModel() {
         viewModelScope.launch(Dispatchers.IO) {
             account.sendNewUserMetadata(writer.buffer.toString(), newClaims)
         }
-
         clear()
     }
 
     fun clear() {
-        userName.value = ""
+        // userName.value = ""
         displayName.value = ""
         about.value = ""
         picture.value = ""
@@ -183,23 +183,25 @@ class NewUserMetadataViewModel : ViewModel() {
             contentResolver.getType(galleryUri),
             context.applicationContext,
             onReady = { fileUri, contentType, size ->
-                ImageUploader.uploadImage(
-                    uri = fileUri,
-                    contentType = contentType,
-                    size = size,
-                    server = account.defaultFileServer,
-                    contentResolver = contentResolver,
-                    onSuccess = { imageUrl, mimeType ->
-                        onUploading(false)
-                        onUploaded(imageUrl)
-                    },
-                    onError = {
-                        onUploading(false)
-                        viewModelScope.launch {
-                            imageUploadingError.emit("Failed to upload the image / video")
+                viewModelScope.launch(Dispatchers.IO) {
+                    ImageUploader.uploadImage(
+                        uri = fileUri,
+                        contentType = contentType,
+                        size = size,
+                        server = account.defaultFileServer,
+                        contentResolver = contentResolver,
+                        onSuccess = { imageUrl, mimeType ->
+                            onUploading(false)
+                            onUploaded(imageUrl)
+                        },
+                        onError = {
+                            onUploading(false)
+                            viewModelScope.launch {
+                                imageUploadingError.emit("Failed to upload the image / video")
+                            }
                         }
-                    }
-                )
+                    )
+                }
             },
             onError = {
                 onUploading(false)

app/src/main/java/com/vitorpamplona/amethyst/ui/actions/RelayInformationDialog.kt

@@ -13,9 +13,10 @@ import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.verticalScroll
-import androidx.compose.material.Surface
-import androidx.compose.material.Text
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
@@ -25,8 +26,10 @@ import androidx.compose.ui.unit.sp
 import androidx.compose.ui.window.Dialog
 import androidx.compose.ui.window.DialogProperties
 import com.vitorpamplona.amethyst.R
+import com.vitorpamplona.amethyst.model.ConnectivityType
 import com.vitorpamplona.amethyst.model.RelayBriefInfo
 import com.vitorpamplona.amethyst.model.RelayInformation
+import com.vitorpamplona.amethyst.service.connectivitystatus.ConnectivityStatus
 import com.vitorpamplona.amethyst.ui.components.ClickableEmail
 import com.vitorpamplona.amethyst.ui.components.ClickableUrl
 import com.vitorpamplona.amethyst.ui.note.LoadUser
@@ -47,6 +50,14 @@ fun RelayInformationDialog(
     accountViewModel: AccountViewModel,
     nav: (String) -> Unit
 ) {
+    val automaticallyShowProfilePicture = remember {
+        when (accountViewModel.account.settings.automaticallyShowProfilePictures) {
+            ConnectivityType.WIFI_ONLY -> !ConnectivityStatus.isOnMobileData.value
+            ConnectivityType.NEVER -> false
+            ConnectivityType.ALWAYS -> true
+        }
+    }
+
     Dialog(
         onDismissRequest = { onClose() },
         properties = DialogProperties(
@@ -77,6 +88,7 @@ fun RelayInformationDialog(
                     Column() {
                         RenderRelayIcon(
                             relayBriefInfo.favIcon,
+                            automaticallyShowProfilePicture,
                             Size55dp
                         )
                     }
@@ -111,7 +123,15 @@ fun RelayInformationDialog(
                 Section(stringResource(R.string.contact))
 
                 Box(modifier = Modifier.padding(start = 10.dp)) {
-                    ClickableEmail(relayInfo.contact ?: "")
+                    relayInfo.contact?.let {
+                        if (it.startsWith("https:")) {
+                            ClickableUrl(urlText = it, url = it)
+                        } else if (it.startsWith("mailto:") || it.contains('@')) {
+                            ClickableEmail(it)
+                        } else {
+                            SectionContent(it)
+                        }
+                    }
                 }
 
                 Section(stringResource(R.string.supports))
@@ -248,7 +268,7 @@ private fun DisplayOwnerInformation(
     accountViewModel: AccountViewModel,
     nav: (String) -> Unit
 ) {
-    LoadUser(baseUserHex = userHex) {
+    LoadUser(baseUserHex = userHex, accountViewModel) {
         Crossfade(it) {
             if (it != null) {
                 UserCompose(baseUser = it, accountViewModel = accountViewModel, showDiviser = false, nav = nav)

app/src/main/java/com/vitorpamplona/amethyst/ui/actions/RelaySelectionDialog.kt

@@ -1,6 +1,5 @@
 package com.vitorpamplona.amethyst.ui.actions
 
-import android.widget.Toast
 import androidx.compose.foundation.ExperimentalFoundationApi
 import androidx.compose.foundation.combinedClickable
 import androidx.compose.foundation.layout.Arrangement
@@ -12,19 +11,18 @@ import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.itemsIndexed
-import androidx.compose.material.Surface
-import androidx.compose.material.Switch
-import androidx.compose.material.Text
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Switch
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.window.Dialog
 import androidx.compose.ui.window.DialogProperties
@@ -34,7 +32,6 @@ import com.vitorpamplona.amethyst.model.RelayInformation
 import com.vitorpamplona.amethyst.service.Nip11Retriever
 import com.vitorpamplona.amethyst.service.relays.Relay
 import com.vitorpamplona.amethyst.ui.screen.loggedIn.AccountViewModel
-import kotlinx.coroutines.launch
 
 data class RelayList(
     val relay: Relay,
@@ -55,7 +52,6 @@ fun RelaySelectionDialog(
     accountViewModel: AccountViewModel,
     nav: (String) -> Unit
 ) {
-    val scope = rememberCoroutineScope()
     val context = LocalContext.current
 
     var relays by remember {
@@ -69,6 +65,13 @@ fun RelaySelectionDialog(
             }
         )
     }
+
+    val hasSelectedRelay by remember {
+        derivedStateOf {
+            relays.any { it.isSelected }
+        }
+    }
+
     var relayInfo: RelayInfoDialog? by remember { mutableStateOf(null) }
 
     relayInfo?.let {
@@ -121,21 +124,15 @@ fun RelaySelectionDialog(
                     SaveButton(
                         onPost = {
                             val selectedRelays = relays.filter { it.isSelected }
-                            if (selectedRelays.isEmpty()) {
-                                scope.launch {
-                                    Toast.makeText(context, context.getString(R.string.select_a_relay_to_continue), Toast.LENGTH_SHORT).show()
-                                }
-                                return@SaveButton
-                            }
                             onPost(selectedRelays.map { it.relay })
                             onClose()
                         },
-                        isActive = true
+                        isActive = hasSelectedRelay
                     )
                 }
 
                 RelaySwitch(
-                    text = stringResource(R.string.select_deselect_all),
+                    text = context.getString(R.string.select_deselect_all),
                     checked = selected,
                     onClick = {
                         selected = !selected
@@ -181,15 +178,10 @@ fun RelaySelectionDialog(
                                             Nip11Retriever.ErrorCode.FAIL_WITH_HTTP_STATUS -> context.getString(R.string.relay_information_document_error_assemble_url, url, exceptionMessage)
                                         }
 
-                                        scope.launch {
-                                            Toast
-                                                .makeText(
-                                                    context,
-                                                    msg,
-                                                    Toast.LENGTH_SHORT
-                                                )
-                                                .show()
-                                        }
+                                        accountViewModel.toast(
+                                            context.getString(R.string.unable_to_download_relay_document),
+                                            msg
+                                        )
                                     }
                                 )
                             }

app/src/main/java/com/vitorpamplona/amethyst/ui/actions/SaveToGallery.kt

@@ -3,12 +3,10 @@ package com.vitorpamplona.amethyst.ui.actions
 import android.Manifest
 import android.os.Build
 import android.widget.Toast
-import androidx.compose.material.Button
-import androidx.compose.material.ButtonDefaults
-import androidx.compose.material.Text
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import com.google.accompanist.permissions.ExperimentalPermissionsApi
@@ -66,21 +64,16 @@ fun SaveToGallery(url: String) {
         }
     }
 
-    Button(
+    OutlinedButton(
         onClick = {
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q || writeStoragePermissionState.status.isGranted) {
                 saveImage()
             } else {
                 writeStoragePermissionState.launchPermissionRequest()
             }
-        },
-        shape = ButtonBorder,
-        colors = ButtonDefaults
-            .buttonColors(
-                backgroundColor = Color.Gray
-            )
+        }
     ) {
-        Text(text = stringResource(id = R.string.save), color = Color.White)
+        Text(text = stringResource(id = R.string.save))
     }
 }
 
@@ -126,7 +119,7 @@ fun SaveToGallery(localFile: File, mimeType: String?) {
         }
     }
 
-    Button(
+    OutlinedButton(
         onClick = {
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q || writeStoragePermissionState.status.isGranted) {
                 saveImage()
@@ -134,12 +127,8 @@ fun SaveToGallery(localFile: File, mimeType: String?) {
                 writeStoragePermissionState.launchPermissionRequest()
             }
         },
-        shape = ButtonBorder,
-        colors = ButtonDefaults
-            .buttonColors(
-                backgroundColor = Color.Gray
-            )
+        shape = ButtonBorder
     ) {
-        Text(text = stringResource(id = R.string.save), color = Color.White)
+        Text(text = stringResource(id = R.string.save))
     }
 }

app/src/main/java/com/vitorpamplona/amethyst/ui/actions/UploadFromGallery.kt

@@ -9,12 +9,22 @@ import androidx.compose.animation.core.infiniteRepeatable
 import androidx.compose.animation.core.rememberInfiniteTransition
 import androidx.compose.animation.core.tween
 import androidx.compose.foundation.border
-import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.AddPhotoAlternate
-import androidx.compose.runtime.*
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.SideEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.rotate
@@ -144,7 +154,7 @@ fun LoadingAnimation(
             ),
         progress = 1f,
         strokeWidth = 1.dp,
-        color = MaterialTheme.colors.background // Set background color
+        color = MaterialTheme.colorScheme.background // Set background color
     )
 }
 

app/src/main/java/com/vitorpamplona/amethyst/ui/buttons/ChannelFabColumn.kt

@@ -1,15 +1,21 @@
 package com.vitorpamplona.amethyst.ui.buttons
 
-import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.material.ButtonDefaults
-import androidx.compose.material.Icon
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.OutlinedButton
-import androidx.compose.material.Text
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.Add
-import androidx.compose.runtime.*
+import androidx.compose.material3.FloatingActionButton
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.res.stringResource
@@ -20,6 +26,7 @@ import com.vitorpamplona.amethyst.ui.actions.NewChannelView
 import com.vitorpamplona.amethyst.ui.actions.NewPostView
 import com.vitorpamplona.amethyst.ui.screen.loggedIn.AccountViewModel
 import com.vitorpamplona.amethyst.ui.theme.Font12SP
+import com.vitorpamplona.amethyst.ui.theme.Size55Modifier
 
 @Composable
 fun ChannelFabColumn(accountViewModel: AccountViewModel, nav: (String) -> Unit) {
@@ -46,12 +53,11 @@ fun ChannelFabColumn(accountViewModel: AccountViewModel, nav: (String) -> Unit)
 
     Column() {
         if (isOpen) {
-            OutlinedButton(
+            FloatingActionButton(
                 onClick = { wantsToSendNewMessage = true; isOpen = false },
-                modifier = Modifier.size(55.dp),
+                modifier = Size55Modifier,
                 shape = CircleShape,
-                colors = ButtonDefaults.outlinedButtonColors(backgroundColor = MaterialTheme.colors.primary),
-                contentPadding = PaddingValues(bottom = 3.dp)
+                containerColor = MaterialTheme.colorScheme.primary
             ) {
                 Text(
                     text = stringResource(R.string.messages_new_message),
@@ -63,12 +69,11 @@ fun ChannelFabColumn(accountViewModel: AccountViewModel, nav: (String) -> Unit)
 
             Spacer(modifier = Modifier.height(20.dp))
 
-            OutlinedButton(
+            FloatingActionButton(
                 onClick = { wantsToCreateChannel = true; isOpen = false },
-                modifier = Modifier.size(55.dp),
+                modifier = Size55Modifier,
                 shape = CircleShape,
-                colors = ButtonDefaults.outlinedButtonColors(backgroundColor = MaterialTheme.colors.primary),
-                contentPadding = PaddingValues(bottom = 3.dp)
+                containerColor = MaterialTheme.colorScheme.primary
             ) {
                 Text(
                     text = stringResource(R.string.messages_create_public_chat),
@@ -81,12 +86,11 @@ fun ChannelFabColumn(accountViewModel: AccountViewModel, nav: (String) -> Unit)
             Spacer(modifier = Modifier.height(20.dp))
         }
 
-        OutlinedButton(
+        FloatingActionButton(
             onClick = { isOpen = !isOpen },
-            modifier = Modifier.size(55.dp),
+            modifier = Size55Modifier,
             shape = CircleShape,
-            colors = ButtonDefaults.outlinedButtonColors(backgroundColor = MaterialTheme.colors.primary),
-            contentPadding = PaddingValues(0.dp)
+            containerColor = MaterialTheme.colorScheme.primary
         ) {
             Icon(
                 imageVector = Icons.Outlined.Add,

app/src/main/java/com/vitorpamplona/amethyst/ui/buttons/NewChannelButton.kt

@@ -3,12 +3,12 @@ package com.vitorpamplona.amethyst.buttons
 import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.material.ButtonDefaults
-import androidx.compose.material.Icon
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.OutlinedButton
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.Add
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -36,7 +36,7 @@ fun NewChannelButton(accountViewModel: AccountViewModel) {
         onClick = { wantsToPost = true },
         modifier = Modifier.size(55.dp),
         shape = CircleShape,
-        colors = ButtonDefaults.outlinedButtonColors(backgroundColor = MaterialTheme.colors.primary),
+        colors = ButtonDefaults.outlinedButtonColors(containerColor = MaterialTheme.colorScheme.primary),
         contentPadding = PaddingValues(0.dp)
     ) {
         Icon(

app/src/main/java/com/vitorpamplona/amethyst/ui/buttons/NewCommunityNoteButton.kt

@@ -1,12 +1,10 @@
 package com.vitorpamplona.amethyst.ui.buttons
 
-import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.material.ButtonDefaults
-import androidx.compose.material.Icon
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.OutlinedButton
+import androidx.compose.material3.FloatingActionButton
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -21,10 +19,11 @@ import com.vitorpamplona.amethyst.model.Note
 import com.vitorpamplona.amethyst.ui.actions.NewPostView
 import com.vitorpamplona.amethyst.ui.components.LoadNote
 import com.vitorpamplona.amethyst.ui.screen.loggedIn.AccountViewModel
+import com.vitorpamplona.amethyst.ui.theme.Size55Modifier
 
 @Composable
 fun NewCommunityNoteButton(communityIdHex: String, accountViewModel: AccountViewModel, nav: (String) -> Unit) {
-    LoadNote(baseNoteHex = communityIdHex) {
+    LoadNote(baseNoteHex = communityIdHex, accountViewModel) {
         it?.let {
             NewCommunityNoteButton(it, accountViewModel, nav)
         }
@@ -41,12 +40,11 @@ fun NewCommunityNoteButton(note: Note, accountViewModel: AccountViewModel, nav:
         NewPostView({ wantsToPost = false }, note, accountViewModel = accountViewModel, nav = nav)
     }
 
-    OutlinedButton(
+    FloatingActionButton(
         onClick = { wantsToPost = true },
-        modifier = Modifier.size(55.dp),
+        modifier = Size55Modifier,
         shape = CircleShape,
-        colors = ButtonDefaults.outlinedButtonColors(backgroundColor = MaterialTheme.colors.primary),
-        contentPadding = PaddingValues(0.dp)
+        containerColor = MaterialTheme.colorScheme.primary
     ) {
         Icon(
             painter = painterResource(R.drawable.ic_compose),

app/src/main/java/com/vitorpamplona/amethyst/ui/buttons/NewImageButton.kt

@@ -6,16 +6,14 @@ import android.os.Build
 import androidx.compose.animation.core.animateFloatAsState
 import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.material.ButtonDefaults
-import androidx.compose.material.CircularProgressIndicator
-import androidx.compose.material.Icon
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.OutlinedButton
-import androidx.compose.material.ProgressIndicatorDefaults
-import androidx.compose.material.Text
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.FloatingActionButton
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.ProgressIndicatorDefaults
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
@@ -41,6 +39,7 @@ import com.vitorpamplona.amethyst.ui.actions.NewMediaModel
 import com.vitorpamplona.amethyst.ui.actions.NewMediaView
 import com.vitorpamplona.amethyst.ui.navigation.Route
 import com.vitorpamplona.amethyst.ui.screen.loggedIn.AccountViewModel
+import com.vitorpamplona.amethyst.ui.theme.Size55Modifier
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
@@ -112,12 +111,11 @@ fun NewImageButton(accountViewModel: AccountViewModel, nav: (String) -> Unit, na
     if (postViewModel.isUploadingImage) {
         ShowProgress(postViewModel)
     } else {
-        OutlinedButton(
+        FloatingActionButton(
             onClick = { wantsToPost = true },
-            modifier = Modifier.size(55.dp),
+            modifier = Size55Modifier,
             shape = CircleShape,
-            colors = ButtonDefaults.outlinedButtonColors(backgroundColor = MaterialTheme.colors.primary),
-            contentPadding = PaddingValues(0.dp)
+            containerColor = MaterialTheme.colorScheme.primary
         ) {
             Icon(
                 painter = painterResource(R.drawable.ic_compose),
@@ -137,16 +135,15 @@ private fun ShowProgress(postViewModel: NewMediaModel) {
                 targetValue = postViewModel.uploadingPercentage.value,
                 animationSpec = ProgressIndicatorDefaults.ProgressAnimationSpec
             ).value,
-            modifier = Modifier
-                .size(55.dp)
+            modifier = Size55Modifier
                 .clip(CircleShape)
-                .background(MaterialTheme.colors.background),
+                .background(MaterialTheme.colorScheme.background),
             strokeWidth = 5.dp
         )
         postViewModel.uploadingDescription.value?.let {
             Text(
                 it,
-                color = MaterialTheme.colors.onSurface,
+                color = MaterialTheme.colorScheme.onSurface,
                 fontSize = 10.sp,
                 textAlign = TextAlign.Center
             )

app/src/main/java/com/vitorpamplona/amethyst/ui/buttons/NewNoteButton.kt

@@ -1,12 +1,10 @@
 package com.vitorpamplona.amethyst.ui.buttons
 
-import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.material.ButtonDefaults
-import androidx.compose.material.Icon
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.OutlinedButton
+import androidx.compose.material3.FloatingActionButton
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -19,6 +17,7 @@ import androidx.compose.ui.unit.dp
 import com.vitorpamplona.amethyst.R
 import com.vitorpamplona.amethyst.ui.actions.NewPostView
 import com.vitorpamplona.amethyst.ui.screen.loggedIn.AccountViewModel
+import com.vitorpamplona.amethyst.ui.theme.Size55Modifier
 
 @Composable
 fun NewNoteButton(accountViewModel: AccountViewModel, nav: (String) -> Unit) {
@@ -30,12 +29,11 @@ fun NewNoteButton(accountViewModel: AccountViewModel, nav: (String) -> Unit) {
         NewPostView({ wantsToPost = false }, accountViewModel = accountViewModel, nav = nav)
     }
 
-    OutlinedButton(
+    FloatingActionButton(
         onClick = { wantsToPost = true },
-        modifier = Modifier.size(55.dp),
+        modifier = Size55Modifier,
         shape = CircleShape,
-        colors = ButtonDefaults.outlinedButtonColors(backgroundColor = MaterialTheme.colors.primary),
-        contentPadding = PaddingValues(0.dp)
+        containerColor = MaterialTheme.colorScheme.primary
     ) {
         Icon(
             painter = painterResource(R.drawable.ic_compose),

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

@@ -6,16 +6,24 @@ import androidx.compose.animation.core.tween
 import androidx.compose.foundation.Canvas
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.requiredHeight
-import androidx.compose.material.MaterialTheme
-import androidx.compose.runtime.*
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.ExperimentalComposeUiApi
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.geometry.CornerRadius
 import androidx.compose.ui.geometry.Offset
 import androidx.compose.ui.geometry.Size
-import androidx.compose.ui.graphics.*
+import androidx.compose.ui.graphics.BlendMode
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.SolidColor
 import androidx.compose.ui.graphics.drawscope.DrawStyle
 import androidx.compose.ui.graphics.drawscope.Fill
+import androidx.compose.ui.graphics.graphicsLayer
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.coerceIn
 import androidx.compose.ui.unit.dp
@@ -55,7 +63,7 @@ fun AudioWaveformReadOnly(
     amplitudes: List<Int>,
     onProgressChange: (Float) -> Unit
 ) {
-    val backgroundColor = MaterialTheme.colors.background
+    val backgroundColor = MaterialTheme.colorScheme.background
     val _progress = remember(progress) { progress.coerceIn(MinProgress, MaxProgress) }
     val _spikeWidth = remember(spikeWidth) { spikeWidth.coerceIn(MinSpikeWidthDp, MaxSpikeWidthDp) }
     val _spikePadding = remember(spikePadding) { spikePadding.coerceIn(MinSpikePaddingDp, MaxSpikePaddingDp) }

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

@@ -2,7 +2,6 @@ package com.vitorpamplona.amethyst.ui.components
 
 import android.content.Intent
 import android.net.Uri
-import android.widget.Toast
 import androidx.compose.animation.Crossfade
 import androidx.compose.foundation.border
 import androidx.compose.foundation.layout.Column
@@ -10,8 +9,20 @@ import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
-import androidx.compose.material.*
-import androidx.compose.runtime.*
+import androidx.compose.material3.Button
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.Divider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.LocalTextStyle
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
@@ -76,7 +87,7 @@ fun CashuPreview(token: CashuToken, accountViewModel: AccountViewModel) {
             .fillMaxWidth()
             .padding(start = 30.dp, end = 30.dp)
             .clip(shape = QuoteBorder)
-            .border(1.dp, MaterialTheme.colors.subtleBorder, QuoteBorder)
+            .border(1.dp, MaterialTheme.colorScheme.subtleBorder, QuoteBorder)
     ) {
         Column(
             modifier = Modifier
@@ -133,31 +144,25 @@ fun CashuPreview(token: CashuToken, accountViewModel: AccountViewModel) {
                                 CashuProcessor().melt(
                                     token,
                                     lud16,
-                                    onSuccess = {
-                                        scope.launch {
-                                            Toast.makeText(context, it, Toast.LENGTH_SHORT).show()
-                                        }
+                                    onSuccess = { title, message ->
+                                        accountViewModel.toast(title, message)
                                     },
-                                    onError = {
-                                        scope.launch {
-                                            Toast.makeText(context, it, Toast.LENGTH_SHORT).show()
-                                        }
-                                    }
+                                    onError = { title, message ->
+                                        accountViewModel.toast(title, message)
+                                    },
+                                    context
                                 )
                             }
                         } else {
-                            scope.launch {
-                                Toast.makeText(
-                                    context,
-                                    context.getString(R.string.no_lightning_address_set),
-                                    Toast.LENGTH_SHORT
-                                ).show()
-                            }
+                            accountViewModel.toast(
+                                context.getString(R.string.no_lightning_address_set),
+                                context.getString(R.string.user_x_does_not_have_a_lightning_address_setup_to_receive_sats, accountViewModel.account.userProfile().toBestDisplayName())
+                            )
                         }
                     },
                     shape = QuoteBorder,
                     colors = ButtonDefaults.buttonColors(
-                        backgroundColor = MaterialTheme.colors.primary
+                        containerColor = MaterialTheme.colorScheme.primary
                     )
                 ) {
                     Text(
@@ -177,16 +182,12 @@ fun CashuPreview(token: CashuToken, accountViewModel: AccountViewModel) {
                             startActivity(context, intent, null)
                         } else {
                             // Copying the token to clipboard for now
-                            var orignaltoken = token.token
-                            clipboardManager.setText(AnnotatedString("$orignaltoken"))
-                            scope.launch {
-                                Toast.makeText(context, context.getString(R.string.copied_token_to_clipboard), Toast.LENGTH_SHORT).show()
-                            }
+                            clipboardManager.setText(AnnotatedString(token.token))
                         }
                     },
                     shape = QuoteBorder,
                     colors = ButtonDefaults.buttonColors(
-                        backgroundColor = MaterialTheme.colors.primary
+                        containerColor = MaterialTheme.colorScheme.primary
                     )
                 ) {
                     Text("⎘", color = Color.White, fontSize = 18.sp)

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

@@ -4,8 +4,8 @@ import android.content.ActivityNotFoundException
 import android.content.Context
 import android.content.Intent
 import androidx.compose.foundation.text.ClickableText
-import androidx.compose.material.LocalTextStyle
-import androidx.compose.material.MaterialTheme
+import androidx.compose.material3.LocalTextStyle
+import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
 import androidx.compose.ui.platform.LocalContext
@@ -13,12 +13,13 @@ import androidx.compose.ui.text.AnnotatedString
 
 @Composable
 fun ClickableEmail(email: String) {
+    val stripped = email.replaceFirst("mailto:", "")
     val context = LocalContext.current
 
     ClickableText(
-        text = remember { AnnotatedString(email) },
-        onClick = { runCatching { context.sendMail(email) } },
-        style = LocalTextStyle.current.copy(color = MaterialTheme.colors.primary)
+        text = remember { AnnotatedString(stripped) },
+        onClick = { runCatching { context.sendMail(stripped) } },
+        style = LocalTextStyle.current.copy(color = MaterialTheme.colorScheme.primary)
     )
 }
 

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

@@ -1,8 +1,8 @@
 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.material3.LocalTextStyle
+import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.text.AnnotatedString
 import com.vitorpamplona.amethyst.model.Note
@@ -16,6 +16,6 @@ fun ClickableNoteTag(
     ClickableText(
         text = AnnotatedString("@${baseNote.idNote().toShortenHex()}"),
         onClick = { nav("Note/${baseNote.idHex}") },
-        style = LocalTextStyle.current.copy(color = MaterialTheme.colors.primary)
+        style = LocalTextStyle.current.copy(color = MaterialTheme.colorScheme.primary)
     )
 }

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

@@ -4,8 +4,8 @@ import android.content.Context
 import android.content.Intent
 import android.net.Uri
 import androidx.compose.foundation.text.ClickableText
-import androidx.compose.material.LocalTextStyle
-import androidx.compose.material.MaterialTheme
+import androidx.compose.material3.LocalTextStyle
+import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
 import androidx.compose.ui.platform.LocalContext
@@ -18,7 +18,7 @@ fun ClickablePhone(phone: String) {
     ClickableText(
         text = remember { AnnotatedString(phone) },
         onClick = { runCatching { context.dial(phone) } },
-        style = LocalTextStyle.current.copy(color = MaterialTheme.colors.primary)
+        style = LocalTextStyle.current.copy(color = MaterialTheme.colorScheme.primary)
     )
 }
 

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

@@ -7,11 +7,10 @@ import androidx.compose.foundation.text.BasicText
 import androidx.compose.foundation.text.ClickableText
 import androidx.compose.foundation.text.InlineTextContent
 import androidx.compose.foundation.text.appendInlineContent
-import androidx.compose.material.LocalContentAlpha
-import androidx.compose.material.LocalContentColor
-import androidx.compose.material.LocalTextStyle
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.Text
+import androidx.compose.material3.LocalContentColor
+import androidx.compose.material3.LocalTextStyle
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.Immutable
 import androidx.compose.runtime.LaunchedEffect
@@ -40,12 +39,12 @@ import androidx.compose.ui.unit.TextUnit
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import coil.compose.AsyncImage
-import com.vitorpamplona.amethyst.model.LocalCache
 import com.vitorpamplona.amethyst.model.Note
 import com.vitorpamplona.amethyst.model.User
 import com.vitorpamplona.amethyst.service.NIP30Parser
 import com.vitorpamplona.amethyst.ui.note.LoadChannel
 import com.vitorpamplona.amethyst.ui.note.toShortenHex
+import com.vitorpamplona.amethyst.ui.screen.loggedIn.AccountViewModel
 import com.vitorpamplona.quartz.encoders.Nip19
 import com.vitorpamplona.quartz.events.ChannelCreateEvent
 import com.vitorpamplona.quartz.events.ImmutableListOfLists
@@ -61,20 +60,21 @@ import kotlinx.coroutines.launch
 @Composable
 fun ClickableRoute(
     nip19: Nip19.Return,
+    accountViewModel: AccountViewModel,
     nav: (String) -> Unit
 ) {
     when (nip19.type) {
         Nip19.Type.USER -> {
-            DisplayUser(nip19, nav)
+            DisplayUser(nip19, accountViewModel, nav)
         }
         Nip19.Type.ADDRESS -> {
-            DisplayAddress(nip19, nav)
+            DisplayAddress(nip19, accountViewModel, nav)
         }
         Nip19.Type.NOTE -> {
-            DisplayNote(nip19, nav)
+            DisplayNote(nip19, accountViewModel, nav)
         }
         Nip19.Type.EVENT -> {
-            DisplayEvent(nip19, nav)
+            DisplayEvent(nip19, accountViewModel, nav)
         }
         else -> {
             Text(
@@ -86,34 +86,15 @@ fun ClickableRoute(
     }
 }
 
-@Composable
-private fun LoadNote(
-    hex: String,
-    content: @Composable (Note) -> Unit
-) {
-    var noteBase by remember(hex) { mutableStateOf(LocalCache.getNoteIfExists(hex)) }
-
-    if (noteBase == null) {
-        LaunchedEffect(key1 = hex) {
-            launch(Dispatchers.IO) {
-                noteBase = LocalCache.checkGetOrCreateNote(hex)
-            }
-        }
-    }
-
-    noteBase?.let {
-        content(it)
-    }
-}
-
 @Composable
 private fun DisplayEvent(
     nip19: Nip19.Return,
+    accountViewModel: AccountViewModel,
     nav: (String) -> Unit
 ) {
-    LoadNote(nip19.hex) {
+    LoadNote(nip19.hex, accountViewModel) {
         if (it != null) {
-            DisplayNoteLink(it, nip19, nav)
+            DisplayNoteLink(it, nip19, accountViewModel, nav)
         } else {
             CreateClickableText(
                 clickablePart = remember(nip19) { "@${nip19.hex.toShortenHex()}" },
@@ -128,11 +109,12 @@ private fun DisplayEvent(
 @Composable
 private fun DisplayNote(
     nip19: Nip19.Return,
+    accountViewModel: AccountViewModel,
     nav: (String) -> Unit
 ) {
-    LoadNote(nip19.hex) {
+    LoadNote(nip19.hex, accountViewModel = accountViewModel) {
         if (it != null) {
-            DisplayNoteLink(it, nip19, nav)
+            DisplayNoteLink(it, nip19, accountViewModel, nav)
         } else {
             CreateClickableText(
                 clickablePart = remember(nip19) { "@${nip19.hex.toShortenHex()}" },
@@ -148,6 +130,7 @@ private fun DisplayNote(
 private fun DisplayNoteLink(
     it: Note,
     nip19: Nip19.Return,
+    accountViewModel: AccountViewModel,
     nav: (String) -> Unit
 ) {
     val noteState by it.live().metadata.observeAsState()
@@ -177,7 +160,7 @@ private fun DisplayNoteLink(
             nav = nav
         )
     } else if (channelHex != null) {
-        LoadChannel(baseChannelHex = channelHex) { baseChannel ->
+        LoadChannel(baseChannelHex = channelHex, accountViewModel) { baseChannel ->
             val channelState by baseChannel.live.observeAsState()
             val channelDisplayName by remember(channelState) {
                 derivedStateOf {
@@ -205,14 +188,15 @@ private fun DisplayNoteLink(
 @Composable
 private fun DisplayAddress(
     nip19: Nip19.Return,
+    accountViewModel: AccountViewModel,
     nav: (String) -> Unit
 ) {
-    var noteBase by remember(nip19) { mutableStateOf(LocalCache.getNoteIfExists(nip19.hex)) }
+    var noteBase by remember(nip19) { mutableStateOf(accountViewModel.getNoteIfExists(nip19.hex)) }
 
     if (noteBase == null) {
         LaunchedEffect(key1 = nip19.hex) {
-            launch(Dispatchers.IO) {
-                noteBase = LocalCache.checkGetOrCreateAddressableNote(nip19.hex)
+            accountViewModel.checkGetOrCreateAddressableNote(nip19.hex) {
+                noteBase = it
             }
         }
     }
@@ -244,14 +228,19 @@ private fun DisplayAddress(
 @Composable
 private fun DisplayUser(
     nip19: Nip19.Return,
+    accountViewModel: AccountViewModel,
     nav: (String) -> Unit
 ) {
-    var userBase by remember(nip19) { mutableStateOf(LocalCache.getUserIfExists(nip19.hex)) }
+    var userBase by remember(nip19) {
+        mutableStateOf(
+            accountViewModel.getUserIfExists(nip19.hex)
+        )
+    }
 
     if (userBase == null) {
         LaunchedEffect(key1 = nip19.hex) {
-            launch(Dispatchers.IO) {
-                userBase = LocalCache.checkGetOrCreateUser(nip19.hex)
+            accountViewModel.checkGetOrCreateUser(nip19.hex) {
+                userBase = it
             }
         }
     }
@@ -317,8 +306,8 @@ fun CreateClickableText(
     nav: (String) -> Unit
 ) {
     val currentStyle = LocalTextStyle.current
-    val primaryColor = MaterialTheme.colors.primary
-    val onBackgroundColor = MaterialTheme.colors.onBackground
+    val primaryColor = MaterialTheme.colorScheme.primary
+    val onBackgroundColor = MaterialTheme.colorScheme.onBackground
 
     val clickablePartStyle = remember(primaryColor, overrideColor) {
         currentStyle.copy(color = overrideColor ?: primaryColor, fontWeight = fontWeight).toSpanStyle()
@@ -378,7 +367,7 @@ fun CreateTextWithEmoji(
 
     val textColor = color.takeOrElse {
         LocalTextStyle.current.color.takeOrElse {
-            LocalContentColor.current.copy(alpha = LocalContentAlpha.current)
+            LocalContentColor.current
         }
     }
 
@@ -434,7 +423,7 @@ fun CreateTextWithEmoji(
 
     val textColor = color.takeOrElse {
         LocalTextStyle.current.color.takeOrElse {
-            LocalContentColor.current.copy(alpha = LocalContentAlpha.current)
+            LocalContentColor.current
         }
     }
 
@@ -547,14 +536,14 @@ fun CreateClickableTextWithEmoji(
         ClickableInLineIconRenderer(
             emojiLists!!.part1,
             maxLines,
-            LocalTextStyle.current.copy(color = overrideColor ?: MaterialTheme.colors.primary, fontWeight = fontWeight).toSpanStyle()
+            LocalTextStyle.current.copy(color = overrideColor ?: MaterialTheme.colorScheme.primary, fontWeight = fontWeight).toSpanStyle()
         ) {
             nav(route)
         }
 
         InLineIconRenderer(
             emojiLists!!.part2,
-            LocalTextStyle.current.copy(color = overrideColor ?: MaterialTheme.colors.onBackground, fontWeight = fontWeight).toSpanStyle(),
+            LocalTextStyle.current.copy(color = overrideColor ?: MaterialTheme.colorScheme.onBackground, fontWeight = fontWeight).toSpanStyle(),
             maxLines = maxLines
         )
     }
@@ -687,7 +676,7 @@ fun InLineIconRenderer(
                         contentDescription = null,
                         modifier = Modifier
                             .fillMaxSize()
-                            .padding(horizontal = 1.dp)
+                            .padding(horizontal = 0.dp)
                     )
                 }
             )

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

@@ -1,8 +1,8 @@
 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.material3.LocalTextStyle
+import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
 import androidx.compose.ui.platform.LocalUriHandler
@@ -23,6 +23,6 @@ fun ClickableUrl(urlText: String, url: String) {
     ClickableText(
         text = text,
         onClick = { runCatching { uri.openUri(doubleCheckedUrl) } },
-        style = LocalTextStyle.current.copy(color = MaterialTheme.colors.primary)
+        style = LocalTextStyle.current.copy(color = MaterialTheme.colorScheme.primary)
     )
 }

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

@@ -1,8 +1,8 @@
 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.material3.LocalTextStyle
+import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.livedata.observeAsState
@@ -28,6 +28,6 @@ fun ClickableUserTag(
     ClickableText(
         text = userName,
         onClick = { nav(route) },
-        style = LocalTextStyle.current.copy(color = MaterialTheme.colors.primary)
+        style = LocalTextStyle.current.copy(color = MaterialTheme.colorScheme.primary)
     )
 }

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

@@ -1,19 +1,22 @@
 package com.vitorpamplona.amethyst.ui.components
 
-import android.content.Intent
-import android.net.Uri
-import android.widget.Toast
 import androidx.compose.animation.Crossfade
 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.*
+import androidx.compose.material3.LocalTextStyle
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.text.style.TextDirection
-import androidx.core.content.ContextCompat
 import com.vitorpamplona.amethyst.R
+import com.vitorpamplona.amethyst.ui.note.ErrorMessageDialog
+import com.vitorpamplona.amethyst.ui.note.payViaIntent
 import com.vitorpamplona.quartz.encoders.LnWithdrawalUtil
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
@@ -43,29 +46,28 @@ fun MayBeWithdrawal(lnurlWord: String) {
 @Composable
 fun ClickableWithdrawal(withdrawalString: String) {
     val context = LocalContext.current
-    val scope = rememberCoroutineScope()
 
     val withdraw = remember(withdrawalString) {
         AnnotatedString("$withdrawalString ")
     }
 
+    var showErrorMessageDialog by remember { mutableStateOf<String?>(null) }
+
+    if (showErrorMessageDialog != null) {
+        ErrorMessageDialog(
+            title = context.getString(R.string.error_dialog_pay_withdraw_error),
+            textContent = showErrorMessageDialog ?: "",
+            onDismiss = { showErrorMessageDialog = null }
+        )
+    }
+
     ClickableText(
         text = withdraw,
         onClick = {
-            try {
-                val intent = Intent(Intent.ACTION_VIEW, Uri.parse("lightning:$withdrawalString"))
-                intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
-                ContextCompat.startActivity(context, intent, null)
-            } catch (e: Exception) {
-                scope.launch {
-                    Toast.makeText(
-                        context,
-                        context.getString(R.string.lightning_wallets_not_found),
-                        Toast.LENGTH_LONG
-                    ).show()
-                }
+            payViaIntent(withdrawalString, context) {
+                showErrorMessageDialog = it
             }
         },
-        style = LocalTextStyle.current.copy(color = MaterialTheme.colors.primary)
+        style = LocalTextStyle.current.copy(color = MaterialTheme.colorScheme.primary)
     )
 }

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

@@ -7,10 +7,10 @@ import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
-import androidx.compose.material.Button
-import androidx.compose.material.ButtonDefaults
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.Text
+import androidx.compose.material3.Button
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.MutableState
 import androidx.compose.runtime.derivedStateOf
@@ -31,6 +31,7 @@ import com.vitorpamplona.amethyst.ui.theme.secondaryButtonBackground
 import com.vitorpamplona.quartz.events.ImmutableListOfLists
 
 const val SHORT_TEXT_LENGTH = 350
+const val SHORTEN_AFTER_LINES = 10
 
 @Composable
 fun ExpandableRichTextViewer(
@@ -45,11 +46,25 @@ fun ExpandableRichTextViewer(
     var showFullText by remember { mutableStateOf(false) }
 
     val whereToCut = remember(content) {
-        // Cuts the text in the first space after 350
+        // Cuts the text in the first space or new line after SHORT_TEXT_LENGTH characters
         val firstSpaceAfterCut = content.indexOf(' ', SHORT_TEXT_LENGTH).let { if (it < 0) content.length else it }
         val firstNewLineAfterCut = content.indexOf('\n', SHORT_TEXT_LENGTH).let { if (it < 0) content.length else it }
 
-        minOf(firstSpaceAfterCut, firstNewLineAfterCut)
+        // or after SHORTEN_AFTER_LINES lines
+        val numberOfLines = content.count { it == '\n' }
+
+        var charactersInLines = minOf(firstSpaceAfterCut, firstNewLineAfterCut)
+
+        if (numberOfLines > SHORTEN_AFTER_LINES) {
+            val shortContent = content.lines().take(SHORTEN_AFTER_LINES)
+            charactersInLines = 0
+            for (line in shortContent) {
+                // +1 because new line character is omitted from .lines
+                charactersInLines += (line.length + 1)
+            }
+        }
+
+        minOf(firstSpaceAfterCut, firstNewLineAfterCut, charactersInLines)
     }
 
     val text by remember(content) {
@@ -82,7 +97,7 @@ fun ExpandableRichTextViewer(
                     .fillMaxWidth()
                     .background(getGradient(backgroundColor))
             ) {
-                ShowMoreButton() {
+                ShowMoreButton {
                     showFullText = !showFullText
                 }
             }
@@ -97,7 +112,7 @@ fun ShowMoreButton(onClick: () -> Unit) {
         onClick = onClick,
         shape = ButtonBorder,
         colors = ButtonDefaults.buttonColors(
-            backgroundColor = MaterialTheme.colors.secondaryButtonBackground
+            containerColor = MaterialTheme.colorScheme.secondaryButtonBackground
         ),
         contentPadding = PaddingValues(vertical = 6.dp, horizontal = 16.dp)
     ) {

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

@@ -1,8 +1,5 @@
 package com.vitorpamplona.amethyst.ui.components
 
-import android.content.Intent
-import android.net.Uri
-import android.widget.Toast
 import androidx.compose.animation.Crossfade
 import androidx.compose.foundation.border
 import androidx.compose.foundation.layout.Column
@@ -10,8 +7,19 @@ import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
-import androidx.compose.material.*
-import androidx.compose.runtime.*
+import androidx.compose.material3.Button
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.Divider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.LocalTextStyle
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
@@ -23,8 +31,9 @@ import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextDirection
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
-import androidx.core.content.ContextCompat.startActivity
 import com.vitorpamplona.amethyst.R
+import com.vitorpamplona.amethyst.ui.note.ErrorMessageDialog
+import com.vitorpamplona.amethyst.ui.note.payViaIntent
 import com.vitorpamplona.amethyst.ui.theme.QuoteBorder
 import com.vitorpamplona.amethyst.ui.theme.subtleBorder
 import com.vitorpamplona.quartz.encoders.LnInvoiceUtil
@@ -67,14 +76,23 @@ fun MayBeInvoicePreview(lnbcWord: String) {
 @Composable
 fun InvoicePreview(lnInvoice: String, amount: String?) {
     val context = LocalContext.current
-    val scope = rememberCoroutineScope()
+
+    var showErrorMessageDialog by remember { mutableStateOf<String?>(null) }
+
+    if (showErrorMessageDialog != null) {
+        ErrorMessageDialog(
+            title = context.getString(R.string.error_dialog_pay_invoice_error),
+            textContent = showErrorMessageDialog ?: "",
+            onDismiss = { showErrorMessageDialog = null }
+        )
+    }
 
     Column(
         modifier = Modifier
             .fillMaxWidth()
             .padding(start = 30.dp, end = 30.dp)
             .clip(shape = QuoteBorder)
-            .border(1.dp, MaterialTheme.colors.subtleBorder, QuoteBorder)
+            .border(1.dp, MaterialTheme.colorScheme.subtleBorder, QuoteBorder)
     ) {
         Column(
             modifier = Modifier
@@ -120,23 +138,13 @@ fun InvoicePreview(lnInvoice: String, amount: String?) {
                     .fillMaxWidth()
                     .padding(vertical = 10.dp),
                 onClick = {
-                    try {
-                        val intent = Intent(Intent.ACTION_VIEW, Uri.parse("lightning:$lnInvoice"))
-                        intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
-                        startActivity(context, intent, null)
-                    } catch (e: Exception) {
-                        scope.launch {
-                            Toast.makeText(
-                                context,
-                                context.getString(R.string.lightning_wallets_not_found),
-                                Toast.LENGTH_LONG
-                            ).show()
-                        }
+                    payViaIntent(lnInvoice, context) {
+                        showErrorMessageDialog = it
                     }
                 },
                 shape = QuoteBorder,
                 colors = ButtonDefaults.buttonColors(
-                    backgroundColor = MaterialTheme.colors.primary
+                    containerColor = MaterialTheme.colorScheme.primary
                 )
             ) {
                 Text(text = stringResource(R.string.pay), color = Color.White, fontSize = 20.sp)

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

@@ -1,6 +1,5 @@
 package com.vitorpamplona.amethyst.ui.components
 
-import android.widget.Toast
 import androidx.compose.foundation.border
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
@@ -8,13 +7,13 @@ import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.text.KeyboardOptions
-import androidx.compose.material.Button
-import androidx.compose.material.ButtonDefaults
-import androidx.compose.material.Divider
-import androidx.compose.material.Icon
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.OutlinedTextField
-import androidx.compose.material.Text
+import androidx.compose.material3.Button
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.Divider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -50,21 +49,22 @@ fun InvoiceRequestCard(
     titleText: String? = null,
     buttonText: String? = null,
     onSuccess: (String) -> Unit,
-    onClose: () -> Unit
+    onClose: () -> Unit,
+    onError: (String, String) -> Unit
 ) {
     Column(
         modifier = Modifier
             .fillMaxWidth()
             .padding(start = 30.dp, end = 30.dp)
             .clip(shape = QuoteBorder)
-            .border(1.dp, MaterialTheme.colors.subtleBorder, QuoteBorder)
+            .border(1.dp, MaterialTheme.colorScheme.subtleBorder, QuoteBorder)
     ) {
         Column(
             modifier = Modifier
                 .fillMaxWidth()
                 .padding(30.dp)
         ) {
-            InvoiceRequest(lud16, toUserPubKeyHex, account, titleText, buttonText, onSuccess, onClose)
+            InvoiceRequest(lud16, toUserPubKeyHex, account, titleText, buttonText, onSuccess, onClose, onError)
         }
     }
 }
@@ -77,7 +77,8 @@ fun InvoiceRequest(
     titleText: String? = null,
     buttonText: String? = null,
     onSuccess: (String) -> Unit,
-    onClose: () -> Unit
+    onClose: () -> Unit,
+    onError: (String, String) -> Unit
 ) {
     val context = LocalContext.current
     val scope = rememberCoroutineScope()
@@ -116,7 +117,7 @@ fun InvoiceRequest(
         placeholder = {
             Text(
                 text = stringResource(R.string.thank_you_so_much),
-                color = MaterialTheme.colors.placeholderText
+                color = MaterialTheme.colorScheme.placeholderText
             )
         },
         keyboardOptions = KeyboardOptions.Default.copy(
@@ -141,7 +142,7 @@ fun InvoiceRequest(
         placeholder = {
             Text(
                 text = "1000",
-                color = MaterialTheme.colors.placeholderText
+                color = MaterialTheme.colorScheme.placeholderText
             )
         },
         keyboardOptions = KeyboardOptions.Default.copy(
@@ -162,20 +163,16 @@ fun InvoiceRequest(
                     message,
                     zapRequest?.toJson(),
                     onSuccess = onSuccess,
-                    onError = {
-                        scope.launch {
-                            Toast.makeText(context, it, Toast.LENGTH_SHORT).show()
-                            onClose()
-                        }
-                    },
+                    onError = onError,
                     onProgress = {
-                    }
+                    },
+                    context = context
                 )
             }
         },
         shape = QuoteBorder,
         colors = ButtonDefaults.buttonColors(
-            backgroundColor = MaterialTheme.colors.primary
+            containerColor = MaterialTheme.colorScheme.primary
         )
     ) {
         Text(text = buttonText ?: stringResource(R.string.send_sats), color = Color.White, fontSize = 20.sp)

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

@@ -0,0 +1,154 @@
+package com.vitorpamplona.amethyst.ui.components
+
+import android.util.Log
+import android.util.Patterns
+import com.vitorpamplona.amethyst.model.LocalCache
+import com.vitorpamplona.amethyst.service.checkNotInMainThread
+import com.vitorpamplona.amethyst.service.startsWithNIP19Scheme
+import com.vitorpamplona.quartz.encoders.Nip19
+import com.vitorpamplona.quartz.events.ImmutableListOfLists
+
+class MarkdownParser {
+    private fun getDisplayNameAndNIP19FromTag(tag: String, tags: ImmutableListOfLists<String>): Pair<String, String>? {
+        val matcher = tagIndex.matcher(tag)
+        val (index, suffix) = try {
+            matcher.find()
+            Pair(matcher.group(1)?.toInt(), matcher.group(2) ?: "")
+        } catch (e: Exception) {
+            Log.w("Tag Parser", "Couldn't link tag $tag", e)
+            Pair(null, null)
+        }
+
+        if (index != null && index >= 0 && index < tags.lists.size) {
+            val tag = tags.lists[index]
+
+            if (tag.size > 1) {
+                if (tag[0] == "p") {
+                    LocalCache.checkGetOrCreateUser(tag[1])?.let {
+                        return Pair(it.toBestDisplayName(), it.pubkeyNpub())
+                    }
+                } else if (tag[0] == "e" || tag[0] == "a") {
+                    LocalCache.checkGetOrCreateNote(tag[1])?.let {
+                        return Pair(it.idDisplayNote(), it.toNEvent())
+                    }
+                }
+            }
+        }
+
+        return null
+    }
+
+    private fun getDisplayNameFromNip19(nip19: Nip19.Return): Pair<String, String>? {
+        if (nip19.type == Nip19.Type.USER) {
+            LocalCache.users[nip19.hex]?.let {
+                return Pair(it.toBestDisplayName(), it.pubkeyNpub())
+            }
+        } else if (nip19.type == Nip19.Type.NOTE) {
+            LocalCache.notes[nip19.hex]?.let {
+                return Pair(it.idDisplayNote(), it.toNEvent())
+            }
+        } else if (nip19.type == Nip19.Type.ADDRESS) {
+            LocalCache.addressables[nip19.hex]?.let {
+                return Pair(it.idDisplayNote(), it.toNEvent())
+            }
+        } else if (nip19.type == Nip19.Type.EVENT) {
+            LocalCache.notes[nip19.hex]?.let {
+                return Pair(it.idDisplayNote(), it.toNEvent())
+            }
+        }
+
+        return null
+    }
+
+    fun returnNIP19References(content: String, tags: ImmutableListOfLists<String>?): List<Nip19.Return> {
+        checkNotInMainThread()
+
+        val listOfReferences = mutableListOf<Nip19.Return>()
+        content.split('\n').forEach { paragraph ->
+            paragraph.split(' ').forEach { word: String ->
+                if (startsWithNIP19Scheme(word)) {
+                    val parsedNip19 = Nip19.uriToRoute(word)
+                    parsedNip19?.let {
+                        listOfReferences.add(it)
+                    }
+                }
+            }
+        }
+
+        tags?.lists?.forEach {
+            if (it[0] == "p" && it.size > 1) {
+                listOfReferences.add(Nip19.Return(Nip19.Type.USER, it[1], null, null, null, ""))
+            } else if (it[0] == "e" && it.size > 1) {
+                listOfReferences.add(Nip19.Return(Nip19.Type.NOTE, it[1], null, null, null, ""))
+            } else if (it[0] == "a" && it.size > 1) {
+                listOfReferences.add(Nip19.Return(Nip19.Type.ADDRESS, it[1], null, null, null, ""))
+            }
+        }
+
+        return listOfReferences
+    }
+
+    fun returnMarkdownWithSpecialContent(content: String, tags: ImmutableListOfLists<String>?): String {
+        var returnContent = ""
+        content.split('\n').forEach { paragraph ->
+            paragraph.split(' ').forEach { word: String ->
+                if (isValidURL(word)) {
+                    val removedParamsFromUrl = word.split("?")[0].lowercase()
+                    if (imageExtensions.any { removedParamsFromUrl.endsWith(it) }) {
+                        returnContent += "![]($word) "
+                    } else {
+                        returnContent += "[$word]($word) "
+                    }
+                } else if (Patterns.EMAIL_ADDRESS.matcher(word).matches()) {
+                    returnContent += "[$word](mailto:$word) "
+                } else if (Patterns.PHONE.matcher(word).matches() && word.length > 6) {
+                    returnContent += "[$word](tel:$word) "
+                } else if (startsWithNIP19Scheme(word)) {
+                    val parsedNip19 = Nip19.uriToRoute(word)
+                    returnContent += if (parsedNip19 !== null) {
+                        val pair = getDisplayNameFromNip19(parsedNip19)
+                        if (pair != null) {
+                            val (displayName, nip19) = pair
+                            "[$displayName](nostr:$nip19) "
+                        } else {
+                            "$word "
+                        }
+                    } else {
+                        "$word "
+                    }
+                } else if (word.startsWith("#")) {
+                    if (tagIndex.matcher(word).matches() && tags != null) {
+                        val pair = getDisplayNameAndNIP19FromTag(word, tags)
+                        if (pair != null) {
+                            returnContent += "[${pair.first}](nostr:${pair.second}) "
+                        } else {
+                            returnContent += "$word "
+                        }
+                    } else if (hashTagsPattern.matcher(word).matches()) {
+                        val hashtagMatcher = hashTagsPattern.matcher(word)
+
+                        val (myTag, mySuffix) = try {
+                            hashtagMatcher.find()
+                            Pair(hashtagMatcher.group(1), hashtagMatcher.group(2))
+                        } catch (e: Exception) {
+                            Log.e("Hashtag Parser", "Couldn't link hashtag $word", e)
+                            Pair(null, null)
+                        }
+
+                        if (myTag != null) {
+                            returnContent += "[#$myTag](nostr:Hashtag?id=$myTag)$mySuffix "
+                        } else {
+                            returnContent += "$word "
+                        }
+                    } else {
+                        returnContent += "$word "
+                    }
+                } else {
+                    returnContent += "$word "
+                }
+            }
+            returnContent += "\n"
+        }
+        return returnContent
+    }
+}

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

@@ -1,22 +1,31 @@
 package com.vitorpamplona.amethyst.ui.components
 
-import android.util.Log
-import android.util.Patterns
 import androidx.compose.animation.Crossfade
-import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.text.BasicText
 import androidx.compose.foundation.text.ClickableText
 import androidx.compose.foundation.text.InlineTextContent
 import androidx.compose.foundation.text.appendInlineContent
-import androidx.compose.material.Icon
-import androidx.compose.material.LocalContentAlpha
-import androidx.compose.material.LocalContentColor
-import androidx.compose.material.LocalTextStyle
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.ProvideTextStyle
-import androidx.compose.material.Text
-import androidx.compose.runtime.*
+import androidx.compose.material3.Icon
+import androidx.compose.material3.LocalContentColor
+import androidx.compose.material3.LocalTextStyle
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.ProvideTextStyle
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.MutableState
+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.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
@@ -25,16 +34,19 @@ import androidx.compose.ui.layout.SubcomposeLayout
 import androidx.compose.ui.platform.LocalLayoutDirection
 import androidx.compose.ui.platform.LocalUriHandler
 import androidx.compose.ui.res.painterResource
-import androidx.compose.ui.text.*
+import androidx.compose.ui.text.Placeholder
+import androidx.compose.ui.text.PlaceholderVerticalAlign
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.unit.Constraints
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.LayoutDirection
 import androidx.compose.ui.unit.em
 import com.halilibo.richtext.markdown.Markdown
 import com.halilibo.richtext.markdown.MarkdownParseOptions
-import com.halilibo.richtext.ui.material.MaterialRichText
+import com.halilibo.richtext.ui.material3.Material3RichText
 import com.vitorpamplona.amethyst.model.HashtagIcon
-import com.vitorpamplona.amethyst.model.LocalCache
 import com.vitorpamplona.amethyst.model.Note
 import com.vitorpamplona.amethyst.model.User
 import com.vitorpamplona.amethyst.model.checkForHashtagWithIcon
@@ -59,6 +71,7 @@ import com.vitorpamplona.amethyst.ui.note.LoadUser
 import com.vitorpamplona.amethyst.ui.note.NoteCompose
 import com.vitorpamplona.amethyst.ui.note.toShortenHex
 import com.vitorpamplona.amethyst.ui.screen.loggedIn.AccountViewModel
+import com.vitorpamplona.amethyst.ui.screen.loggedIn.LoadedBechLink
 import com.vitorpamplona.amethyst.ui.theme.Font17SP
 import com.vitorpamplona.amethyst.ui.theme.HalfVertPadding
 import com.vitorpamplona.amethyst.ui.theme.MarkdownTextStyle
@@ -113,7 +126,7 @@ fun RichTextViewer(
 ) {
     Column(modifier = modifier) {
         if (remember(content) { isMarkdown(content) }) {
-            RenderContentAsMarkdown(content, tags, nav)
+            RenderContentAsMarkdown(content, tags, accountViewModel, nav)
         } else {
             RenderRegular(content, tags, canPreview, backgroundColor, accountViewModel, nav)
         }
@@ -139,7 +152,7 @@ private fun RenderRegular(
     val textStyle = currentTextStyle.copy(
         lineHeight = 1.4.em,
         color = currentTextStyle.color.takeOrElse {
-            LocalContentColor.current.copy(alpha = LocalContentAlpha.current)
+            LocalContentColor.current
         }
     )
 
@@ -243,7 +256,7 @@ private fun RenderWordWithoutPreview(
         is PhoneSegment -> ClickablePhone(word.segmentText)
         is BechSegment -> BechLink(word.segmentText, false, backgroundColor, accountViewModel, nav)
         is HashTagSegment -> HashTag(word, nav)
-        is HashIndexUserSegment -> TagLink(word, nav)
+        is HashIndexUserSegment -> TagLink(word, accountViewModel, nav)
         is HashIndexEventSegment -> TagLink(word, false, backgroundColor, accountViewModel, nav)
         is SchemelessUrlSegment -> NoProtocolUrlRenderer(word)
         is RegularTextSegment -> NormalWord(word.segmentText, style)
@@ -270,7 +283,7 @@ private fun RenderWordWithPreview(
         is PhoneSegment -> ClickablePhone(word.segmentText)
         is BechSegment -> BechLink(word.segmentText, true, backgroundColor, accountViewModel, nav)
         is HashTagSegment -> HashTag(word, nav)
-        is HashIndexUserSegment -> TagLink(word, nav)
+        is HashIndexUserSegment -> TagLink(word, accountViewModel, nav)
         is HashIndexEventSegment -> TagLink(word, true, backgroundColor, accountViewModel, nav)
         is SchemelessUrlSegment -> NoProtocolUrlRenderer(word)
         is RegularTextSegment -> NormalWord(word.segmentText, style)
@@ -320,7 +333,7 @@ fun RenderCustomEmoji(word: String, state: RichTextViewerState) {
 }
 
 @Composable
-private fun RenderContentAsMarkdown(content: String, tags: ImmutableListOfLists<String>?, nav: (String) -> Unit) {
+private fun RenderContentAsMarkdown(content: String, tags: ImmutableListOfLists<String>?, accountViewModel: AccountViewModel, nav: (String) -> Unit) {
     val uri = LocalUriHandler.current
     val onClick = remember {
         { link: String ->
@@ -335,10 +348,10 @@ private fun RenderContentAsMarkdown(content: String, tags: ImmutableListOfLists<
     }
 
     ProvideTextStyle(MarkdownTextStyle) {
-        MaterialRichText(
-            style = MaterialTheme.colors.markdownStyle
+        Material3RichText(
+            style = MaterialTheme.colorScheme.markdownStyle
         ) {
-            RefreshableContent(content, tags) {
+            RefreshableContent(content, tags, accountViewModel) {
                 Markdown(
                     content = it,
                     markdownParseOptions = MarkdownParseOptions.Default,
@@ -350,13 +363,14 @@ private fun RenderContentAsMarkdown(content: String, tags: ImmutableListOfLists<
 }
 
 @Composable
-private fun RefreshableContent(content: String, tags: ImmutableListOfLists<String>?, onCompose: @Composable (String) -> Unit) {
+private fun RefreshableContent(content: String, tags: ImmutableListOfLists<String>?, accountViewModel: AccountViewModel, onCompose: @Composable (String) -> Unit) {
     var markdownWithSpecialContent by remember(content) { mutableStateOf<String?>(content) }
 
-    ObserverAllNIP19References(content, tags) {
-        val newMarkdownWithSpecialContent = returnMarkdownWithSpecialContent(content, tags)
-        if (markdownWithSpecialContent != newMarkdownWithSpecialContent) {
-            markdownWithSpecialContent = newMarkdownWithSpecialContent
+    ObserverAllNIP19References(content, tags, accountViewModel) {
+        accountViewModel.returnMarkdownWithSpecialContent(content, tags) { newMarkdownWithSpecialContent ->
+            if (markdownWithSpecialContent != newMarkdownWithSpecialContent) {
+                markdownWithSpecialContent = newMarkdownWithSpecialContent
+            }
         }
     }
 
@@ -366,47 +380,47 @@ private fun RefreshableContent(content: String, tags: ImmutableListOfLists<Strin
 }
 
 @Composable
-fun ObserverAllNIP19References(content: String, tags: ImmutableListOfLists<String>?, onRefresh: () -> Unit) {
+fun ObserverAllNIP19References(content: String, tags: ImmutableListOfLists<String>?, accountViewModel: AccountViewModel, onRefresh: () -> Unit) {
     var nip19References by remember(content) { mutableStateOf<List<Nip19.Return>>(emptyList()) }
 
     LaunchedEffect(key1 = content) {
-        launch(Dispatchers.IO) {
-            nip19References = returnNIP19References(content, tags)
+        accountViewModel.returnNIP19References(content, tags) {
+            nip19References = it
             onRefresh()
         }
     }
 
     nip19References.forEach {
-        ObserveNIP19(it, onRefresh)
+        ObserveNIP19(it, accountViewModel, onRefresh)
     }
 }
 
 @Composable
 fun ObserveNIP19(
     it: Nip19.Return,
+    accountViewModel: AccountViewModel,
     onRefresh: () -> Unit
 ) {
     if (it.type == Nip19.Type.NOTE || it.type == Nip19.Type.EVENT || it.type == Nip19.Type.ADDRESS) {
-        ObserveNIP19Event(it, onRefresh)
+        ObserveNIP19Event(it, accountViewModel, onRefresh)
     } else if (it.type == Nip19.Type.USER) {
-        ObserveNIP19User(it, onRefresh)
+        ObserveNIP19User(it, accountViewModel, onRefresh)
     }
 }
 
 @Composable
 private fun ObserveNIP19Event(
     it: Nip19.Return,
+    accountViewModel: AccountViewModel,
     onRefresh: () -> Unit
 ) {
-    var baseNote by remember(it) { mutableStateOf<Note?>(LocalCache.getNoteIfExists(it.hex)) }
+    var baseNote by remember(it) { mutableStateOf<Note?>(accountViewModel.getNoteIfExists(it.hex)) }
 
     if (baseNote == null) {
         LaunchedEffect(key1 = it.hex) {
-            launch(Dispatchers.IO) {
-                if (it.type == Nip19.Type.NOTE || it.type == Nip19.Type.EVENT || it.type == Nip19.Type.ADDRESS) {
-                    LocalCache.checkGetOrCreateNote(it.hex)?.let { note ->
-                        launch(Dispatchers.Main) { baseNote = note }
-                    }
+            if (it.type == Nip19.Type.NOTE || it.type == Nip19.Type.EVENT || it.type == Nip19.Type.ADDRESS) {
+                accountViewModel.checkGetOrCreateNote(it.hex) { note ->
+                    launch(Dispatchers.Main) { baseNote = note }
                 }
             }
         }
@@ -423,9 +437,7 @@ fun ObserveNote(note: Note, onRefresh: () -> Unit) {
 
     LaunchedEffect(key1 = loadedNoteId) {
         if (loadedNoteId != null) {
-            launch(Dispatchers.IO) {
-                onRefresh()
-            }
+            onRefresh()
         }
     }
 }
@@ -433,17 +445,16 @@ fun ObserveNote(note: Note, onRefresh: () -> Unit) {
 @Composable
 private fun ObserveNIP19User(
     it: Nip19.Return,
+    accountViewModel: AccountViewModel,
     onRefresh: () -> Unit
 ) {
-    var baseUser by remember(it) { mutableStateOf<User?>(LocalCache.getUserIfExists(it.hex)) }
+    var baseUser by remember(it) { mutableStateOf<User?>(accountViewModel.getUserIfExists(it.hex)) }
 
     if (baseUser == null) {
         LaunchedEffect(key1 = it.hex) {
-            launch(Dispatchers.IO) {
-                if (it.type == Nip19.Type.USER) {
-                    LocalCache.checkGetOrCreateUser(it.hex)?.let { user ->
-                        launch(Dispatchers.Main) { baseUser = user }
-                    }
+            if (it.type == Nip19.Type.USER) {
+                accountViewModel.checkGetOrCreateUser(it.hex)?.let { user ->
+                    launch(Dispatchers.Main) { baseUser = user }
                 }
             }
         }
@@ -460,184 +471,19 @@ private fun ObserveUser(user: User, onRefresh: () -> Unit) {
 
     LaunchedEffect(key1 = loadedUserMetaId) {
         if (loadedUserMetaId != null) {
-            launch(Dispatchers.IO) {
-                onRefresh()
-            }
+            onRefresh()
         }
     }
 }
 
-private fun getDisplayNameAndNIP19FromTag(tag: String, tags: ImmutableListOfLists<String>): Pair<String, String>? {
-    val matcher = tagIndex.matcher(tag)
-    val (index, suffix) = try {
-        matcher.find()
-        Pair(matcher.group(1)?.toInt(), matcher.group(2) ?: "")
-    } catch (e: Exception) {
-        Log.w("Tag Parser", "Couldn't link tag $tag", e)
-        Pair(null, null)
-    }
-
-    if (index != null && index >= 0 && index < tags.lists.size) {
-        val tag = tags.lists[index]
-
-        if (tag.size > 1) {
-            if (tag[0] == "p") {
-                LocalCache.checkGetOrCreateUser(tag[1])?.let {
-                    return Pair(it.toBestDisplayName(), it.pubkeyNpub())
-                }
-            } else if (tag[0] == "e" || tag[0] == "a") {
-                LocalCache.checkGetOrCreateNote(tag[1])?.let {
-                    return Pair(it.idDisplayNote(), it.toNEvent())
-                }
-            }
-        }
-    }
-
-    return null
-}
-
-private fun getDisplayNameFromNip19(nip19: Nip19.Return): Pair<String, String>? {
-    if (nip19.type == Nip19.Type.USER) {
-        LocalCache.users[nip19.hex]?.let {
-            return Pair(it.toBestDisplayName(), it.pubkeyNpub())
-        }
-    } else if (nip19.type == Nip19.Type.NOTE) {
-        LocalCache.notes[nip19.hex]?.let {
-            return Pair(it.idDisplayNote(), it.toNEvent())
-        }
-    } else if (nip19.type == Nip19.Type.ADDRESS) {
-        LocalCache.addressables[nip19.hex]?.let {
-            return Pair(it.idDisplayNote(), it.toNEvent())
-        }
-    } else if (nip19.type == Nip19.Type.EVENT) {
-        LocalCache.notes[nip19.hex]?.let {
-            return Pair(it.idDisplayNote(), it.toNEvent())
-        }
-    }
-
-    return null
-}
-
-private fun returnNIP19References(content: String, tags: ImmutableListOfLists<String>?): List<Nip19.Return> {
-    val listOfReferences = mutableListOf<Nip19.Return>()
-    content.split('\n').forEach { paragraph ->
-        paragraph.split(' ').forEach { word: String ->
-            if (startsWithNIP19Scheme(word)) {
-                val parsedNip19 = Nip19.uriToRoute(word)
-                parsedNip19?.let {
-                    listOfReferences.add(it)
-                }
-            }
-        }
-    }
-
-    tags?.lists?.forEach {
-        if (it[0] == "p" && it.size > 1) {
-            listOfReferences.add(Nip19.Return(Nip19.Type.USER, it[1], null, null, null, ""))
-        } else if (it[0] == "e" && it.size > 1) {
-            listOfReferences.add(Nip19.Return(Nip19.Type.NOTE, it[1], null, null, null, ""))
-        } else if (it[0] == "a" && it.size > 1) {
-            listOfReferences.add(Nip19.Return(Nip19.Type.ADDRESS, it[1], null, null, null, ""))
-        }
-    }
-
-    return listOfReferences
-}
-
-private fun returnMarkdownWithSpecialContent(content: String, tags: ImmutableListOfLists<String>?): String {
-    var returnContent = ""
-    content.split('\n').forEach { paragraph ->
-        paragraph.split(' ').forEach { word: String ->
-            if (isValidURL(word)) {
-                val removedParamsFromUrl = word.split("?")[0].lowercase()
-                if (imageExtensions.any { removedParamsFromUrl.endsWith(it) }) {
-                    returnContent += "![]($word) "
-                } else {
-                    returnContent += "[$word]($word) "
-                }
-            } else if (Patterns.EMAIL_ADDRESS.matcher(word).matches()) {
-                returnContent += "[$word](mailto:$word) "
-            } else if (Patterns.PHONE.matcher(word).matches() && word.length > 6) {
-                returnContent += "[$word](tel:$word) "
-            } else if (startsWithNIP19Scheme(word)) {
-                val parsedNip19 = Nip19.uriToRoute(word)
-                returnContent += if (parsedNip19 !== null) {
-                    val pair = getDisplayNameFromNip19(parsedNip19)
-                    if (pair != null) {
-                        val (displayName, nip19) = pair
-                        "[$displayName](nostr:$nip19) "
-                    } else {
-                        "$word "
-                    }
-                } else {
-                    "$word "
-                }
-            } else if (word.startsWith("#")) {
-                if (tagIndex.matcher(word).matches() && tags != null) {
-                    val pair = getDisplayNameAndNIP19FromTag(word, tags)
-                    if (pair != null) {
-                        returnContent += "[${pair.first}](nostr:${pair.second}) "
-                    } else {
-                        returnContent += "$word "
-                    }
-                } else if (hashTagsPattern.matcher(word).matches()) {
-                    val hashtagMatcher = hashTagsPattern.matcher(word)
-
-                    val (myTag, mySuffix) = try {
-                        hashtagMatcher.find()
-                        Pair(hashtagMatcher.group(1), hashtagMatcher.group(2))
-                    } catch (e: Exception) {
-                        Log.e("Hashtag Parser", "Couldn't link hashtag $word", e)
-                        Pair(null, null)
-                    }
-
-                    if (myTag != null) {
-                        returnContent += "[#$myTag](nostr:Hashtag?id=$myTag)$mySuffix "
-                    } else {
-                        returnContent += "$word "
-                    }
-                } else {
-                    returnContent += "$word "
-                }
-            } else {
-                returnContent += "$word "
-            }
-        }
-        returnContent += "\n"
-    }
-    return returnContent
-}
-
-fun startsWithNIP19Scheme(word: String): Boolean {
-    val cleaned = word.lowercase().removePrefix("@").removePrefix("nostr:").removePrefix("@")
-
-    return listOf("npub1", "naddr1", "note1", "nprofile1", "nevent1").any { cleaned.startsWith(it) }
-}
-
-@Immutable
-data class LoadedBechLink(val baseNote: Note?, val nip19: Nip19.Return)
-
 @Composable
 fun BechLink(word: String, canPreview: Boolean, backgroundColor: MutableState<Color>, accountViewModel: AccountViewModel, nav: (String) -> Unit) {
     var loadedLink by remember { mutableStateOf<LoadedBechLink?>(null) }
 
     if (loadedLink == null) {
         LaunchedEffect(key1 = word) {
-            launch(Dispatchers.IO) {
-                Nip19.uriToRoute(word)?.let {
-                    var returningNote: Note? = null
-                    if (it.type == Nip19.Type.NOTE || it.type == Nip19.Type.EVENT || it.type == Nip19.Type.ADDRESS) {
-                        LocalCache.checkGetOrCreateNote(it.hex)?.let { note ->
-                            returningNote = note
-                        }
-                    }
-
-                    val newLink = LoadedBechLink(returningNote, it)
-
-                    launch(Dispatchers.Main) {
-                        loadedLink = newLink
-                    }
-                }
+            accountViewModel.parseNIP19(word) {
+                loadedLink = it
             }
         }
     }
@@ -654,10 +500,10 @@ fun BechLink(word: String, canPreview: Boolean, backgroundColor: MutableState<Co
         }
     } else if (loadedLink?.nip19 != null) {
         Row() {
-            ClickableRoute(loadedLink?.nip19!!, nav)
+            ClickableRoute(loadedLink?.nip19!!, accountViewModel, nav)
         }
     } else {
-        val text = remember {
+        val text = remember(word) {
             if (word.length > 16) {
                 word.replaceRange(8, word.length - 8, ":")
             } else {
@@ -680,7 +526,7 @@ private fun DisplayFullNote(
     NoteCompose(
         baseNote = it,
         accountViewModel = accountViewModel,
-        modifier = MaterialTheme.colors.replyModifier,
+        modifier = MaterialTheme.colorScheme.replyModifier,
         parentBackgroundColor = backgroundColor,
         isQuotedNote = true,
         nav = nav
@@ -709,12 +555,12 @@ private fun RenderHashtag(
     segment: HashTagSegment,
     nav: (String) -> Unit
 ) {
-    val primary = MaterialTheme.colors.primary
+    val primary = MaterialTheme.colorScheme.primary
     val hashtagIcon = remember(segment.hashtag) { checkForHashtagWithIcon(segment.hashtag, primary) }
     ClickableText(
         text = buildAnnotatedString {
             withStyle(
-                LocalTextStyle.current.copy(color = MaterialTheme.colors.primary).toSpanStyle()
+                LocalTextStyle.current.copy(color = MaterialTheme.colorScheme.primary).toSpanStyle()
             ) {
                 append("#${segment.hashtag}")
             }
@@ -726,7 +572,7 @@ private fun RenderHashtag(
         val myId = "inlineContent"
         val emptytext = buildAnnotatedString {
             withStyle(
-                LocalTextStyle.current.copy(color = MaterialTheme.colors.primary).toSpanStyle()
+                LocalTextStyle.current.copy(color = MaterialTheme.colorScheme.primary).toSpanStyle()
             ) {
                 append("")
                 appendInlineContent(myId, "[icon]")
@@ -763,8 +609,8 @@ private fun InlineIcon(hashtagIcon: HashtagIcon) =
     }
 
 @Composable
-fun TagLink(word: HashIndexUserSegment, nav: (String) -> Unit) {
-    LoadUser(baseUserHex = word.hex) {
+fun TagLink(word: HashIndexUserSegment, accountViewModel: AccountViewModel, nav: (String) -> Unit) {
+    LoadUser(baseUserHex = word.hex, accountViewModel) {
         if (it == null) {
             Text(text = word.segmentText)
         } else {
@@ -776,15 +622,15 @@ fun TagLink(word: HashIndexUserSegment, nav: (String) -> Unit) {
 }
 
 @Composable
-fun LoadNote(baseNoteHex: String, content: @Composable (Note?) -> Unit) {
+fun LoadNote(baseNoteHex: String, accountViewModel: AccountViewModel, content: @Composable (Note?) -> Unit) {
     var note by remember(baseNoteHex) {
-        mutableStateOf<Note?>(LocalCache.getNoteIfExists(baseNoteHex))
+        mutableStateOf<Note?>(accountViewModel.getNoteIfExists(baseNoteHex))
     }
 
     if (note == null) {
         LaunchedEffect(key1 = baseNoteHex) {
-            launch(Dispatchers.IO) {
-                note = LocalCache.checkGetOrCreateNote(baseNoteHex)
+            accountViewModel.checkGetOrCreateNote(baseNoteHex) {
+                note = it
             }
         }
     }
@@ -794,7 +640,7 @@ fun LoadNote(baseNoteHex: String, content: @Composable (Note?) -> Unit) {
 
 @Composable
 fun TagLink(word: HashIndexEventSegment, canPreview: Boolean, backgroundColor: MutableState<Color>, accountViewModel: AccountViewModel, nav: (String) -> Unit) {
-    LoadNote(baseNoteHex = word.hex) {
+    LoadNote(baseNoteHex = word.hex, accountViewModel) {
         if (it == null) {
             Text(text = remember { word.segmentText.toShortenHex() })
         } else {
@@ -825,7 +671,7 @@ private fun DisplayNoteFromTag(
         NoteCompose(
             baseNote = baseNote,
             accountViewModel = accountViewModel,
-            modifier = MaterialTheme.colors.innerPostModifier,
+            modifier = MaterialTheme.colorScheme.innerPostModifier,
             parentBackgroundColor = backgroundColor,
             isQuotedNote = true,
             nav = nav

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

@@ -1,7 +1,13 @@
 package com.vitorpamplona.amethyst.ui.components
 
+import android.content.Context
+import android.graphics.BitmapFactory
+import android.net.Uri
 import androidx.compose.foundation.Image
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.derivedStateOf
+import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@@ -11,9 +17,19 @@ import androidx.compose.ui.graphics.FilterQuality
 import androidx.compose.ui.graphics.drawscope.DrawScope
 import androidx.compose.ui.layout.ContentScale
 import androidx.compose.ui.platform.LocalContext
+import androidx.core.graphics.drawable.toDrawable
+import coil.ImageLoader
 import coil.compose.AsyncImage
 import coil.compose.AsyncImagePainter
 import coil.compose.rememberAsyncImagePainter
+import coil.decode.DataSource
+import coil.fetch.DrawableResult
+import coil.fetch.FetchResult
+import coil.fetch.Fetcher
+import coil.request.ImageRequest
+import coil.request.Options
+import com.vitorpamplona.amethyst.service.checkNotInMainThread
+import java.util.Base64
 
 @Composable
 fun RobohashAsyncImage(
@@ -58,27 +74,49 @@ fun RobohashFallbackAsyncImage(
     contentScale: ContentScale = ContentScale.Fit,
     alpha: Float = DefaultAlpha,
     colorFilter: ColorFilter? = null,
-    filterQuality: FilterQuality = DrawScope.DefaultFilterQuality
+    filterQuality: FilterQuality = DrawScope.DefaultFilterQuality,
+    loadProfilePicture: Boolean
 ) {
     val context = LocalContext.current
     val painter = rememberAsyncImagePainter(
         model = Robohash.imageRequest(context, robot)
     )
 
-    if (model != null) {
-        AsyncImage(
-            model = model,
-            contentDescription = contentDescription,
-            modifier = modifier,
-            placeholder = painter,
-            fallback = painter,
-            error = painter,
-            alignment = alignment,
-            contentScale = contentScale,
-            alpha = alpha,
-            colorFilter = colorFilter,
-            filterQuality = filterQuality
-        )
+    if (model != null && loadProfilePicture) {
+        val isBase64 by remember {
+            derivedStateOf {
+                model.startsWith("data:image/jpeg;base64,")
+            }
+        }
+
+        if (isBase64) {
+            val painter = rememberAsyncImagePainter(
+                model = Base64Requester.imageRequest(context, model)
+            )
+
+            Image(
+                painter = painter,
+                contentDescription = null,
+                modifier = modifier,
+                alignment = alignment,
+                contentScale = contentScale,
+                colorFilter = colorFilter
+            )
+        } else {
+            AsyncImage(
+                model = model,
+                contentDescription = contentDescription,
+                modifier = modifier,
+                placeholder = painter,
+                fallback = painter,
+                error = painter,
+                alignment = alignment,
+                contentScale = contentScale,
+                alpha = alpha,
+                colorFilter = colorFilter,
+                filterQuality = filterQuality
+            )
+        }
     } else {
         Image(
             painter = painter,
@@ -101,7 +139,8 @@ fun RobohashAsyncImageProxy(
     contentScale: ContentScale = ContentScale.Fit,
     alpha: Float = DefaultAlpha,
     colorFilter: ColorFilter? = null,
-    filterQuality: FilterQuality = DrawScope.DefaultFilterQuality
+    filterQuality: FilterQuality = DrawScope.DefaultFilterQuality,
+    loadProfilePicture: Boolean
 ) {
     RobohashFallbackAsyncImage(
         robot = robot,
@@ -112,6 +151,49 @@ fun RobohashAsyncImageProxy(
         contentScale = contentScale,
         alpha = alpha,
         colorFilter = colorFilter,
-        filterQuality = filterQuality
+        filterQuality = filterQuality,
+        loadProfilePicture = loadProfilePicture
     )
 }
+
+object Base64Requester {
+    fun imageRequest(context: Context, message: String): ImageRequest {
+        return ImageRequest
+            .Builder(context)
+            .data(message)
+            .fetcherFactory(Base64Fetcher.Factory)
+            .build()
+    }
+}
+
+@Stable
+class Base64Fetcher(
+    private val options: Options,
+    private val data: Uri
+) : Fetcher {
+
+    override suspend fun fetch(): FetchResult {
+        checkNotInMainThread()
+
+        val base64String = data.toString().removePrefix("data:image/jpeg;base64,")
+
+        val byteArray = Base64.getDecoder().decode(base64String)
+        val bitmap = BitmapFactory.decodeByteArray(byteArray, 0, byteArray.size)
+
+        if (bitmap == null) {
+            throw Exception("Unable to load base64 $base64String")
+        }
+
+        return DrawableResult(
+            drawable = bitmap.toDrawable(options.context.resources),
+            isSampled = false,
+            dataSource = DataSource.MEMORY
+        )
+    }
+
+    object Factory : Fetcher.Factory<Uri> {
+        override fun create(data: Uri, options: Options, imageLoader: ImageLoader): Fetcher {
+            return Base64Fetcher(options, data)
+        }
+    }
+}

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

@@ -9,10 +9,10 @@ import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.text.selection.SelectionContainer
 import androidx.compose.foundation.verticalScroll
-import androidx.compose.material.Card
-import androidx.compose.material.Divider
-import androidx.compose.material.IconButton
-import androidx.compose.material.Text
+import androidx.compose.material3.Card
+import androidx.compose.material3.Divider
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier

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

@@ -11,14 +11,14 @@ import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.width
-import androidx.compose.material.Button
-import androidx.compose.material.ButtonDefaults
-import androidx.compose.material.Icon
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.Text
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Visibility
 import androidx.compose.material.icons.rounded.Warning
+import androidx.compose.material3.Button
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.livedata.observeAsState
@@ -104,7 +104,7 @@ fun ContentWarningNote(onDismiss: () -> Unit) {
                             modifier = Modifier
                                 .size(70.dp)
                                 .align(Alignment.BottomStart),
-                            tint = MaterialTheme.colors.onBackground
+                            tint = MaterialTheme.colorScheme.onBackground
                         )
                         Icon(
                             imageVector = Icons.Rounded.Warning,
@@ -112,7 +112,7 @@ fun ContentWarningNote(onDismiss: () -> Unit) {
                             modifier = Modifier
                                 .size(30.dp)
                                 .align(Alignment.TopEnd),
-                            tint = MaterialTheme.colors.onBackground
+                            tint = MaterialTheme.colorScheme.onBackground
                         )
                     }
                 }
@@ -141,7 +141,7 @@ fun ContentWarningNote(onDismiss: () -> Unit) {
                         shape = ButtonBorder,
                         colors = ButtonDefaults
                             .buttonColors(
-                                backgroundColor = MaterialTheme.colors.primary
+                                containerColor = MaterialTheme.colorScheme.primary
                             ),
                         contentPadding = PaddingValues(vertical = 6.dp, horizontal = 16.dp)
                     ) {

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

@@ -14,8 +14,8 @@ import androidx.compose.foundation.lazy.LazyRow
 import androidx.compose.foundation.pager.HorizontalPager
 import androidx.compose.foundation.pager.PagerState
 import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.Surface
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.ui.Alignment
@@ -66,8 +66,8 @@ fun DotsIndicator(
     modifier: Modifier = Modifier,
     totalDots: Int,
     selectedIndex: Int,
-    selectedColor: Color = MaterialTheme.colors.primary /* Color.Yellow */,
-    unSelectedColor: Color = MaterialTheme.colors.placeholderText /* Color.Gray */,
+    selectedColor: Color = MaterialTheme.colorScheme.primary /* Color.Yellow */,
+    unSelectedColor: Color = MaterialTheme.colorScheme.placeholderText /* Color.Gray */,
     dotSize: Dp
 ) {
     LazyRow(

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

@@ -0,0 +1,99 @@
+package com.vitorpamplona.amethyst.ui.components
+
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import kotlin.math.abs
+
+class SplitItem<T>(val key: T) {
+    var percentage by mutableStateOf(0f)
+}
+
+class Split<T>() {
+    var items: List<SplitItem<T>> by mutableStateOf(emptyList())
+
+    fun addItem(key: T): Int {
+        val wasEqualSplit = isEqualSplit()
+        val newItem = SplitItem(key)
+        items = items.plus(newItem)
+
+        if (wasEqualSplit) {
+            forceEqualSplit()
+        } else {
+            updatePercentage(items.lastIndex, equalSplit())
+        }
+
+        return items.lastIndex
+    }
+
+    fun equalSplit() = 1f / items.size
+
+    fun isEqualSplit(): Boolean {
+        val expectedPercentage = equalSplit()
+        return items.all { (it.percentage - expectedPercentage) < 0.01 }
+    }
+
+    fun forceEqualSplit() {
+        val correctPercentage = equalSplit()
+        items.forEach {
+            it.percentage = correctPercentage
+        }
+    }
+
+    fun updatePercentage(index: Int, percentage: Float) {
+        if (items.isEmpty()) return
+
+        val splitItem = items.getOrNull(index) ?: return
+
+        if (items.size == 1) {
+            splitItem.percentage = 1f
+        } else {
+            splitItem.percentage = percentage
+
+            println("Update ${items[index].key} to $percentage")
+
+            val othersMustShare = 1.0f - splitItem.percentage
+
+            val othersHave = items.sumOf {
+                if (it == splitItem) 0.0 else it.percentage.toDouble()
+            }.toFloat()
+
+            if (abs(othersHave - othersMustShare) < 0.01) return // nothing to do
+
+            println("Others Must Share $othersMustShare but have $othersHave")
+
+            bottomUpAdjustment(othersMustShare, othersHave, index)
+        }
+    }
+
+    private fun bottomUpAdjustment(othersMustShare: Float, othersHave: Float, exceptForIndex: Int) {
+        var needToRemove = othersHave - othersMustShare
+        if (needToRemove > 0) {
+            for (i in items.indices.reversed()) {
+                if (i == exceptForIndex) continue // do not update the current item
+
+                if (needToRemove < items[i].percentage) {
+                    val oldValue = items[i].percentage
+                    items[i].percentage -= needToRemove
+                    needToRemove = 0f
+                    println("- Updating ${items[i].key} from $oldValue to ${items[i].percentage - needToRemove}. $needToRemove left")
+                } else {
+                    val oldValue = items[i].percentage
+                    needToRemove -= items[i].percentage
+                    items[i].percentage = 0f
+                    println("- Updating ${items[i].key} from $oldValue to ${0}. $needToRemove left")
+                }
+
+                if (needToRemove < 0.01) {
+                    break
+                }
+            }
+        } else if (needToRemove < 0) {
+            if (items.lastIndex == exceptForIndex) {
+                items[items.lastIndex - 1].percentage += -needToRemove
+            } else {
+                items.last().percentage += -needToRemove
+            }
+        }
+    }
+}

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

@@ -14,12 +14,13 @@ import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.itemsIndexed
 import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material.Divider
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.OutlinedTextField
-import androidx.compose.material.Surface
-import androidx.compose.material.Text
+import androidx.compose.material3.Divider
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Immutable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
@@ -37,8 +38,7 @@ import kotlinx.collections.immutable.ImmutableList
 fun TextSpinner(
     label: String?,
     placeholder: String,
-    options: ImmutableList<String>,
-    explainers: ImmutableList<String>? = null,
+    options: ImmutableList<TitleExplainer>,
     onSelect: (Int) -> Unit,
     modifier: Modifier = Modifier
 ) {
@@ -74,8 +74,8 @@ fun TextSpinner(
 
     if (optionsShowing) {
         options.isNotEmpty().also {
-            SpinnerSelectionDialog(options = options, explainers = explainers, onDismiss = { optionsShowing = false }) {
-                currentText = options[it]
+            SpinnerSelectionDialog(options = options, onDismiss = { optionsShowing = false }) {
+                currentText = options[it].title
                 optionsShowing = false
                 onSelect(it)
             }
@@ -85,10 +85,40 @@ fun TextSpinner(
 
 @Composable
 fun SpinnerSelectionDialog(
-    options: ImmutableList<String>,
-    explainers: ImmutableList<String>?,
+    options: ImmutableList<TitleExplainer>,
     onDismiss: () -> Unit,
     onSelect: (Int) -> Unit
+) {
+    SpinnerSelectionDialog(
+        options = options,
+        onSelect = onSelect,
+        onDismiss = onDismiss
+    ) { item ->
+        Row(
+            horizontalArrangement = Arrangement.Center,
+            modifier = Modifier.fillMaxWidth()
+        ) {
+            Text(text = item.title, color = MaterialTheme.colorScheme.onSurface)
+        }
+        item.explainer?.let {
+            Spacer(modifier = Modifier.height(5.dp))
+            Row(
+                horizontalArrangement = Arrangement.Start,
+                modifier = Modifier
+                    .fillMaxWidth()
+            ) {
+                Text(text = it, color = Color.Gray, fontSize = Font14SP)
+            }
+        }
+    }
+}
+
+@Composable
+fun <T> SpinnerSelectionDialog(
+    options: ImmutableList<T>,
+    onSelect: (Int) -> Unit,
+    onDismiss: () -> Unit,
+    onRenderItem: @Composable (T) -> Unit
 ) {
     Dialog(onDismissRequest = onDismiss) {
         Surface(
@@ -106,23 +136,7 @@ fun SpinnerSelectionDialog(
                             }
                     ) {
                         Column() {
-                            Row(
-                                horizontalArrangement = Arrangement.Center,
-                                modifier = Modifier
-                                    .fillMaxWidth()
-                            ) {
-                                Text(text = item, color = MaterialTheme.colors.onSurface)
-                            }
-                            explainers?.getOrNull(index)?.let {
-                                Spacer(modifier = Modifier.height(5.dp))
-                                Row(
-                                    horizontalArrangement = Arrangement.Start,
-                                    modifier = Modifier
-                                        .fillMaxWidth()
-                                ) {
-                                    Text(text = it, color = Color.Gray, fontSize = Font14SP)
-                                }
-                            }
+                            onRenderItem(item)
                         }
                     }
                     if (index < options.lastIndex) {
@@ -133,3 +147,6 @@ fun SpinnerSelectionDialog(
         }
     }
 }
+
+@Immutable
+data class TitleExplainer(val title: String, val explainer: String? = null)

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

@@ -0,0 +1,11 @@
+package com.vitorpamplona.amethyst.ui.components
+
+import androidx.compose.runtime.Immutable
+
+@Immutable
+data class TranslationConfig(
+    val result: String?,
+    val sourceLang: String?,
+    val targetLang: String?,
+    val showOriginal: Boolean
+)

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

@@ -3,10 +3,10 @@ package com.vitorpamplona.amethyst.ui.components
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.Text
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
@@ -15,13 +15,15 @@ import androidx.compose.ui.layout.ContentScale
 import androidx.compose.ui.platform.LocalUriHandler
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextOverflow
-import androidx.compose.ui.unit.dp
 import coil.compose.AsyncImage
 import com.vitorpamplona.amethyst.R
 import com.vitorpamplona.amethyst.model.ConnectivityType
 import com.vitorpamplona.amethyst.service.connectivitystatus.ConnectivityStatus
 import com.vitorpamplona.amethyst.service.previews.UrlInfoItem
 import com.vitorpamplona.amethyst.ui.screen.loggedIn.AccountViewModel
+import com.vitorpamplona.amethyst.ui.theme.DoubleVertSpacer
+import com.vitorpamplona.amethyst.ui.theme.MaxWidthWithHorzPadding
+import com.vitorpamplona.amethyst.ui.theme.StdVertSpacer
 import com.vitorpamplona.amethyst.ui.theme.innerPostModifier
 
 @Composable
@@ -44,7 +46,7 @@ fun UrlPreviewCard(
         val uri = LocalUriHandler.current
 
         Row(
-            modifier = MaterialTheme.colors.innerPostModifier
+            modifier = MaterialTheme.colorScheme.innerPostModifier
                 .clickable {
                     runCatching { uri.openUri(url) }
                 }
@@ -57,12 +59,12 @@ fun UrlPreviewCard(
                     modifier = Modifier.fillMaxWidth()
                 )
 
+                Spacer(modifier = StdVertSpacer)
+
                 Text(
                     text = previewInfo.verifiedUrl?.host ?: previewInfo.url,
-                    style = MaterialTheme.typography.caption,
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(start = 10.dp, end = 10.dp, top = 10.dp),
+                    style = MaterialTheme.typography.bodySmall,
+                    modifier = MaxWidthWithHorzPadding,
                     color = Color.Gray,
                     maxLines = 1,
                     overflow = TextOverflow.Ellipsis
@@ -70,24 +72,22 @@ fun UrlPreviewCard(
 
                 Text(
                     text = previewInfo.title,
-                    style = MaterialTheme.typography.body2,
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(start = 10.dp, end = 10.dp),
+                    style = MaterialTheme.typography.bodyMedium,
+                    modifier = MaxWidthWithHorzPadding,
                     maxLines = 1,
                     overflow = TextOverflow.Ellipsis
                 )
 
                 Text(
                     text = previewInfo.description,
-                    style = MaterialTheme.typography.caption,
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(start = 10.dp, end = 10.dp, bottom = 10.dp),
+                    style = MaterialTheme.typography.bodySmall,
+                    modifier = MaxWidthWithHorzPadding,
                     color = Color.Gray,
                     maxLines = 3,
                     overflow = TextOverflow.Ellipsis
                 )
+
+                Spacer(modifier = DoubleVertSpacer)
             }
         }
     }

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

@@ -1,9 +1,9 @@
 package com.vitorpamplona.amethyst.ui.components
 
+import android.content.Context
 import android.graphics.Rect
 import android.graphics.drawable.Drawable
 import android.net.Uri
-import android.util.Log
 import android.view.View
 import android.view.ViewGroup
 import android.widget.FrameLayout
@@ -21,14 +21,15 @@ import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.material.IconButton
-import androidx.compose.material.MaterialTheme
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.MutableState
 import androidx.compose.runtime.Stable
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
@@ -42,11 +43,15 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.layout.LayoutCoordinates
 import androidx.compose.ui.layout.boundsInWindow
 import androidx.compose.ui.layout.onGloballyPositioned
+import androidx.compose.ui.layout.onSizeChanged
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalLifecycleOwner
 import androidx.compose.ui.platform.LocalView
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.IntSize
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.isFinite
+import androidx.compose.ui.unit.isSpecified
 import androidx.compose.ui.viewinterop.AndroidView
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleEventObserver
@@ -57,12 +62,10 @@ import androidx.media3.common.util.UnstableApi
 import androidx.media3.session.MediaController
 import androidx.media3.ui.AspectRatioFrameLayout
 import androidx.media3.ui.PlayerView
-import coil.imageLoader
-import coil.request.ImageRequest
 import com.linc.audiowaveform.infiniteLinearGradient
-import com.vitorpamplona.amethyst.PlaybackClientController
 import com.vitorpamplona.amethyst.model.ConnectivityType
 import com.vitorpamplona.amethyst.service.connectivitystatus.ConnectivityStatus
+import com.vitorpamplona.amethyst.service.playback.PlaybackClientController
 import com.vitorpamplona.amethyst.ui.note.LyricsIcon
 import com.vitorpamplona.amethyst.ui.note.LyricsOffIcon
 import com.vitorpamplona.amethyst.ui.note.MuteIcon
@@ -96,24 +99,23 @@ fun LoadThumbAndThenVideoView(
     onDialog: ((Boolean) -> Unit)? = null
 ) {
     var loadingFinished by remember { mutableStateOf<Pair<Boolean, Drawable?>>(Pair(false, null)) }
-
     val context = LocalContext.current
 
     LaunchedEffect(Unit) {
-        launch(Dispatchers.IO) {
-            try {
-                val request = ImageRequest.Builder(context).data(thumbUri).build()
-                val myCover = context.imageLoader.execute(request).drawable
-                if (myCover != null) {
-                    loadingFinished = Pair(true, myCover)
+        accountViewModel.loadThumb(
+            context,
+            thumbUri,
+            onReady = {
+                if (it != null) {
+                    loadingFinished = Pair(true, it)
                 } else {
                     loadingFinished = Pair(true, null)
                 }
-            } catch (e: Exception) {
-                Log.e("VideoView", "Fail to load cover $thumbUri", e)
+            },
+            onError = {
                 loadingFinished = Pair(true, null)
             }
-        }
+        )
     }
 
     if (loadingFinished.first) {
@@ -151,29 +153,33 @@ fun VideoView(
     title: String? = null,
     thumb: VideoThumb? = null,
     roundedCorner: Boolean,
+    topPaddingForControllers: Dp = Dp.Unspecified,
     waveform: ImmutableList<Int>? = null,
     artworkUri: String? = null,
     authorName: String? = null,
     nostrUriCallback: String? = null,
     onDialog: ((Boolean) -> Unit)? = null,
+    onControllerVisibilityChanged: ((Boolean) -> Unit)? = null,
     accountViewModel: AccountViewModel,
     alwaysShowVideo: Boolean = false
 ) {
     val defaultToStart by remember(videoUri) { mutableStateOf(DefaultMutedSetting.value) }
 
     VideoViewInner(
-        videoUri,
-        defaultToStart,
-        title,
-        thumb,
-        roundedCorner,
-        waveform,
-        artworkUri,
-        authorName,
-        nostrUriCallback,
-        alwaysShowVideo,
-        accountViewModel,
-        onDialog
+        videoUri = videoUri,
+        defaultToStart = defaultToStart,
+        title = title,
+        thumb = thumb,
+        roundedCorner = roundedCorner,
+        topPaddingForControllers = topPaddingForControllers,
+        waveform = waveform,
+        artworkUri = artworkUri,
+        authorName = authorName,
+        nostrUriCallback = nostrUriCallback,
+        alwaysShowVideo = alwaysShowVideo,
+        accountViewModel = accountViewModel,
+        onControllerVisibilityChanged = onControllerVisibilityChanged,
+        onDialog = onDialog
     )
 }
 
@@ -185,12 +191,14 @@ fun VideoViewInner(
     title: String? = null,
     thumb: VideoThumb? = null,
     roundedCorner: Boolean,
+    topPaddingForControllers: Dp = Dp.Unspecified,
     waveform: ImmutableList<Int>? = null,
     artworkUri: String? = null,
     authorName: String? = null,
     nostrUriCallback: String? = null,
     alwaysShowVideo: Boolean = false,
     accountViewModel: AccountViewModel,
+    onControllerVisibilityChanged: ((Boolean) -> Unit)? = null,
     onDialog: ((Boolean) -> Unit)? = null
 ) {
     val automaticallyStartPlayback = remember {
@@ -210,27 +218,29 @@ fun VideoViewInner(
     } else {
         VideoPlayerActiveMutex(videoUri) { activeOnScreen ->
             val mediaItem = remember(videoUri) {
-                MediaItem.Builder()
-                    .setMediaId(videoUri)
-                    .setUri(videoUri)
-                    .setMediaMetadata(
-                        MediaMetadata.Builder()
-                            .setArtist(authorName?.ifBlank { null })
-                            .setTitle(title?.ifBlank { null } ?: videoUri)
-                            .setArtworkUri(
-                                try {
-                                    if (artworkUri != null) {
-                                        Uri.parse(artworkUri)
-                                    } else {
+                mutableStateOf(
+                    MediaItem.Builder()
+                        .setMediaId(videoUri)
+                        .setUri(videoUri)
+                        .setMediaMetadata(
+                            MediaMetadata.Builder()
+                                .setArtist(authorName?.ifBlank { null })
+                                .setTitle(title?.ifBlank { null } ?: videoUri)
+                                .setArtworkUri(
+                                    try {
+                                        if (artworkUri != null) {
+                                            Uri.parse(artworkUri)
+                                        } else {
+                                            null
+                                        }
+                                    } catch (e: Exception) {
                                         null
                                     }
-                                } catch (e: Exception) {
-                                    null
-                                }
-                            )
-                            .build()
-                    )
-                    .build()
+                                )
+                                .build()
+                        )
+                        .build()
+                )
             }
 
             GetVideoController(
@@ -243,10 +253,12 @@ fun VideoViewInner(
                     controller = controller,
                     thumbData = thumb,
                     roundedCorner = roundedCorner,
+                    topPaddingForControllers = topPaddingForControllers,
                     waveform = waveform,
                     keepPlaying = keepPlaying,
                     automaticallyStartPlayback = automaticallyStartPlayback,
                     activeOnScreen = activeOnScreen,
+                    onControllerVisibilityChanged = onControllerVisibilityChanged,
                     onDialog = onDialog
                 )
             }
@@ -257,7 +269,7 @@ fun VideoViewInner(
 @Composable
 @OptIn(UnstableApi::class)
 fun GetVideoController(
-    mediaItem: MediaItem,
+    mediaItem: MutableState<MediaItem>,
     videoUri: String,
     defaultToStart: Boolean = false,
     nostrUriCallback: String? = null,
@@ -281,18 +293,22 @@ fun GetVideoController(
         UUID.randomUUID().toString()
     }
 
+    val scope = rememberCoroutineScope()
+
     // Prepares a VideoPlayer from the foreground service.
-    LaunchedEffect(key1 = videoUri) {
+    DisposableEffect(key1 = videoUri) {
         // If it is not null, the user might have come back from a playing video, like clicking on
         // the notification of the video player.
         if (controller.value == null) {
-            launch(Dispatchers.IO) {
+            scope.launch(Dispatchers.IO) {
                 PlaybackClientController.prepareController(
                     uid,
                     videoUri,
                     nostrUriCallback,
                     context
                 ) {
+                    // REQUIRED TO BE RUN IN THE MAIN THREAD
+
                     // checks again because of race conditions.
                     if (controller.value == null) { // still prone to race conditions.
                         controller.value = it
@@ -308,7 +324,7 @@ fun GetVideoController(
                             }
                         }
 
-                        controller.value?.setMediaItem(mediaItem)
+                        controller.value?.setMediaItem(mediaItem.value)
                         controller.value?.prepare()
                     } else if (controller.value != it) {
                         // discards the new controller because there is an existing one
@@ -326,7 +342,7 @@ fun GetVideoController(
                                     it.volume = if (defaultToStart) 0f else 1f
                                 }
 
-                                it.setMediaItem(mediaItem)
+                                it.setMediaItem(mediaItem.value)
                                 it.prepare()
                             }
                         }
@@ -345,29 +361,39 @@ fun GetVideoController(
                         it.volume = if (defaultToStart) 0f else 1f
                     }
 
-                    it.setMediaItem(mediaItem)
+                    it.setMediaItem(mediaItem.value)
                     it.prepare()
                 }
             }
         }
+
+        onDispose {
+            if (!keepPlaying.value) {
+                // Stops and releases the media.
+                controller.value?.stop()
+                controller.value?.release()
+                controller.value = null
+            }
+        }
     }
 
     // User pauses and resumes the app. What to do with videos?
-    val scope = rememberCoroutineScope()
     val lifeCycleOwner = LocalLifecycleOwner.current
-    DisposableEffect(key1 = videoUri) {
+    DisposableEffect(key1 = lifeCycleOwner) {
         val observer = LifecycleEventObserver { _, event ->
             if (event == Lifecycle.Event.ON_RESUME) {
                 // if the controller is null, restarts the controller with a new one
                 // if the controller is not null, just continue playing what the controller was playing
-                if (controller.value == null) {
-                    scope.launch(Dispatchers.IO) {
+                scope.launch(Dispatchers.IO) {
+                    if (controller.value == null) {
                         PlaybackClientController.prepareController(
-                            UUID.randomUUID().toString(),
+                            uid,
                             videoUri,
                             nostrUriCallback,
                             context
                         ) {
+                            // REQUIRED TO BE RUN IN THE MAIN THREAD
+
                             // checks again to make sure no other thread has created a controller.
                             if (controller.value == null) {
                                 controller.value = it
@@ -383,7 +409,7 @@ fun GetVideoController(
                                     }
                                 }
 
-                                controller.value?.setMediaItem(mediaItem)
+                                controller.value?.setMediaItem(mediaItem.value)
                                 controller.value?.prepare()
                             } else if (controller.value != it) {
                                 // discards the new controller because there is an existing one
@@ -407,13 +433,6 @@ fun GetVideoController(
         lifeCycleOwner.lifecycle.addObserver(observer)
         onDispose {
             lifeCycleOwner.lifecycle.removeObserver(observer)
-
-            if (!keepPlaying.value) {
-                // Stops and releases the media.
-                controller.value?.stop()
-                controller.value?.release()
-                controller.value = null
-            }
         }
     }
 
@@ -456,7 +475,7 @@ fun VideoPlayerActiveMutex(videoUri: String, inner: @Composable (MutableState<Bo
         }
     }
 
-    Box(
+    val myModifier = remember(videoUri) {
         Modifier
             .fillMaxWidth()
             .defaultMinSize(minHeight = 70.dp)
@@ -485,7 +504,9 @@ fun VideoPlayerActiveMutex(videoUri: String, inner: @Composable (MutableState<Bo
                     }
                 }
             }
-    ) {
+    }
+
+    Box(modifier = myModifier) {
         inner(active)
     }
 }
@@ -501,95 +522,148 @@ private fun RenderVideoPlayer(
     controller: MediaController,
     thumbData: VideoThumb?,
     roundedCorner: Boolean,
+    topPaddingForControllers: Dp = Dp.Unspecified,
     waveform: ImmutableList<Int>? = null,
     keepPlaying: MutableState<Boolean>,
     automaticallyStartPlayback: MutableState<Boolean>,
     activeOnScreen: MutableState<Boolean>,
+    onControllerVisibilityChanged: ((Boolean) -> Unit)? = null,
     onDialog: ((Boolean) -> Unit)?
 ) {
-    val context = LocalContext.current
-
     ControlWhenPlayerIsActive(controller, keepPlaying, automaticallyStartPlayback, activeOnScreen)
 
     val controllerVisible = remember(controller) {
         mutableStateOf(false)
     }
 
-    BoxWithConstraints() {
-        AndroidView(
-            modifier = if (roundedCorner) {
-                MaterialTheme.colors.imageModifier
-                    .defaultMinSize(minHeight = 100.dp)
-                    .align(Alignment.Center)
-            } else {
-                Modifier.fillMaxWidth()
-                    .defaultMinSize(minHeight = 100.dp)
-                    .align(Alignment.Center)
-            },
-            factory = {
-                PlayerView(context).apply {
-                    player = controller
-                    layoutParams = FrameLayout.LayoutParams(
-                        ViewGroup.LayoutParams.MATCH_PARENT,
-                        ViewGroup.LayoutParams.WRAP_CONTENT
-                    )
-                    controllerAutoShow = false
-                    thumbData?.thumb?.let { defaultArtwork = it }
-                    hideController()
-                    resizeMode =
-                        if (maxHeight.isFinite) AspectRatioFrameLayout.RESIZE_MODE_FIT else AspectRatioFrameLayout.RESIZE_MODE_FIXED_WIDTH
-                    onDialog?.let { innerOnDialog ->
-                        setFullscreenButtonClickListener {
-                            controller.pause()
-                            innerOnDialog(it)
-                        }
-                    }
-                    setControllerVisibilityListener(
-                        PlayerView.ControllerVisibilityListener {
-                            controllerVisible.value = it == View.VISIBLE
-                        }
-                    )
+    val parentVideoPlaybackSize = remember {
+        mutableStateOf<IntSize>(IntSize.Zero)
+    }
+
+    val videoPlaybackSize = remember {
+        mutableStateOf<IntSize>(IntSize.Zero)
+    }
+
+    BoxWithConstraints(
+        contentAlignment = Alignment.Center,
+        modifier = Modifier.fillMaxSize().onSizeChanged {
+            parentVideoPlaybackSize.value = it
+        }
+    ) {
+        BoxWithConstraints(
+            modifier = Modifier.onSizeChanged {
+                videoPlaybackSize.value = it
+            }
+        ) {
+            val borders = MaterialTheme.colorScheme.imageModifier
+
+            val myModifier = remember {
+                if (roundedCorner) {
+                    borders
+                        .defaultMinSize(minHeight = 100.dp)
+                        .align(Alignment.Center)
+                } else {
+                    Modifier
+                        .fillMaxWidth()
+                        .defaultMinSize(minHeight = 100.dp)
+                        .align(Alignment.Center)
                 }
             }
-        )
 
-        waveform?.let {
-            Waveform(it, controller, Modifier.align(Alignment.Center))
-        }
-
-        val startingMuteState = remember(controller) {
-            controller.volume < 0.001
-        }
-
-        MuteButton(controllerVisible, startingMuteState) { mute: Boolean ->
-            // makes the new setting the default for new creations.
-            DefaultMutedSetting.value = mute
-
-            // if the user unmutes a video and it's not the current playing, switches to that one.
-            if (!mute && keepPlayingMutex != null && keepPlayingMutex != controller) {
-                keepPlayingMutex?.stop()
-                keepPlayingMutex?.release()
-                keepPlayingMutex = null
+            val factory = remember(controller) {
+                { context: Context ->
+                    PlayerView(context).apply {
+                        player = controller
+                        layoutParams = FrameLayout.LayoutParams(
+                            ViewGroup.LayoutParams.MATCH_PARENT,
+                            ViewGroup.LayoutParams.WRAP_CONTENT
+                        )
+                        controllerAutoShow = false
+                        thumbData?.thumb?.let { defaultArtwork = it }
+                        hideController()
+                        resizeMode =
+                            if (maxHeight.isFinite) AspectRatioFrameLayout.RESIZE_MODE_FIT else AspectRatioFrameLayout.RESIZE_MODE_FIXED_WIDTH
+                        onDialog?.let { innerOnDialog ->
+                            setFullscreenButtonClickListener {
+                                controller.pause()
+                                innerOnDialog(it)
+                            }
+                        }
+                        setControllerVisibilityListener(
+                            PlayerView.ControllerVisibilityListener { visible ->
+                                controllerVisible.value = visible == View.VISIBLE
+                                onControllerVisibilityChanged?.let { callback ->
+                                    callback(visible == View.VISIBLE)
+                                }
+                            }
+                        )
+                    }
+                }
             }
 
-            controller.volume = if (mute) 0f else 1f
-        }
+            AndroidView(
+                modifier = myModifier,
+                factory = factory
+            )
 
-        KeepPlayingButton(keepPlaying, controllerVisible, Modifier.align(Alignment.TopEnd)) { newKeepPlaying: Boolean ->
-            // If something else is playing and the user marks this video to keep playing, stops the other one.
-            if (newKeepPlaying) {
-                if (keepPlayingMutex != null && keepPlayingMutex != controller) {
+            waveform?.let {
+                Waveform(it, controller, remember { Modifier.align(Alignment.Center) })
+            }
+
+            val startingMuteState = remember(controller) {
+                controller.volume < 0.001
+            }
+
+            val spaceModifier =
+                if (topPaddingForControllers.isSpecified && videoPlaybackSize.value.height > 0) {
+                    val space = (abs(parentVideoPlaybackSize.value.height - videoPlaybackSize.value.height) / 2).dp
+                    if (space > topPaddingForControllers) {
+                        Modifier
+                    } else {
+                        Modifier.padding(top = topPaddingForControllers - space)
+                    }
+                } else {
+                    Modifier
+                }
+
+            MuteButton(
+                controllerVisible,
+                startingMuteState,
+                spaceModifier
+            ) { mute: Boolean ->
+                // makes the new setting the default for new creations.
+                DefaultMutedSetting.value = mute
+
+                // if the user unmutes a video and it's not the current playing, switches to that one.
+                if (!mute && keepPlayingMutex != null && keepPlayingMutex != controller) {
                     keepPlayingMutex?.stop()
                     keepPlayingMutex?.release()
-                }
-                keepPlayingMutex = controller
-            } else {
-                if (keepPlayingMutex == controller) {
                     keepPlayingMutex = null
                 }
+
+                controller.volume = if (mute) 0f else 1f
             }
 
-            keepPlaying.value = newKeepPlaying
+            KeepPlayingButton(
+                keepPlaying,
+                controllerVisible,
+                spaceModifier.align(Alignment.TopEnd)
+            ) { newKeepPlaying: Boolean ->
+                // If something else is playing and the user marks this video to keep playing, stops the other one.
+                if (newKeepPlaying) {
+                    if (keepPlayingMutex != null && keepPlayingMutex != controller) {
+                        keepPlayingMutex?.stop()
+                        keepPlayingMutex?.release()
+                    }
+                    keepPlayingMutex = controller
+                } else {
+                    if (keepPlayingMutex == controller) {
+                        keepPlayingMutex = null
+                    }
+                }
+
+                keepPlaying.value = newKeepPlaying
+            }
         }
     }
 }
@@ -612,7 +686,7 @@ fun Waveform(
     DrawWaveform(waveform, waveformProgress, modifier)
 
     val restartFlow = remember {
-        mutableStateOf(0)
+        mutableIntStateOf(0)
     }
 
     // Keeps the screen on while playing and viewing videos.
@@ -664,36 +738,38 @@ fun ControlWhenPlayerIsActive(
     automaticallyStartPlayback: MutableState<Boolean>,
     activeOnScreen: MutableState<Boolean>
 ) {
-    // active means being fully visible
-    if (activeOnScreen.value) {
-        // should auto start video from settings?
-        if (!automaticallyStartPlayback.value) {
-            if (controller.isPlaying) {
-                // if it is visible, it's playing but it wasn't supposed to start automatically.
+    LaunchedEffect(key1 = activeOnScreen.value) {
+        // active means being fully visible
+        if (activeOnScreen.value) {
+            // should auto start video from settings?
+            if (!automaticallyStartPlayback.value) {
+                if (controller.isPlaying) {
+                    // if it is visible, it's playing but it wasn't supposed to start automatically.
+                    controller.pause()
+                }
+            } else if (!controller.isPlaying) {
+                // if it is visible, was supposed to start automatically, but it's not
+
+                // If something else is playing, play on mute.
+                if (keepPlayingMutex != null && keepPlayingMutex != controller) {
+                    controller.volume = 0f
+                }
+                controller.play()
+            }
+        } else {
+            // Pauses the video when it becomes invisible.
+            // Destroys the video later when it Disposes the element
+            // meanwhile if the user comes back, the position in the track is saved.
+            if (!keepPlaying.value) {
                 controller.pause()
             }
-        } else if (!controller.isPlaying) {
-            // if it is visible, was supposed to start automatically, but it's not
-
-            // If something else is playing, play on mute.
-            if (keepPlayingMutex != null && keepPlayingMutex != controller) {
-                controller.volume = 0f
-            }
-            controller.play()
-        }
-    } else {
-        // Pauses the video when it becomes invisible.
-        // Destroys the video later when it Disposes the element
-        // meanwhile if the user comes back, the position in the track is saved.
-        if (!keepPlaying.value) {
-            controller.pause()
         }
     }
 
     val view = LocalView.current
 
     // Keeps the screen on while playing and viewing videos.
-    DisposableEffect(key1 = controller) {
+    DisposableEffect(key1 = controller, key2 = view) {
         val listener = object : Player.Listener {
             override fun onIsPlayingChanged(isPlaying: Boolean) {
                 // doesn't consider the mutex because the screen can turn off if the video
@@ -747,6 +823,7 @@ fun LayoutCoordinates.getDistanceToVertCenterIfVisible(view: View): Float? {
 private fun MuteButton(
     controllerVisible: MutableState<Boolean>,
     startingMuteState: Boolean,
+    modifier: Modifier,
     toggle: (Boolean) -> Unit
 ) {
     val holdOn = remember {
@@ -766,6 +843,7 @@ private fun MuteButton(
 
     AnimatedVisibility(
         visible = holdOn.value || controllerVisible.value,
+        modifier = modifier,
         enter = fadeIn(),
         exit = fadeOut()
     ) {
@@ -775,7 +853,7 @@ private fun MuteButton(
                     .clip(CircleShape)
                     .fillMaxSize(0.6f)
                     .align(Alignment.Center)
-                    .background(MaterialTheme.colors.background)
+                    .background(MaterialTheme.colorScheme.background)
             )
 
             IconButton(
@@ -816,7 +894,7 @@ private fun KeepPlayingButton(
                     .clip(CircleShape)
                     .fillMaxSize(0.6f)
                     .align(Alignment.Center)
-                    .background(MaterialTheme.colors.background)
+                    .background(MaterialTheme.colorScheme.background)
             )
 
             IconButton(
@@ -827,9 +905,9 @@ private fun KeepPlayingButton(
                 modifier = Size50Modifier
             ) {
                 if (keepPlaying.value) {
-                    LyricsIcon(Size22Modifier, MaterialTheme.colors.onBackground)
+                    LyricsIcon(Size22Modifier, MaterialTheme.colorScheme.onBackground)
                 } else {
-                    LyricsOffIcon(Size22Modifier, MaterialTheme.colors.onBackground)
+                    LyricsOffIcon(Size22Modifier, MaterialTheme.colorScheme.onBackground)
                 }
             }
         }

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

@@ -5,14 +5,12 @@ import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.text.KeyboardOptions
-import androidx.compose.material.Divider
-import androidx.compose.material.Icon
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.OutlinedTextField
-import androidx.compose.material.Text
+import androidx.compose.material3.Divider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
@@ -60,7 +58,7 @@ fun ZapRaiserRequest(
 
         Text(
             text = stringResource(R.string.zapraiser_explainer),
-            color = MaterialTheme.colors.placeholderText,
+            color = MaterialTheme.colorScheme.placeholderText,
             modifier = Modifier.padding(vertical = 10.dp)
         )
 
@@ -84,7 +82,7 @@ fun ZapRaiserRequest(
             placeholder = {
                 Text(
                     text = "1000",
-                    color = MaterialTheme.colors.placeholderText
+                    color = MaterialTheme.colorScheme.placeholderText
                 )
             },
             keyboardOptions = KeyboardOptions.Default.copy(

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

@@ -6,16 +6,20 @@ import android.content.ContextWrapper
 import android.os.Build
 import android.util.Log
 import android.view.Window
-import android.widget.Toast
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
 import androidx.compose.foundation.ExperimentalFoundationApi
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.combinedClickable
+import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.BoxWithConstraints
 import androidx.compose.foundation.layout.ExperimentalLayoutApi
 import androidx.compose.foundation.layout.FlowRow
 import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.aspectRatio
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
@@ -29,18 +33,17 @@ import androidx.compose.foundation.pager.PagerState
 import androidx.compose.foundation.pager.rememberPagerState
 import androidx.compose.foundation.text.InlineTextContent
 import androidx.compose.foundation.text.appendInlineContent
-import androidx.compose.material.Button
-import androidx.compose.material.ButtonDefaults
-import androidx.compose.material.DropdownMenu
-import androidx.compose.material.DropdownMenuItem
-import androidx.compose.material.Icon
-import androidx.compose.material.IconButton
-import androidx.compose.material.LocalTextStyle
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.Surface
-import androidx.compose.material.Text
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Share
+import androidx.compose.material3.DropdownMenu
+import androidx.compose.material3.DropdownMenuItem
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.LocalTextStyle
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.Immutable
@@ -49,11 +52,9 @@ import androidx.compose.runtime.MutableState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.layout.ContentScale
 import androidx.compose.ui.platform.LocalClipboardManager
 import androidx.compose.ui.platform.LocalContext
@@ -64,8 +65,10 @@ import androidx.compose.ui.text.Placeholder
 import androidx.compose.ui.text.PlaceholderVerticalAlign
 import androidx.compose.ui.text.buildAnnotatedString
 import androidx.compose.ui.text.withStyle
+import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.isFinite
+import androidx.compose.ui.unit.isSpecified
 import androidx.compose.ui.window.Dialog
 import androidx.compose.ui.window.DialogProperties
 import androidx.compose.ui.window.DialogWindowProvider
@@ -79,6 +82,7 @@ import com.vitorpamplona.amethyst.model.ConnectivityType
 import com.vitorpamplona.amethyst.service.BlurHashRequester
 import com.vitorpamplona.amethyst.service.connectivitystatus.ConnectivityStatus
 import com.vitorpamplona.amethyst.ui.actions.CloseButton
+import com.vitorpamplona.amethyst.ui.actions.InformationDialog
 import com.vitorpamplona.amethyst.ui.actions.LoadingAnimation
 import com.vitorpamplona.amethyst.ui.actions.SaveToGallery
 import com.vitorpamplona.amethyst.ui.note.BlankNote
@@ -86,15 +90,15 @@ import com.vitorpamplona.amethyst.ui.note.DownloadForOfflineIcon
 import com.vitorpamplona.amethyst.ui.note.HashCheckFailedIcon
 import com.vitorpamplona.amethyst.ui.note.HashCheckIcon
 import com.vitorpamplona.amethyst.ui.screen.loggedIn.AccountViewModel
-import com.vitorpamplona.amethyst.ui.theme.ButtonBorder
 import com.vitorpamplona.amethyst.ui.theme.Font17SP
 import com.vitorpamplona.amethyst.ui.theme.Size20Modifier
 import com.vitorpamplona.amethyst.ui.theme.Size20dp
 import com.vitorpamplona.amethyst.ui.theme.Size24dp
 import com.vitorpamplona.amethyst.ui.theme.Size30dp
+import com.vitorpamplona.amethyst.ui.theme.Size55dp
 import com.vitorpamplona.amethyst.ui.theme.Size5dp
+import com.vitorpamplona.amethyst.ui.theme.StdHorzSpacer
 import com.vitorpamplona.amethyst.ui.theme.imageModifier
-import com.vitorpamplona.amethyst.ui.theme.placeholderText
 import com.vitorpamplona.quartz.crypto.CryptoUtils
 import com.vitorpamplona.quartz.encoders.toHexKey
 import kotlinx.collections.immutable.ImmutableList
@@ -212,7 +216,7 @@ fun ZoomableContentView(
     }
 
     var mainImageModifier = if (roundedCorner) {
-        MaterialTheme.colors.imageModifier
+        MaterialTheme.colorScheme.imageModifier
     } else {
         Modifier.fillMaxWidth()
     }
@@ -234,7 +238,7 @@ fun ZoomableContentView(
     }
 
     when (content) {
-        is ZoomableUrlImage -> UrlImageView(content, mainImageModifier, accountViewModel)
+        is ZoomableUrlImage -> UrlImageView(content, mainImageModifier, accountViewModel = accountViewModel)
         is ZoomableUrlVideo -> VideoView(
             videoUri = content.url,
             title = content.description,
@@ -246,7 +250,7 @@ fun ZoomableContentView(
             accountViewModel = accountViewModel
         )
 
-        is ZoomableLocalImage -> LocalImageView(content, mainImageModifier, accountViewModel)
+        is ZoomableLocalImage -> LocalImageView(content, mainImageModifier, accountViewModel = accountViewModel)
         is ZoomableLocalVideo ->
             content.localFile?.let {
                 VideoView(
@@ -271,6 +275,7 @@ fun ZoomableContentView(
 private fun LocalImageView(
     content: ZoomableLocalImage,
     mainImageModifier: Modifier,
+    topPaddingForControllers: Dp = Dp.Unspecified,
     accountViewModel: AccountViewModel?,
     alwayShowImage: Boolean = false
 ) {
@@ -304,7 +309,11 @@ private fun LocalImageView(
                 if (maxHeight.isFinite) ContentScale.Fit else ContentScale.FillWidth
             }
 
-            val verifierModifier = Modifier.align(Alignment.TopEnd)
+            val verifierModifier = if (topPaddingForControllers.isSpecified) {
+                Modifier.padding(top = topPaddingForControllers).align(Alignment.TopEnd)
+            } else {
+                Modifier.align(Alignment.TopEnd)
+            }
 
             val painterState = remember {
                 mutableStateOf<AsyncImagePainter.State?>(null)
@@ -340,6 +349,7 @@ private fun LocalImageView(
 private fun UrlImageView(
     content: ZoomableUrlImage,
     mainImageModifier: Modifier,
+    topPaddingForControllers: Dp = Dp.Unspecified,
     accountViewModel: AccountViewModel?,
     alwayShowImage: Boolean = false
 ) {
@@ -361,18 +371,24 @@ private fun UrlImageView(
             mainImageModifier
                 .widthIn(max = maxWidth)
                 .heightIn(max = maxHeight)
+                /* Is this necessary? It makes images bleed into other pages
                 .run {
                     aspectRatio(content.dim)?.let { ratio ->
                         this.aspectRatio(ratio, false)
                     } ?: this
                 }
+                */
         }
 
         val contentScale = remember {
             if (maxHeight.isFinite) ContentScale.Fit else ContentScale.FillWidth
         }
 
-        val verifierModifier = Modifier.align(Alignment.TopEnd)
+        val verifierModifier = if (topPaddingForControllers.isSpecified) {
+            Modifier.padding(top = topPaddingForControllers).align(Alignment.TopEnd)
+        } else {
+            Modifier.align(Alignment.TopEnd)
+        }
 
         val painterState = remember {
             mutableStateOf<AsyncImagePainter.State?>(null)
@@ -477,14 +493,16 @@ private fun AddedImageFeatures(
                 if (content.blurhash != null) {
                     DisplayBlurHash(content.blurhash, content.description, contentScale, myModifier)
                 } else {
-                    FlowRow() {
+                    FlowRow(Modifier.fillMaxWidth()) {
                         DisplayUrlWithLoadingSymbol(content)
                     }
                 }
             }
 
             is AsyncImagePainter.State.Error -> {
-                ClickableUrl(urlText = "${content.url} ", url = content.url)
+                FlowRow(Modifier.fillMaxWidth()) {
+                    ClickableUrl(urlText = "${content.url} ", url = content.url)
+                }
             }
 
             is AsyncImagePainter.State.Success -> {
@@ -551,7 +569,7 @@ private fun DisplayUrlWithLoadingSymbolWait(content: ZoomableContent) {
     val myId = "inlineContent"
     val emptytext = buildAnnotatedString {
         withStyle(
-            LocalTextStyle.current.copy(color = MaterialTheme.colors.primary).toSpanStyle()
+            LocalTextStyle.current.copy(color = MaterialTheme.colorScheme.primary).toSpanStyle()
         ) {
             append("")
             appendInlineContent(myId, "[icon]")
@@ -612,7 +630,7 @@ fun ZoomableImageDialog(
 ) {
     val view = LocalView.current
 
-    DisposableEffect(key1 = Unit) {
+    DisposableEffect(key1 = view) {
         if (Build.VERSION.SDK_INT >= 30) {
             view.windowInsetsController?.hide(
                 android.view.WindowInsets.Type.systemBars()
@@ -635,49 +653,97 @@ fun ZoomableImageDialog(
             decorFitsSystemWindows = false
         )
     ) {
-        Surface(modifier = Modifier.fillMaxSize(), color = MaterialTheme.colors.background) {
+        Surface(modifier = Modifier.fillMaxSize(), color = MaterialTheme.colorScheme.background) {
             Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.TopCenter) {
-                val pagerState: PagerState = rememberPagerState() { allImages.size }
+                DialogContent(allImages, imageUrl, onDismiss, accountViewModel)
+            }
+        }
+    }
+}
 
-                LaunchedEffect(key1 = pagerState, key2 = imageUrl) {
-                    val page = allImages.indexOf(imageUrl)
-                    if (page > -1) {
-                        pagerState.scrollToPage(page)
-                    }
-                }
-
-                if (allImages.size > 1) {
-                    SlidingCarousel(
-                        pagerState = pagerState
-                    ) { index ->
-                        RenderImageOrVideo(allImages[index], false, accountViewModel)
-                    }
-                } else {
-                    RenderImageOrVideo(imageUrl, false, accountViewModel)
-                }
-
-                Row(
-                    modifier = Modifier
-                        .padding(10.dp)
-                        .fillMaxWidth(),
-                    horizontalArrangement = Arrangement.SpaceBetween,
-                    verticalAlignment = Alignment.CenterVertically
-                ) {
-                    CloseButton(onPress = onDismiss)
-
-                    val myContent = allImages[pagerState.currentPage]
-                    if (myContent is ZoomableUrlContent) {
-                        Row() {
-                            CopyToClipboard(content = myContent)
-                            SaveToGallery(url = myContent.url)
-                        }
-                    } else if (myContent is ZoomableLocalImage && myContent.localFile != null) {
-                        SaveToGallery(
-                            localFile = myContent.localFile,
-                            mimeType = myContent.mimeType
-                        )
-                    }
+@Composable
+@OptIn(ExperimentalFoundationApi::class)
+private fun DialogContent(
+    allImages: ImmutableList<ZoomableContent>,
+    imageUrl: ZoomableContent,
+    onDismiss: () -> Unit,
+    accountViewModel: AccountViewModel
+) {
+    val pagerState: PagerState = rememberPagerState() { allImages.size }
+    val controllerVisible = remember { mutableStateOf(false) }
+    val holdOn = remember { mutableStateOf<Boolean>(true) }
+
+    LaunchedEffect(key1 = pagerState, key2 = imageUrl) {
+        launch {
+            val page = allImages.indexOf(imageUrl)
+            if (page > -1) {
+                pagerState.scrollToPage(page)
+            }
+        }
+        launch(Dispatchers.Default) {
+            delay(2000)
+            holdOn.value = false
+        }
+    }
+
+    if (allImages.size > 1) {
+        SlidingCarousel(
+            pagerState = pagerState
+        ) { index ->
+            RenderImageOrVideo(
+                content = allImages[index],
+                roundedCorner = false,
+                topPaddingForControllers = Size55dp,
+                onControllerVisibilityChanged = {
+                    controllerVisible.value = it
+                },
+                onToggleControllerVisibility = {
+                    controllerVisible.value = !controllerVisible.value
+                },
+                accountViewModel = accountViewModel
+            )
+        }
+    } else {
+        RenderImageOrVideo(
+            content = imageUrl,
+            roundedCorner = false,
+            topPaddingForControllers = Size55dp,
+            onControllerVisibilityChanged = {
+                controllerVisible.value = it
+            },
+            onToggleControllerVisibility = {
+                controllerVisible.value = !controllerVisible.value
+            },
+            accountViewModel = accountViewModel
+        )
+    }
+
+    AnimatedVisibility(
+        visible = holdOn.value || controllerVisible.value,
+        enter = fadeIn(),
+        exit = fadeOut()
+    ) {
+        Row(
+            modifier = Modifier
+                .padding(10.dp)
+                .fillMaxWidth(),
+            horizontalArrangement = Arrangement.SpaceBetween,
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            CloseButton(onPress = onDismiss)
+
+            val myContent = allImages[pagerState.currentPage]
+            if (myContent is ZoomableUrlContent) {
+                Row() {
+                    CopyToClipboard(content = myContent)
+                    Spacer(modifier = StdHorzSpacer)
+                    SaveToGallery(url = myContent.url)
                 }
+            } else if (myContent is ZoomableLocalImage && myContent.localFile != null) {
+                SaveToGallery(
+                    localFile = myContent.localFile,
+                    mimeType = myContent.mimeType
+                )
             }
         }
     }
@@ -689,17 +755,11 @@ private fun CopyToClipboard(
 ) {
     val popupExpanded = remember { mutableStateOf(false) }
 
-    Button(
+    OutlinedButton(
         modifier = Modifier.padding(horizontal = Size5dp),
-        onClick = { popupExpanded.value = true },
-        shape = ButtonBorder,
-        colors = ButtonDefaults
-            .buttonColors(
-                backgroundColor = MaterialTheme.colors.placeholderText
-            )
+        onClick = { popupExpanded.value = true }
     ) {
         Icon(
-            tint = Color.White,
             imageVector = Icons.Default.Share,
             modifier = Size20Modifier,
             contentDescription = stringResource(R.string.copy_url_to_clipboard)
@@ -723,32 +783,68 @@ private fun ShareImageAction(
         val clipboardManager = LocalClipboardManager.current
 
         if (content is ZoomableUrlContent) {
-            DropdownMenuItem(onClick = { clipboardManager.setText(AnnotatedString(content.url)); onDismiss() }) {
-                Text(stringResource(R.string.copy_url_to_clipboard))
-            }
-            if (content.uri != null) {
-                DropdownMenuItem(onClick = { clipboardManager.setText(AnnotatedString(content.uri)); onDismiss() }) {
-                    Text(stringResource(R.string.copy_the_note_id_to_the_clipboard))
+            DropdownMenuItem(
+                text = {
+                    Text(stringResource(R.string.copy_url_to_clipboard))
+                },
+                onClick = {
+                    clipboardManager.setText(AnnotatedString(content.url)); onDismiss()
                 }
+            )
+            if (content.uri != null) {
+                DropdownMenuItem(
+                    text = {
+                        Text(stringResource(R.string.copy_the_note_id_to_the_clipboard))
+                    },
+                    onClick = {
+                        clipboardManager.setText(AnnotatedString(content.uri)); onDismiss()
+                    }
+                )
             }
         }
 
         if (content is ZoomablePreloadedContent) {
-            DropdownMenuItem(onClick = { clipboardManager.setText(AnnotatedString(content.uri)); onDismiss() }) {
-                Text(stringResource(R.string.copy_the_note_id_to_the_clipboard))
-            }
+            DropdownMenuItem(
+                text = {
+                    Text(stringResource(R.string.copy_the_note_id_to_the_clipboard))
+                },
+                onClick = {
+                    clipboardManager.setText(AnnotatedString(content.uri)); onDismiss()
+                }
+            )
         }
     }
 }
 
 @Composable
-private fun RenderImageOrVideo(content: ZoomableContent, roundedCorner: Boolean, accountViewModel: AccountViewModel) {
-    val mainModifier = Modifier
-        .fillMaxSize()
-        .zoomable(rememberZoomState())
-
+private fun RenderImageOrVideo(
+    content: ZoomableContent,
+    roundedCorner: Boolean,
+    topPaddingForControllers: Dp = Dp.Unspecified,
+    onControllerVisibilityChanged: ((Boolean) -> Unit)? = null,
+    onToggleControllerVisibility: (() -> Unit)? = null,
+    accountViewModel: AccountViewModel
+) {
     if (content is ZoomableUrlImage) {
-        UrlImageView(content = content, mainImageModifier = mainModifier, accountViewModel, alwayShowImage = true)
+        val mainModifier = Modifier
+            .fillMaxSize()
+            .zoomable(rememberZoomState())
+            .clickable(
+                interactionSource = remember { MutableInteractionSource() },
+                indication = null // Avoid flashing on click
+            ) {
+                if (onToggleControllerVisibility != null) {
+                    onToggleControllerVisibility()
+                }
+            }
+
+        UrlImageView(
+            content = content,
+            mainImageModifier = mainModifier,
+            topPaddingForControllers = topPaddingForControllers,
+            accountViewModel,
+            alwayShowImage = true
+        )
     } else if (content is ZoomableUrlVideo) {
         Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxSize(1f)) {
             VideoView(
@@ -757,12 +853,32 @@ private fun RenderImageOrVideo(content: ZoomableContent, roundedCorner: Boolean,
                 artworkUri = content.artworkUri,
                 authorName = content.authorName,
                 roundedCorner = roundedCorner,
+                topPaddingForControllers = topPaddingForControllers,
+                onControllerVisibilityChanged = onControllerVisibilityChanged,
                 accountViewModel = accountViewModel,
                 alwaysShowVideo = true
             )
         }
     } else if (content is ZoomableLocalImage) {
-        LocalImageView(content = content, mainImageModifier = mainModifier, accountViewModel, alwayShowImage = true)
+        val mainModifier = Modifier
+            .fillMaxSize()
+            .zoomable(rememberZoomState())
+            .clickable(
+                interactionSource = remember { MutableInteractionSource() },
+                indication = null // Avoid flashing on click
+            ) {
+                if (onToggleControllerVisibility != null) {
+                    onToggleControllerVisibility()
+                }
+            }
+
+        LocalImageView(
+            content = content,
+            mainImageModifier = mainModifier,
+            topPaddingForControllers = topPaddingForControllers,
+            accountViewModel,
+            alwayShowImage = true
+        )
     } else if (content is ZoomableLocalVideo) {
         Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxSize(1f)) {
             content.localFile?.let {
@@ -772,6 +888,8 @@ private fun RenderImageOrVideo(content: ZoomableContent, roundedCorner: Boolean,
                     artworkUri = content.artworkUri,
                     authorName = content.authorName,
                     roundedCorner = roundedCorner,
+                    topPaddingForControllers = topPaddingForControllers,
+                    onControllerVisibilityChanged = onControllerVisibilityChanged,
                     accountViewModel = accountViewModel,
                     alwaysShowVideo = true
                 )
@@ -798,7 +916,17 @@ private fun verifyHash(content: ZoomableUrlContent, context: Context): Boolean?
 @Composable
 private fun HashVerificationSymbol(verifiedHash: Boolean, modifier: Modifier) {
     val localContext = LocalContext.current
-    val scope = rememberCoroutineScope()
+
+    val openDialogMsg = remember { mutableStateOf<String?>(null) }
+
+    openDialogMsg.value?.let {
+        InformationDialog(
+            title = localContext.getString(R.string.hash_verification_info_title),
+            textContent = it
+        ) {
+            openDialogMsg.value = null
+        }
+    }
 
     Box(
         modifier
@@ -809,13 +937,7 @@ private fun HashVerificationSymbol(verifiedHash: Boolean, modifier: Modifier) {
         if (verifiedHash) {
             IconButton(
                 onClick = {
-                    scope.launch {
-                        Toast.makeText(
-                            localContext,
-                            localContext.getString(R.string.hash_verification_passed),
-                            Toast.LENGTH_LONG
-                        ).show()
-                    }
+                    openDialogMsg.value = localContext.getString(R.string.hash_verification_passed)
                 }
             ) {
                 HashCheckIcon(Size30dp)
@@ -823,13 +945,7 @@ private fun HashVerificationSymbol(verifiedHash: Boolean, modifier: Modifier) {
         } else {
             IconButton(
                 onClick = {
-                    scope.launch {
-                        Toast.makeText(
-                            localContext,
-                            localContext.getString(R.string.hash_verification_failed),
-                            Toast.LENGTH_LONG
-                        ).show()
-                    }
+                    openDialogMsg.value = localContext.getString(R.string.hash_verification_failed)
                 }
             ) {
                 HashCheckFailedIcon(Size30dp)

app/src/main/java/com/vitorpamplona/amethyst/ui/dal/BookmarkPrivateFeedFilter.kt

@@ -3,6 +3,8 @@ package com.vitorpamplona.amethyst.ui.dal
 import com.vitorpamplona.amethyst.model.Account
 import com.vitorpamplona.amethyst.model.LocalCache
 import com.vitorpamplona.amethyst.model.Note
+import com.vitorpamplona.amethyst.service.ExternalSignerUtils
+import com.vitorpamplona.quartz.encoders.toHexKey
 
 object BookmarkPrivateFeedFilter : FeedFilter<Note>() {
     lateinit var account: Account
@@ -12,18 +14,44 @@ object BookmarkPrivateFeedFilter : FeedFilter<Note>() {
     }
 
     override fun feed(): List<Note> {
-        val privKey = account.keyPair.privKey ?: return emptyList()
-
         val bookmarks = account.userProfile().latestBookmarkList
 
-        val notes = bookmarks?.privateTaggedEvents(privKey)
-            ?.mapNotNull { LocalCache.checkGetOrCreateNote(it) } ?: emptyList()
+        if (account.loginWithExternalSigner) {
+            val id = bookmarks?.id
+            if (id != null) {
+                val decryptedContent = ExternalSignerUtils.cachedDecryptedContent[id]
+                if (decryptedContent == null) {
+                    ExternalSignerUtils.decryptBookmark(
+                        bookmarks.content,
+                        account.keyPair.pubKey.toHexKey(),
+                        id
+                    )
+                } else {
+                    bookmarks.decryptedContent = decryptedContent
+                }
+            }
+            val decryptedContent = ExternalSignerUtils.cachedDecryptedContent[id] ?: ""
 
-        val addresses = bookmarks?.privateTaggedAddresses(privKey)
-            ?.map { LocalCache.getOrCreateAddressableNote(it) } ?: emptyList()
+            val notes = bookmarks?.privateTaggedEvents(decryptedContent)
+                ?.mapNotNull { LocalCache.checkGetOrCreateNote(it) } ?: emptyList()
+            val addresses = bookmarks?.privateTaggedAddresses(decryptedContent)
+                ?.map { LocalCache.getOrCreateAddressableNote(it) } ?: emptyList()
 
-        return notes.plus(addresses).toSet()
-            .sortedWith(compareBy({ it.createdAt() }, { it.idHex }))
-            .reversed()
+            return notes.plus(addresses).toSet()
+                .sortedWith(compareBy({ it.createdAt() }, { it.idHex }))
+                .reversed()
+        } else {
+            val privKey = account.keyPair.privKey ?: return emptyList()
+
+            val notes = bookmarks?.privateTaggedEvents(privKey)
+                ?.mapNotNull { LocalCache.checkGetOrCreateNote(it) } ?: emptyList()
+
+            val addresses = bookmarks?.privateTaggedAddresses(privKey)
+                ?.map { LocalCache.getOrCreateAddressableNote(it) } ?: emptyList()
+
+            return notes.plus(addresses).toSet()
+                .sortedWith(compareBy({ it.createdAt() }, { it.idHex }))
+                .reversed()
+        }
     }
 }