v0.79.5

Forces a filter reset after authentication
Adds log of bad signature event.
2026-08-06 06:44:37 +00:00 · 2023-10-17 11:14:50 -04:00 · 2023-10-16 14:39:05 -04:00 · 2023-10-16 14:38:31 -04:00 · 2023-10-16 12:07:17 -04:00 · 2023-10-16 12:05:52 -04:00
254 changed files with 11683 additions and 5099 deletions
@@ -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>
@@ -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 296
-        versionName "0.76.2"
+        versionCode 314
+        versionName "0.79.5"

        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
@@ -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.
@@ -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)

@@ -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>) {
    }
 }
@@ -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 -->
@@ -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))
+    }
+}
@@ -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)
@@ -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
+            }
+        }
+}
@@ -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
@@ -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,7 +78,9 @@ 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 {
@@ -82,7 +88,7 @@ object LocalPreferences {

    private var _currentAccount: String? = null

-    private fun currentAccount(): String? {
+    fun currentAccount(): String? {
        if (_currentAccount == null) {
            _currentAccount = encryptedPreferences().getString(PrefKeys.CURRENT_ACCOUNT, null)
        }
@@ -201,7 +207,11 @@ object LocalPreferences {

    fun allSavedAccounts(): List<AccountInfo> {
        return savedAccounts().map { npub ->
-            AccountInfo(npub = npub)
+            AccountInfo(
+                npub,
+                hasPrivKey(npub),
+                getLoggedInWithExternalSigner(npub)
+            )
        }
    }

@@ -245,6 +255,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 +276,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 +298,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 +340,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 +359,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 +383,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 +394,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 +409,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 +432,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 +475,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)
-    }
 }
@@ -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,10 @@ class MultiPlayerPlaybackManager(
            override fun onPlaybackStateChanged(playbackState: Int) {
                when (playbackState) {
                    STATE_IDLE -> {
-                        cachedPositions.add(uri, player.currentPosition)
+                        // only saves if it wqs playing
+                        if (abs(player.currentPosition) > 1) {
+                            cachedPositions.add(uri, player.currentPosition)
+                        }
                    }
                    STATE_READY -> {
                        cachedPositions.get(uri)?.let { lastPosition ->
@@ -102,7 +106,10 @@ class MultiPlayerPlaybackManager(
                        }
                    }
                    else -> {
-                        cachedPositions.add(uri, player.currentPosition)
+                        // only saves if it wqs playing
+                        if (abs(player.currentPosition) > 1) {
+                            cachedPositions.add(uri, player.currentPosition)
+                        }
                    }
                }
            }
@@ -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 {
@@ -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)

@@ -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
@@ -90,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
            }
@@ -98,6 +166,18 @@ 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()

@@ -206,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()}")
@@ -337,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)
        }
@@ -1436,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 {
@@ -1537,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.
@@ -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)
@@ -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
+        }
+    }
+}
@@ -319,7 +319,7 @@ class User(val pubkeyHex: String) {
        return latestContactList?.verifiedFollowKeySet ?: emptySet()
    }

-    fun cachedFollowingTagSet(): Set<HexKey> {
+    fun cachedFollowingTagSet(): Set<String> {
        return latestContactList?.verifiedFollowTagSet ?: emptySet()
    }

@@ -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) }
+}
@@ -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))
        }
    }
 }
@@ -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
+        }
+    }
+}
@@ -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()
@@ -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,
@@ -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)
    }
@@ -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())
@@ -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
@@ -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
@@ -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>()
@@ -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
@@ -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")
+    }
+}
@@ -35,7 +35,7 @@ class ZapPaymentHandler(val account: Account) {
        pollOption: Int?,
        message: String,
        context: Context,
-        onError: (String) -> Unit,
+        onError: (String, String) -> Unit,
        onProgress: (percent: Float) -> Unit,
        onPayViaIntent: (ImmutableList<Payable>) -> Unit,
        zapType: LnZapEvent.ZapType
@@ -48,7 +48,10 @@ class ZapPaymentHandler(val account: Account) {
            val lud16 = note.author?.info?.lud16?.trim() ?: note.author?.info?.lud06?.trim()

            if (lud16.isNullOrBlank()) {
-                onError(context.getString(R.string.user_does_not_have_a_lightning_address_setup_to_receive_sats))
+                onError(
+                    context.getString(R.string.missing_lud16),
+                    context.getString(R.string.user_does_not_have_a_lightning_address_setup_to_receive_sats)
+                )
                return@withContext
            }

@@ -121,6 +124,9 @@ class ZapPaymentHandler(val account: Account) {
                    )
                } 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
@@ -149,7 +155,7 @@ class ZapPaymentHandler(val account: Account) {
        pollOption: Int?,
        message: String,
        context: Context,
-        onError: (String) -> Unit,
+        onError: (String, String) -> Unit,
        onProgress: (percent: Float) -> Unit,
        onPayInvoiceThroughIntent: (String) -> Unit,
        zapType: LnZapEvent.ZapType,
@@ -181,9 +187,13 @@ class ZapPaymentHandler(val account: Account) {
                            if (response is PayInvoiceErrorResponse) {
                                onProgress(0.0f)
                                onError(
-                                    response.error?.message
-                                        ?: response.error?.code?.toString()
-                                        ?: "Error parsing error message"
+                                    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)
@@ -192,16 +202,13 @@ class ZapPaymentHandler(val account: Account) {
                    )
                    onProgress(0.8f)
                } else {
-                    try {
-                        onPayInvoiceThroughIntent(it)
-                    } catch (e: Exception) {
-                        onError(context.getString(R.string.lightning_wallets_not_found2))
-                    }
+                    onPayInvoiceThroughIntent(it)
                    onProgress(0f)
                }
            },
            onError = onError,
-            onProgress = onProgress
+            onProgress = onProgress,
+            context = context
        )
    }
 }
@@ -1,7 +1,9 @@
 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.LnInvoiceUtil
@@ -31,13 +33,24 @@ class LightningAddressResolver() {
        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
        }

@@ -51,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: suspend (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 "?"
@@ -80,18 +116,22 @@ class LightningAddressResolver() {
            if (it.isSuccessful) {
                onSuccess(it.body.string())
            } else {
-                onError("Could not fetch invoice from $lnCallback")
+                onError(
+                    context.getString(R.string.error_unable_to_fetch_invoice),
+                    context.getString(R.string.could_not_fetch_invoice_from, lnCallback)
+                )
            }
        }
    }

-    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
        )
    }

@@ -101,8 +141,9 @@ class LightningAddressResolver() {
        message: String,
        nostrRequest: String? = null,
        onSuccess: suspend (String) -> Unit,
-        onError: (String) -> Unit,
-        onProgress: (percent: Float) -> Unit
+        onError: (String, String) -> Unit,
+        onProgress: (percent: Float) -> Unit,
+        context: Context
    ) {
        val mapper = jacksonObjectMapper()

@@ -114,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
@@ -138,7 +185,10 @@ 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
                            }

@@ -151,21 +201,40 @@ class LightningAddressResolver() {
                                    onSuccess(pr)
                                } else {
                                    onProgress(0.0f)
-                                    onError("Incorrect invoice amount (${invoiceAmount.toLong()} sats) from $lnaddress. It should have been $expectedAmountInSats")
+                                    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
        )
    }
 }
@@ -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 -> {
@@ -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 && acc.isWriteable()) {
+            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
    }
 }
@@ -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")
@@ -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)
@@ -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)
+    }
 }
@@ -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)
@@ -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()
+                }
            }
        }
    }
@@ -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
@@ -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
@@ -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))
+                }
+            }
+        }
+    )
+}
@@ -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
    )
@@ -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(
@@ -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"
@@ -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(
@@ -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? {
@@ -155,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?
+}
@@ -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
                )
            }
        )
@@ -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
                )
            }
        )
@@ -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(
@@ -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)
    )
 }
@@ -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
            )
        }

@@ -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)
        )
    }
@@ -9,9 +9,26 @@ import android.util.Size
 import android.widget.Toast
 import androidx.compose.foundation.BorderStroke
 import androidx.compose.foundation.Image
-import androidx.compose.foundation.background
 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
@@ -19,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
@@ -32,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
@@ -46,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
@@ -82,7 +115,16 @@ 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
@@ -93,6 +135,7 @@ 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
@@ -100,6 +143,7 @@ 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
@@ -118,6 +162,7 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import java.lang.Math.round

+@OptIn(ExperimentalMaterial3Api::class)
@Composable
 fun NewPostView(
    onClose: () -> Unit,
@@ -142,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 ->
@@ -186,9 +231,7 @@ fun NewPostView(
                TopAppBar(
                    title = {
                        Row(
-                            modifier = Modifier
-                                .fillMaxWidth()
-                                .padding(end = 10.dp),
+                            modifier = Modifier.fillMaxWidth(),
                            horizontalArrangement = Arrangement.SpaceBetween,
                            verticalAlignment = Alignment.CenterVertically
                        ) {
@@ -205,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()
                                    }
                                },
@@ -221,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 ->
@@ -249,7 +299,6 @@ fun NewPostView(
                ) {
                    Column(
                        modifier = Modifier
-                            .padding(top = 10.dp)
                            .imePadding()
                            .weight(1f)
                    ) {
@@ -270,7 +319,7 @@ fun NewPostView(
                                            makeItShort = true,
                                            unPackReply = false,
                                            isQuotedNote = true,
-                                            modifier = MaterialTheme.colors.replyModifier,
+                                            modifier = MaterialTheme.colorScheme.replyModifier,
                                            accountViewModel = accountViewModel,
                                            nav = nav
                                        )
@@ -339,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 = {
@@ -374,6 +423,9 @@ fun NewPostView(
                                                },
                                                onClose = {
                                                    postViewModel.wantsInvoice = false
+                                                },
+                                                onError = { title, message ->
+                                                    accountViewModel.toast(title, message)
                                                }
                                            )
                                        }
@@ -406,7 +458,7 @@ fun NewPostView(
                                                        .clip(shape = QuoteBorder)
                                                        .border(
                                                            1.dp,
-                                                            MaterialTheme.colors.subtleBorder,
+                                                            MaterialTheme.colorScheme.subtleBorder,
                                                            QuoteBorder
                                                        )
                                                )
@@ -416,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)
                                            }
@@ -463,7 +515,7 @@ fun NewPostView(
                        ) {
                            UploadFromGallery(
                                isUploading = postViewModel.isUploadingImage,
-                                tint = MaterialTheme.colors.onBackground,
+                                tint = MaterialTheme.colorScheme.onBackground,
                                modifier = Modifier
                            ) {
                                postViewModel.selectImage(it)
@@ -527,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
@@ -569,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)
@@ -581,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)
    )
 }
@@ -640,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)
        )
    }
@@ -670,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
+                )
            )
        }

@@ -707,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
+                )
            )
        }

@@ -772,7 +819,7 @@ fun FowardZapTo(postViewModel: NewPostViewModel, accountViewModel: AccountViewMo

        Text(
            text = stringResource(R.string.zap_split_explainer),
-            color = MaterialTheme.colors.placeholderText,
+            color = MaterialTheme.colorScheme.placeholderText,
            modifier = Modifier.padding(vertical = 10.dp)
        )

@@ -817,12 +864,12 @@ fun FowardZapTo(postViewModel: NewPostViewModel, accountViewModel: AccountViewMo
            placeholder = {
                Text(
                    text = stringResource(R.string.zap_split_serarch_and_add_user_placeholder),
-                    color = MaterialTheme.colors.placeholderText
+                    color = MaterialTheme.colorScheme.placeholderText
                )
            },
            singleLine = true,
            visualTransformation = UrlUserTagTransformation(
-                MaterialTheme.colors.primary
+                MaterialTheme.colorScheme.primary
            ),
            textStyle = LocalTextStyle.current.copy(textDirection = TextDirection.Content)
        )
@@ -870,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
                    )
                }

@@ -890,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)
            )
        }
@@ -951,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)
            )

@@ -965,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)
@@ -1024,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,
@@ -1032,7 +1079,7 @@ private fun AddZapraiserButton(
                    modifier = Modifier
                        .size(13.dp)
                        .align(Alignment.BottomEnd),
-                    tint = MaterialTheme.colors.onBackground
+                    tint = MaterialTheme.colorScheme.onBackground
                )
            } else {
                Icon(
@@ -1068,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
            )
        }
    }
@@ -1096,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(
@@ -1131,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,
@@ -1139,7 +1186,7 @@ private fun ForwardZapTo(
                    modifier = Modifier
                        .size(13.dp)
                        .align(Alignment.CenterEnd),
-                    tint = MaterialTheme.colors.onBackground
+                    tint = MaterialTheme.colorScheme.onBackground
                )
            } else {
                Icon(
@@ -1185,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,
@@ -1193,7 +1240,7 @@ private fun MarkAsSensitive(
                    modifier = Modifier
                        .size(10.dp)
                        .align(Alignment.TopEnd),
-                    tint = MaterialTheme.colors.onBackground
+                    tint = MaterialTheme.colorScheme.onBackground
                )
            } else {
                Icon(
@@ -1219,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()
    }
@@ -1237,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)
    }
@@ -1256,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))
    }
 }

@@ -1282,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)
    }
@@ -1320,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("") }
@@ -1334,7 +1359,7 @@ fun ImageVideoDescription(
            .clip(shape = QuoteBorder)
            .border(
                1.dp,
-                MaterialTheme.colors.subtleBorder,
+                MaterialTheme.colorScheme.subtleBorder,
                QuoteBorder
            )
    ) {
@@ -1435,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
                    },
@@ -1476,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(
@@ -1495,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)
@@ -1529,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
            )
        }

@@ -14,7 +14,11 @@ 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
@@ -23,6 +27,7 @@ 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
@@ -32,6 +37,7 @@ 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
@@ -45,6 +51,7 @@ enum class UserSuggestionAnchor {

@Stable
 open class NewPostViewModel() : ViewModel() {
+    var accountViewModel: AccountViewModel? = null
    var account: Account? = null
    var requiresNIP24: Boolean = false

@@ -56,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
@@ -115,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) {
@@ -147,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

@@ -160,14 +167,26 @@ open class NewPostViewModel() : ViewModel() {
        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

@@ -285,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

@@ -300,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(
@@ -311,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)
@@ -523,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)
@@ -554,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)
@@ -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)
@@ -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
@@ -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
                            )
                        }
                    )
@@ -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)
@@ -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)
@@ -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
+                                        )
                                    }
                                )
                            }
@@ -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))
    }
 }
@@ -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
    )
 }

@@ -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,
@@ -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(
@@ -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),
@@ -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
            )
@@ -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),
@@ -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) }
@@ -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)
@@ -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)
    )
 }

@@ -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)
    )
 }
@@ -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)
    )
 }

@@ -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)
                    )
                }
            )
@@ -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)
    )
 }
@@ -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)
    )
 }
@@ -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)
    )
 }
@@ -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)
    ) {
@@ -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)
@@ -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)
@@ -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
+    }
+}
@@ -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
@@ -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)
+        }
+    }
+}
@@ -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
@@ -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)
                    ) {
@@ -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(
@@ -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)
@@ -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
+)
@@ -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)
            }
        }
    }
@@ -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,8 +62,6 @@ 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
@@ -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)
                }
            }
        }
@@ -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(
@@ -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)
@@ -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()
+        }
    }
 }
@@ -5,7 +5,9 @@ import com.vitorpamplona.amethyst.model.GLOBAL_FOLLOWS
 import com.vitorpamplona.amethyst.model.LocalCache
 import com.vitorpamplona.amethyst.model.Note
 import com.vitorpamplona.amethyst.model.ParticipantListBuilder
-import com.vitorpamplona.quartz.events.*
+import com.vitorpamplona.quartz.events.ChannelCreateEvent
+import com.vitorpamplona.quartz.events.IsInPublicChatChannel
+import com.vitorpamplona.quartz.events.PeopleListEvent
 import com.vitorpamplona.quartz.utils.TimeUtils

 open class DiscoverChatFeedFilter(val account: Account) : AdditiveFeedFilter<Note>() {
@@ -14,7 +16,7 @@ open class DiscoverChatFeedFilter(val account: Account) : AdditiveFeedFilter<Not
    }

    override fun showHiddenKey(): Boolean {
-        return account.defaultDiscoveryFollowList == PeopleListEvent.blockList
+        return account.defaultDiscoveryFollowList == PeopleListEvent.blockListFor(account.userProfile().pubkeyHex)
    }

    override fun feed(): List<Note> {
@@ -5,7 +5,9 @@ import com.vitorpamplona.amethyst.model.GLOBAL_FOLLOWS
 import com.vitorpamplona.amethyst.model.LocalCache
 import com.vitorpamplona.amethyst.model.Note
 import com.vitorpamplona.amethyst.model.ParticipantListBuilder
-import com.vitorpamplona.quartz.events.*
+import com.vitorpamplona.quartz.events.CommunityDefinitionEvent
+import com.vitorpamplona.quartz.events.CommunityPostApprovalEvent
+import com.vitorpamplona.quartz.events.PeopleListEvent
 import com.vitorpamplona.quartz.utils.TimeUtils

 open class DiscoverCommunityFeedFilter(val account: Account) : AdditiveFeedFilter<Note>() {
@@ -14,7 +16,7 @@ open class DiscoverCommunityFeedFilter(val account: Account) : AdditiveFeedFilte
    }

    override fun showHiddenKey(): Boolean {
-        return account.defaultDiscoveryFollowList == PeopleListEvent.blockList
+        return account.defaultDiscoveryFollowList == PeopleListEvent.blockListFor(account.userProfile().pubkeyHex)
    }

    override fun feed(): List<Note> {
@@ -5,10 +5,11 @@ import com.vitorpamplona.amethyst.model.GLOBAL_FOLLOWS
 import com.vitorpamplona.amethyst.model.LocalCache
 import com.vitorpamplona.amethyst.model.Note
 import com.vitorpamplona.amethyst.model.ParticipantListBuilder
-import com.vitorpamplona.quartz.events.*
+import com.vitorpamplona.quartz.events.LiveActivitiesEvent
 import com.vitorpamplona.quartz.events.LiveActivitiesEvent.Companion.STATUS_ENDED
 import com.vitorpamplona.quartz.events.LiveActivitiesEvent.Companion.STATUS_LIVE
 import com.vitorpamplona.quartz.events.LiveActivitiesEvent.Companion.STATUS_PLANNED
+import com.vitorpamplona.quartz.events.PeopleListEvent
 import com.vitorpamplona.quartz.utils.TimeUtils

 open class DiscoverLiveFeedFilter(
@@ -23,7 +24,7 @@ open class DiscoverLiveFeedFilter(
    }

    override fun showHiddenKey(): Boolean {
-        return followList() == PeopleListEvent.blockList
+        return followList() == PeopleListEvent.blockListFor(account.userProfile().pubkeyHex)
    }

    override fun feed(): List<Note> {
@@ -5,7 +5,7 @@ import com.vitorpamplona.amethyst.model.GLOBAL_FOLLOWS
 import com.vitorpamplona.amethyst.model.KIND3_FOLLOWS
 import com.vitorpamplona.amethyst.model.Note
 import com.vitorpamplona.amethyst.service.OnlineChecker
-import com.vitorpamplona.quartz.events.*
+import com.vitorpamplona.quartz.events.LiveActivitiesEvent
 import com.vitorpamplona.quartz.events.LiveActivitiesEvent.Companion.STATUS_LIVE

 class DiscoverLiveNowFeedFilter(
@@ -14,13 +14,50 @@ class HiddenAccountsFeedFilter(val account: Account) : FeedFilter<User>() {
    }

    override fun feed(): List<User> {
-        return account.getBlockList()
+        val blockList = account.getBlockList()
+        val decryptedContent = blockList?.decryptedContent ?: ""
+        if (account.loginWithExternalSigner) {
+            if (decryptedContent.isEmpty()) return emptyList()
+
+            return blockList
+                ?.publicAndPrivateUsers(decryptedContent)
+                ?.map { LocalCache.getOrCreateUser(it) }
+                ?: emptyList()
+        }
+
+        return blockList
            ?.publicAndPrivateUsers(account.keyPair.privKey)
            ?.map { LocalCache.getOrCreateUser(it) }
            ?: emptyList()
    }
 }

+class HiddenWordsFeedFilter(val account: Account) : FeedFilter<String>() {
+    override fun feedKey(): String {
+        return account.userProfile().pubkeyHex
+    }
+
+    override fun showHiddenKey(): Boolean {
+        return true
+    }
+
+    override fun feed(): List<String> {
+        val blockList = account.getBlockList()
+        val decryptedContent = blockList?.decryptedContent ?: ""
+        if (account.loginWithExternalSigner) {
+            if (decryptedContent.isEmpty()) return emptyList()
+
+            return blockList
+                ?.publicAndPrivateWords(decryptedContent)?.toList()
+                ?: emptyList()
+        }
+
+        return blockList
+            ?.publicAndPrivateWords(account.keyPair.privKey)?.toList()
+            ?: emptyList()
+    }
+}
+
 class SpammerAccountsFeedFilter(val account: Account) : FeedFilter<User>() {
    override fun feedKey(): String {
        return account.userProfile().pubkeyHex
@@ -18,7 +18,7 @@ class HomeConversationsFeedFilter(val account: Account) : AdditiveFeedFilter<Not
    }

    override fun showHiddenKey(): Boolean {
-        return account.defaultHomeFollowList == PeopleListEvent.blockList
+        return account.defaultHomeFollowList == PeopleListEvent.blockListFor(account.userProfile().pubkeyHex)
    }

    override fun feed(): List<Note> {
@@ -17,12 +17,13 @@ import com.vitorpamplona.quartz.events.TextNoteEvent
 import com.vitorpamplona.quartz.utils.TimeUtils

 class HomeNewThreadFeedFilter(val account: Account) : AdditiveFeedFilter<Note>() {
+
    override fun feedKey(): String {
        return account.userProfile().pubkeyHex + "-" + account.defaultHomeFollowList
    }

    override fun showHiddenKey(): Boolean {
-        return account.defaultHomeFollowList == PeopleListEvent.blockList
+        return account.defaultHomeFollowList == PeopleListEvent.blockListFor(account.userProfile().pubkeyHex)
    }

    override fun feed(): List<Note> {
--- a/Show More
+++ b/Show More