v1.08.0

Fix mention styling by deferring style application until after text mutations

.claude/CLAUDE.md

@@ -1,8 +1,14 @@
-# Amethyst Desktop Fork
+# Amethyst
 
 ## Project Overview
 
-Fork of [Amethyst](https://github.com/vitorpamplona/amethyst) adding Compose Multiplatform Desktop support. Quartz library converted to full KMP for code sharing between Android and Desktop JVM.
+Amethyst is a Nostr Client for Android that was made for Android-only and has been slowly switching
+over to a Kotlin Multiplatform project. This project has 4 main modules: `quartz`, `commons`,
+`amethyst` and `desktopApp`. Quartz should contain implementations of Nostr specifications and
+utilities to help implement them. Commons stores shared code between Amethyst Android (`amethyst`)
+and Amethyst Desktop (`desktopApp`). The Desktop App is designed to be mouse first and so uses a
+completely different screen and navigation architecture while sharing the back end components with
+the android counterpart.
 
 ## Architecture
 
@@ -12,7 +18,8 @@ amethyst/
 │   └── src/
 │       ├── commonMain/    # Shared Nostr protocol, data models
 │       ├── androidMain/   # Android-specific (crypto, storage)
-│       └── jvmMain/       # Desktop JVM-specific
+│       ├── jvmMain/       # Desktop JVM-specific
+│       └── iosMain/       # iOS-specific
 ├── commons/        # Shared UI components (convert to KMP)
 │   └── src/
 │       ├── commonMain/    # Shared composables, icons, state
@@ -20,12 +27,12 @@ amethyst/
 │       └── jvmMain/       # Desktop-specific UI utilities
 ├── desktopApp/     # Desktop JVM application (layouts, navigation)
 ├── amethyst/       # Android app (layouts, navigation)
-└── ammolite/       # Support module
+└── ammolite/       # Support module (unused)
 ```
 
 **Sharing Philosophy:**
-- `quartz/` = Business logic, protocol, data (no UI)
-- `commons/` = Shared UI components, icons, composables, **ViewModels**
+- `quartz/` = Nostr business logic, protocol, data (no UI)
+- `commons/` = Shared UI components, icons, composables, flows and ViewModels
 - `amethyst/` & `desktopApp/` = Platform-native layouts and navigation
 
 ## Tech Stack
@@ -241,6 +248,13 @@ actual fun openExternalUrl(url: String) {
 }
 ```
 
+## Code Formatting
+After completing any task that modifies Kotlin files, always run:
+```
+./gradlew spotlessApply
+```
+Do this before considering the task complete.
+
 ### Navigation Shell
 - **Desktop**: Sidebar + main content area
 - **Android**: Bottom navigation

.claude/core-skills-plan.md

@@ -119,7 +119,7 @@ Create 8 hybrid domain skills combining general expertise with AmethystMultiplat
 **Focus:** iosMain patterns, Swift/KMP interop, XCFramework generation
 
 **SKILL.md sections:**
-- iOS source sets: iosMain, iosX64Main, iosArm64Main
+- iOS source sets: iosMain, iosArm64Main
 - Swift interop: type mapping, nullability
 - expect/actual iOS: 10+ examples from quartz/iosMain
 - XCFramework setup: baseName = "quartz-kmpKit"

.claude/hooks/session-start.sh

@@ -0,0 +1,180 @@
+#!/bin/bash
+# Session start hook: Configure proxy auth, SSL trust, and Android SDK for Claude Code on the web
+set -euo pipefail
+
+# Only run in remote (web) environments
+if [ "${CLAUDE_CODE_REMOTE:-}" != "true" ]; then
+  exit 0
+fi
+
+# --- Proxy credentials: configure Maven/Gradle if authenticated proxy is set ---
+proxy="${https_proxy:-${HTTPS_PROXY:-}}"
+if [ -n "$proxy" ] && echo "$proxy" | grep -q '@'; then
+  rest="${proxy#*://}"
+  userpass="${rest%@*}"
+  hostport="${rest##*@}"
+  user="${userpass%%:*}"
+  pass="${userpass#*:}"
+  host="${hostport%%:*}"
+  port="${hostport##*:}"
+  port="${port%/}"
+
+  mkdir -p ~/.m2
+  cat > ~/.m2/settings.xml << EOF
+<settings>
+  <proxies>
+    <proxy>
+      <id>ccw</id><active>true</active><protocol>https</protocol>
+      <host>$host</host><port>$port</port>
+      <username>$user</username>
+      <password><![CDATA[$pass]]></password>
+    </proxy>
+  </proxies>
+</settings>
+EOF
+
+  # Force wagon transport for Maven 3.9+ proxy auth compatibility
+  cat > ~/.mavenrc << 'MAVENRC'
+MAVEN_OPTS="$MAVEN_OPTS -Dmaven.resolver.transport=wagon"
+MAVENRC
+
+  mkdir -p ~/.gradle
+  cat > ~/.gradle/gradle.properties << EOF
+systemProp.https.proxyHost=$host
+systemProp.https.proxyPort=$port
+systemProp.https.proxyUser=$user
+systemProp.https.proxyPassword=$pass
+systemProp.http.proxyHost=$host
+systemProp.http.proxyPort=$port
+systemProp.http.proxyUser=$user
+systemProp.http.proxyPassword=$pass
+# Override nonProxyHosts: route all external traffic (incl. *.google.com) through proxy
+systemProp.http.nonProxyHosts=localhost|127.0.0.1
+systemProp.https.nonProxyHosts=localhost|127.0.0.1
+# Use Ubuntu's Java trust store (includes Anthropic TLS inspection CA) for all Gradle JVMs.
+# This is needed because Gradle may download a custom JDK (e.g. JetBrains) whose bundled
+# trust store doesn't include the Anthropic CA, causing TLS inspection failures.
+systemProp.javax.net.ssl.trustStore=/etc/ssl/certs/java/cacerts
+systemProp.javax.net.ssl.trustStoreType=JKS
+systemProp.javax.net.ssl.trustStorePassword=changeit
+systemProp.jdk.http.auth.tunneling.disabledSchemes=
+systemProp.jdk.http.auth.proxying.disabledSchemes=
+EOF
+
+  echo "Configured Maven/Gradle proxy from HTTPS_PROXY" >&2
+fi
+
+# --- SSL trust: import Anthropic TLS inspection CA into JVM trust stores ---
+ANTHROPIC_CA_PEM=$(python3 -c "
+import re, ssl, sys
+try:
+    with open('/etc/ssl/certs/ca-certificates.crt') as f:
+        certs = re.findall(r'-----BEGIN CERTIFICATE-----.*?-----END CERTIFICATE-----', f.read(), re.DOTALL)
+    for cert in certs:
+        der = ssl.PEM_cert_to_DER_cert(cert)
+        if b'Anthropic' in der and b'sandbox-egress-production' in der:
+            print(cert)
+            break
+except Exception as e:
+    sys.stderr.write(f'CA extraction failed: {e}\n')
+" 2>/dev/null)
+
+if [ -n "$ANTHROPIC_CA_PEM" ]; then
+  TMPCA=$(mktemp /tmp/anthropic-ca.XXXXXX.pem)
+  echo "$ANTHROPIC_CA_PEM" > "$TMPCA"
+  for cacerts in \
+    /usr/lib/jvm/java-21-openjdk-amd64/lib/security/cacerts \
+    /root/.gradle/jdks/*/lib/security/cacerts; do
+    [ -f "$cacerts" ] || continue
+    keytool -list -keystore "$cacerts" -storepass changeit \
+      -alias anthropic-egress-production-ca >/dev/null 2>&1 && continue
+    keytool -import \
+      -alias anthropic-egress-production-ca \
+      -file "$TMPCA" \
+      -keystore "$cacerts" \
+      -storepass changeit \
+      -noprompt >/dev/null 2>&1 && \
+      echo "Imported Anthropic CA into $cacerts" >&2
+  done
+  rm -f "$TMPCA"
+fi
+
+ANDROID_SDK_DIR="/root/android-sdk"
+SDK_REPO_BASE="https://dl.google.com/android/repository"
+
+# Install Android SDK packages by downloading directly with curl
+# (sdkmanager cannot reach the SDK repository through the proxy)
+install_sdk_package() {
+  local zip_url="$1"
+  local dest_dir="$2"
+  local inner_dir="$3"  # top-level dir inside the zip
+
+  if [ -d "$dest_dir" ]; then
+    return 0
+  fi
+
+  echo "Downloading $zip_url..."
+  local TMP_ZIP
+  TMP_ZIP=$(mktemp /tmp/sdk-pkg.XXXXXX.zip)
+  curl -fsSL "$zip_url" -o "$TMP_ZIP"
+
+  local TMP_DIR
+  TMP_DIR=$(mktemp -d)
+  unzip -q "$TMP_ZIP" -d "$TMP_DIR"
+  rm -f "$TMP_ZIP"
+
+  mkdir -p "$(dirname "$dest_dir")"
+  mv "$TMP_DIR/$inner_dir" "$dest_dir"
+  rm -rf "$TMP_DIR"
+  echo "Installed to $dest_dir"
+}
+
+# Install Android platform 36
+install_sdk_package \
+  "$SDK_REPO_BASE/platform-36_r02.zip" \
+  "$ANDROID_SDK_DIR/platforms/android-36" \
+  "android-36"
+
+# Install build-tools 36.0.0 (zip uses "android-16" as inner dir name)
+install_sdk_package \
+  "$SDK_REPO_BASE/build-tools_r36_linux.zip" \
+  "$ANDROID_SDK_DIR/build-tools/36.0.0" \
+  "android-16"
+
+# Install platform-tools
+install_sdk_package \
+  "$SDK_REPO_BASE/platform-tools_r37.0.0-linux.zip" \
+  "$ANDROID_SDK_DIR/platform-tools" \
+  "platform-tools"
+
+# Accept SDK licenses (create license files manually)
+echo "Writing SDK license files..."
+mkdir -p "$ANDROID_SDK_DIR/licenses"
+# android-sdk-license
+echo -e "\n24333f8a63b6825ea9c5514f83c2829b004d1fee" > "$ANDROID_SDK_DIR/licenses/android-sdk-license"
+echo -e "\n84831b9409646a918e30573bab4c9c91346d8abd" >> "$ANDROID_SDK_DIR/licenses/android-sdk-license"
+# android-sdk-preview-license
+echo -e "\n84831b9409646a918e30573bab4c9c91346d8abd" > "$ANDROID_SDK_DIR/licenses/android-sdk-preview-license"
+echo -e "\n504667f4c0de7af1a06de9f4b1727b84351f2910" >> "$ANDROID_SDK_DIR/licenses/android-sdk-preview-license"
+# intel-android-extra-license
+echo -e "\nd975f751698a77b662f1254ddbeed3901e976f5a" > "$ANDROID_SDK_DIR/licenses/intel-android-extra-license"
+
+# Create local.properties if missing
+REPO_ROOT="$(git -C "$(dirname "$0")" rev-parse --show-toplevel 2>/dev/null || echo "${CLAUDE_PROJECT_DIR:-/home/user/Amber}")"
+LOCAL_PROPS="$REPO_ROOT/local.properties"
+if [ ! -f "$LOCAL_PROPS" ]; then
+  echo "sdk.dir=$ANDROID_SDK_DIR" > "$LOCAL_PROPS"
+  echo "Created local.properties with sdk.dir=$ANDROID_SDK_DIR"
+fi
+
+# Export ANDROID_HOME for the session
+if [ -n "${CLAUDE_ENV_FILE:-}" ]; then
+  echo "export ANDROID_HOME=$ANDROID_SDK_DIR" >> "$CLAUDE_ENV_FILE"
+  echo "export ANDROID_SDK_ROOT=$ANDROID_SDK_DIR" >> "$CLAUDE_ENV_FILE"
+  echo "export PATH=\$PATH:$ANDROID_SDK_DIR/platform-tools" >> "$CLAUDE_ENV_FILE"
+fi
+
+cd "$CLAUDE_PROJECT_DIR"
+./gradlew --version > /dev/null 2>&1
+
+echo "Android SDK setup complete."

.claude/settings.json

@@ -0,0 +1,26 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/session-start.sh"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "./gradlew spotlessApply 2>/dev/null || spotless-apply",
+            "timeout": 120
+          }
+        ]
+      }
+    ]
+  }
+}

.claude/skills/android-expert/SKILL.md

@@ -745,8 +745,8 @@ android {
         applicationId = "com.vitorpamplona.amethyst"
         minSdk = 26          // Android 8.0 (Oreo)
         targetSdk = 36       // Android 15
-        versionCode = 430
-        versionName = "1.04.2"
+        versionCode = 442
+        versionName = "1.08.0"
 
         vectorDrawables {
             useSupportLibrary = true

.claude/skills/find-missing-translations/SKILL.md

@@ -0,0 +1,96 @@
+---
+name: find-missing-translations
+description: Use when comparing Android strings.xml locale files to find untranslated string resources, missing translation keys, or preparing translation work for a specific language
+---
+
+# Find Missing Translations
+
+## Overview
+
+Extract string resource keys from the default `values/strings.xml` that are absent in a target locale's `strings.xml`, excluding non-translatable entries. Outputs missing keys and offers to translate them.
+
+## When to Use
+
+- Need to find untranslated strings for a specific locale
+- Preparing a batch of strings for a translator
+- Checking translation coverage after adding new features
+
+## Target Locales
+
+The default set of locales (unless the user specifies otherwise):
+
+| Locale | Language | Directory |
+|--------|----------|-----------|
+| `cs-rCZ` | Czech | `values-cs-rCZ` |
+| `pt-rBR` | Brazilian Portuguese | `values-pt-rBR` |
+| `sv-rSE` | Swedish | `values-sv-rSE` |
+| `de-rDE` | German | `values-de-rDE` |
+
+## Technique
+
+### 1. Identify files
+
+```
+Default:  amethyst/src/main/res/values/strings.xml
+Target:   amethyst/src/main/res/values-<locale>/strings.xml
+```
+
+### 2. Find missing keys using cs-rCZ as reference
+
+Always diff against `cs-rCZ` first — it is the most complete locale and serves as the reference. Any keys missing in `cs-rCZ` will also be missing in the other target locales.
+
+```bash
+# Extract translatable keys from default (exclude translatable="false")
+comm -23 \
+  <(grep '<string name=' amethyst/src/main/res/values/strings.xml \
+    | grep -v 'translatable="false"' \
+    | sed 's/.*name="\([^"]*\)".*/\1/' | sort) \
+  <(grep '<string name=' amethyst/src/main/res/values-cs-rCZ/strings.xml \
+    | sed 's/.*name="\([^"]*\)".*/\1/' | sort)
+```
+
+This gives the list of missing key names. Do NOT diff each locale separately — assume the same keys are missing in all target locales.
+
+### 3. Get English values for missing keys
+
+For each missing key, extract its English value:
+
+```bash
+# For each missing key, extract the full line from default strings.xml
+while IFS= read -r key; do
+  grep "name=\"$key\"" amethyst/src/main/res/values/strings.xml
+done < <(comm -23 \
+  <(grep '<string name=' amethyst/src/main/res/values/strings.xml \
+    | grep -v 'translatable="false"' \
+    | sed 's/.*name="\([^"]*\)".*/\1/' | sort) \
+  <(grep '<string name=' amethyst/src/main/res/values-cs-rCZ/strings.xml \
+    | sed 's/.*name="\([^"]*\)".*/\1/' | sort))
+```
+
+### 4. Present results and ask to translate
+
+Output the missing entries as raw XML resource lines (copy-paste ready):
+
+```xml
+    <string name="attestation_valid">Valid</string>
+    <string name="attestation_valid_from">Valid from %1$s</string>
+    <string name="feed_group_lists">Lists</string>
+```
+
+Also check `<string-array>` and `<plurals>` tags using the same approach if the project uses them.
+
+**Then ask the user:** "Would you like me to translate these missing strings into [list of target locales]?"
+
+### 5. Adding translations (if approved)
+
+When adding translated strings to locale files:
+
+- **Append new strings at the bottom** of the file, just before the closing `</resources>` tag.
+- Do NOT try to insert them in alphabetical or matching order — a separate process handles ordering.
+
+## Common Mistakes
+
+- **Forgetting `translatable="false"`** — these should never appear in locale files
+- **Not checking string-arrays/plurals** — only checking `<string>` misses other resource types
+- **Diffing each locale separately** — only diff against `cs-rCZ`; assume the same keys are missing everywhere
+- **Inserting strings in a specific position** — always append at the bottom; ordering is handled separately

.claude/skills/find-non-lambda-logs/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: find-non-lambda-logs
+description: Use when auditing or migrating Log calls to lambda overloads, after adding new logging, or checking for string interpolation in Log.d/i/w/e calls that waste allocations when the log level is filtered out
+---
+
+# Find Non-Lambda Log Calls
+
+## Overview
+
+Locates `Log.d/i/w/e` calls that use string interpolation without the lambda overload, wasting string allocation when the log level is filtered out in release builds.
+
+## When to Use
+
+- After merging branches that add new logging
+- Periodic audit of logging hygiene
+- After migrating `android.util.Log` usages to the shared `Log` wrapper
+
+## What to Flag
+
+Calls with **string interpolation** (`$` in message) that do **not** pass a throwable:
+
+```kotlin
+// FLAG - interpolation without lambda, no throwable
+Log.d("Tag", "Processing ${event.id}")
+Log.w("Tag", "Failed for $url")
+
+// IGNORE - passes throwable (lambda overload doesn't accept throwable)
+Log.w("Tag", "Error: ${e.message}", e)
+Log.e("Tag", "Failed for $url", throwable)
+
+// IGNORE - no interpolation (no allocation benefit from lambda)
+Log.d("Tag", "Initialization complete")
+```
+
+## Search Commands
+
+**Important:** Tags can be string literals (`"Tag"`) or variables (`tag`, `LOG_TAG`). Run both patterns for each step.
+
+### Step 1: Find interpolated Log.d/Log.i (highest priority — filtered in release)
+
+```
+pattern: Log\.(d|i)\("[^"]+",\s*"[^"]*\$
+type: kotlin
+```
+```
+pattern: Log\.(d|i)\(\w+,\s*"[^"]*\$
+type: kotlin
+```
+
+### Step 2: Find interpolated Log.w/Log.e without throwable
+
+```
+pattern: Log\.(w|e)\("[^"]+",\s*"[^"]*\$
+type: kotlin
+```
+```
+pattern: Log\.(w|e)\(\w+,\s*"[^"]*\$
+type: kotlin
+```
+
+Then **manually exclude** lines where a throwable is passed as third argument (ending with `, e)`, `, throwable)`, etc.). Check the actual line — a catch block catching `e` doesn't mean `e` is passed to the Log call.
+
+### Step 3: Verify no android.util.Log leakage
+
+```
+pattern: android\.util\.Log\.(d|i|w|e|v)\(
+type: kotlin
+```
+
+These bypass the `Log.minLevel` filter entirely. Exclude `PlatformLog.android.kt` which is the wrapper implementation.
+
+## Fix Pattern
+
+```kotlin
+// Before
+Log.d("Tag", "Processing event ${event.id} from ${relay.url}")
+
+// After
+Log.d("Tag") { "Processing event ${event.id} from ${relay.url}" }
+```
+
+## Do NOT Convert
+
+- Calls passing a `Throwable` parameter - the lambda overload `(tag) { message }` has no throwable parameter
+- Static string calls with no `$` interpolation - no allocation benefit
+- Commented-out log calls

.claude/skills/gradle-expert/references/dependency-graph.md

@@ -47,7 +47,7 @@
 
 ### :quartz (KMP Nostr Library)
 **Type:** Kotlin Multiplatform Library
-**Targets:** JVM, Android, iOS (iosX64, iosArm64, iosSimulatorArm64)
+**Targets:** JVM, Android, iOS (iosArm64, iosSimulatorArm64)
 **Dependencies:**
 - External: secp256k1, jackson, okhttp, kotlinx.coroutines, kotlinx.collections.immutable
 - Source sets: commonMain → jvmAndroid → {androidMain, jvmMain}, iosMain
@@ -127,7 +127,6 @@ commonMain (base)
     │   ├─ androidMain (Android platform)
     │   └─ jvmMain (Desktop platform)
     └─ iosMain (iOS platform)
-        ├─ iosX64Main
         ├─ iosArm64Main
         └─ iosSimulatorArm64Main
 ```

.claude/skills/kotlin-multiplatform/SKILL.md

@@ -110,8 +110,8 @@ Think of source sets as a dependency graph, not folders.
    │ - Jackson         │  │                  │
    │ - OkHttp          │  └────┬─────────────┘
    └───┬───────────┬───┘       │
-       │           │            ├─→ iosX64Main
-       ▼           ▼            ├─→ iosArm64Main
+       │           │           │
+       ▼           ▼           ├─→ iosArm64Main
   ┌─────────┐ ┌──────────┐     └─→ iosSimulatorArm64Main
   │android  │ │jvmMain   │
   │Main     │ │(Desktop) │
@@ -252,7 +252,7 @@ expect fun currentTimeSeconds(): Long
 
 **iOS (iosMain):**
 - Active development, framework configured
-- Architecture targets: iosX64Main, iosArm64Main, iosSimulatorArm64Main
+- Architecture targets: macosArm64Main, iosArm64Main, iosSimulatorArm64Main
 - Platform APIs via platform.posix, Security framework
 
 ### Web, wasm - Future Targets

.claude/skills/kotlin-multiplatform/references/source-set-hierarchy.md

@@ -29,7 +29,7 @@ Visual guide to source set organization with concrete examples from the codebase
 │  - Jackson       │    │   - Platform libs │
 │  - OkHttp        │    └───────┬───────────┘
 └────┬─────────┬───┘            │
-     │         │                ├─→ iosX64Main (simulator Intel)
+     │         │                │
      │         │                ├─→ iosArm64Main (device ARM64)
      │         │                └─→ iosSimulatorArm64Main (Apple Silicon)
      ▼         ▼
@@ -238,7 +238,6 @@ iosMain {
     }
 }
 
-val iosX64Main by getting { dependsOn(iosMain.get()) }
 val iosArm64Main by getting { dependsOn(iosMain.get()) }
 val iosSimulatorArm64Main by getting { dependsOn(iosMain.get()) }
 ```
@@ -249,7 +248,6 @@ val iosSimulatorArm64Main by getting { dependsOn(iosMain.get()) }
 - Different from Android/Desktop
 
 **Architecture targets:**
-- iosX64Main: Intel simulator
 - iosArm64Main: Device (iPhone, iPad)
 - iosSimulatorArm64Main: Apple Silicon simulator
 
@@ -326,7 +324,7 @@ commonMain
 | androidMain | jvmAndroid | Android framework | Activity, ViewModel |
 | jvmMain | jvmAndroid | JVM + Compose Desktop | Window, MenuBar |
 | iosMain | commonMain | iOS platform | Security framework |
-| iosX64Main | iosMain | Simulator (Intel) | Architecture-specific |
+| iosMain | Simulator (Intel) | Architecture-specific |
 | iosArm64Main | iosMain | Device (ARM64) | Architecture-specific |
 | jsMain | commonMain | JS/DOM | Web (future) |
 | wasmMain | commonMain | wasm APIs | WebAssembly (future) |

.claude/skills/kotlin-multiplatform/references/target-compatibility.md

@@ -76,7 +76,6 @@ fun main() = application {
 
 **Source sets:**
 - iosMain (common iOS code)
-- iosX64Main (Intel simulator)
 - iosArm64Main (device - iPhone/iPad)
 - iosSimulatorArm64Main (Apple Silicon simulator)
 
@@ -110,7 +109,7 @@ actual object Secp256k1Instance {
 ```kotlin
 // quartz/build.gradle.kts
 kotlin {
-    listOf(iosX64(), iosArm64(), iosSimulatorArm64())
+    listOf(macosArm64(), iosArm64(), iosSimulatorArm64())
         .forEach { target ->
             target.binaries.framework {
                 baseName = "quartz-kmpKit"
@@ -310,7 +309,7 @@ fun parseJson(json: String): Event {
 - Manual desktop app testing
 
 **iOS:**
-- Unit tests: iosTest (iosX64Test, iosArm64Test, etc.)
+- Unit tests: iosTest (iosArm64Test, etc.)
 - Simulator/device testing
 
 **Web (future):**

.claude/skills/quartz-integration/SKILL.md

@@ -0,0 +1,671 @@
+---
+name: quartz-integration
+description: Integration guide for using the Quartz Nostr KMP library in external projects. Use when: (1) adding Quartz as a Gradle dependency, (2) setting up NostrClient with WebSocket, (3) creating/signing/sending events, (4) building relay subscriptions with Filter, (5) handling keys with KeyPair/NostrSignerInternal, (6) using Bech32 encoding/decoding (NIP-19), (7) platform-specific setup (Android vs JVM/Desktop), (8) NIP-57 zaps, NIP-17 DMs, NIP-44 encryption in external projects.
+---
+
+# Quartz Integration Guide
+
+Reference for integrating `com.vitorpamplona.quartz:quartz` into external Nostr KMP projects.
+
+**Published artifact**: `com.vitorpamplona.quartz:quartz:1.08.0` (Maven Central)
+**Targets**: JVM 21+, Android (minSdk 21+), iOS (XCFramework `quartz-kmpKit`)
+**License**: MIT
+
+---
+
+## 1. Gradle Setup
+
+### Version Catalog (`libs.versions.toml`)
+
+```toml
+[versions]
+quartz = "1.08.0"
+
+[libraries]
+quartz = { module = "com.vitorpamplona.quartz:quartz", version.ref = "quartz" }
+```
+
+### `build.gradle.kts` (KMP project)
+
+```kotlin
+kotlin {
+    sourceSets {
+        commonMain.dependencies {
+            implementation(libs.quartz)
+        }
+    }
+}
+```
+
+### Android-only project
+
+```kotlin
+dependencies {
+    implementation("com.vitorpamplona.quartz:quartz:1.08.0")
+}
+```
+
+### Transitive dependencies pulled in automatically
+
+Quartz exposes these as `api` (you get them transitively):
+
+| Dependency | Used for |
+|-----------|----------|
+| `fr.acinq.secp256k1:secp256k1-kmp-*` | Schnorr signing |
+| `com.github.anthonynsimon:rfc3986-normalizer` | Relay URL normalization |
+| `com.fasterxml.jackson.module:jackson-module-kotlin` | Event JSON parsing |
+
+For Android, add to `build.gradle.kts`:
+```kotlin
+android {
+    packaging {
+        resources.excludes += "/META-INF/{AL2.0,LGPL2.1}"
+    }
+}
+```
+
+---
+
+## 2. Key Concepts
+
+### Core Types
+
+```kotlin
+typealias HexKey = String        // 64-char hex string (pubkey, event id, sig)
+typealias Kind = Int             // Event kind number
+typealias TagArray = Array<Array<String>>
+```
+
+### Event Anatomy
+
+```kotlin
+@Immutable
+open class Event(
+    val id: HexKey,        // SHA-256 of canonical JSON (64 hex chars)
+    val pubKey: HexKey,    // Author public key (64 hex chars)
+    val createdAt: Long,   // Unix timestamp (seconds)
+    val kind: Kind,        // Event type
+    val tags: TagArray,    // [["e","eventid"], ["p","pubkey"], ...]
+    val content: String,
+    val sig: HexKey,       // Schnorr signature (128 hex chars)
+)
+```
+
+### Kind Classification
+
+```kotlin
+// Regular events — stored by relays forever
+val isRegular = kind in 1..9999
+
+// Replaceable events — relay keeps only latest per (pubkey, kind)
+val isReplaceable = kind == 0 || kind == 3 || kind in 10000..19999
+
+// Addressable events — relay keeps latest per (pubkey, kind, d-tag)
+val isAddressable = kind in 30000..39999
+
+// Ephemeral events — relays don't persist
+val isEphemeral = kind in 20000..29999
+```
+
+---
+
+## 3. Key Management
+
+### Generate a new keypair
+
+```kotlin
+import com.vitorpamplona.quartz.nip01Core.crypto.KeyPair
+
+// Generate fresh random keys
+val keyPair = KeyPair()
+
+// From existing private key bytes
+val keyPair = KeyPair(privKey = myPrivKeyBytes)
+
+// Read-only (public key only, cannot sign)
+val keyPair = KeyPair(pubKey = myPubKeyBytes)
+
+// Access
+val pubKeyHex: String = keyPair.pubKey.toHexKey()
+val privKeyHex: String? = keyPair.privKey?.toHexKey()
+```
+
+### Convert between formats
+
+```kotlin
+import com.vitorpamplona.quartz.nip01Core.core.toHexKey
+import com.vitorpamplona.quartz.nip19Bech32.Nip19Parser
+
+// ByteArray → hex
+val hex = byteArray.toHexKey()
+
+// hex → ByteArray
+val bytes = HexKey.decodeHex(hex)
+
+// Bech32 import (npub, nsec)
+val parsed = Nip19Parser.uriToRoute("npub1abc...")
+// or
+val parsed = Nip19Parser.uriToRoute("nsec1abc...")
+```
+
+---
+
+## 4. Signing Events
+
+### `NostrSignerInternal` (local key, JVM + Android)
+
+```kotlin
+import com.vitorpamplona.quartz.nip01Core.crypto.KeyPair
+import com.vitorpamplona.quartz.nip01Core.signers.NostrSignerInternal
+
+val keyPair = KeyPair()
+val signer = NostrSignerInternal(keyPair)
+
+// Sign any EventTemplate
+val template = TextNoteEvent.build("Hello Nostr!")
+val signedEvent: TextNoteEvent = signer.sign(template)
+```
+
+### `NostrSignerSync` (synchronous, for testing)
+
+```kotlin
+import com.vitorpamplona.quartz.nip01Core.signers.NostrSignerSync
+
+val signerSync = NostrSignerSync(keyPair)
+val event = signerSync.sign<TextNoteEvent>(
+    createdAt = TimeUtils.now(),
+    kind = 1,
+    tags = emptyArray(),
+    content = "Hello!"
+)
+```
+
+### NostrSigner interface (for custom signers)
+
+```kotlin
+abstract class NostrSigner(val pubKey: HexKey) {
+    abstract fun isWriteable(): Boolean
+    abstract suspend fun <T : Event> sign(createdAt: Long, kind: Int, tags: Array<Array<String>>, content: String): T
+    abstract suspend fun nip04Encrypt(plaintext: String, toPublicKey: HexKey): String
+    abstract suspend fun nip04Decrypt(ciphertext: String, fromPublicKey: HexKey): String
+    abstract suspend fun nip44Encrypt(plaintext: String, toPublicKey: HexKey): String
+    abstract suspend fun nip44Decrypt(ciphertext: String, fromPublicKey: HexKey): String
+    abstract suspend fun deriveKey(nonce: HexKey): HexKey
+    abstract fun hasForegroundSupport(): Boolean
+    // Convenience: auto-detects NIP-04 vs NIP-44 by ciphertext format
+    suspend fun decrypt(encryptedContent: String, fromPublicKey: HexKey): String
+}
+```
+
+---
+
+## 5. Creating Events
+
+### Using typed event builders (recommended)
+
+```kotlin
+import com.vitorpamplona.quartz.nip10Notes.TextNoteEvent
+import com.vitorpamplona.quartz.nip25Reactions.ReactionEvent
+
+// Kind 1 — Text note
+val template = TextNoteEvent.build("Hello Nostr!")
+val event: TextNoteEvent = signer.sign(template)
+
+// Kind 1 — Reply
+val replyTemplate = TextNoteEvent.build(
+    note = "Interesting thread!",
+    replyingTo = originalEventHintBundle
+)
+
+// Kind 7 — Reaction
+val reactionTemplate = ReactionEvent.build(
+    content = "+",          // "+" = like, "-" = dislike, emoji = custom
+    originalNote = targetEvent
+)
+```
+
+### Using low-level `Event.build` DSL
+
+```kotlin
+import com.vitorpamplona.quartz.nip01Core.core.Event
+
+val template = Event.build(
+    kind = 1,
+    content = "Hello world",
+    createdAt = TimeUtils.now()
+) {
+    // TagArrayBuilder DSL
+    add(arrayOf("p", mentionedPubKey))
+    add(arrayOf("t", "nostr"))
+    add(arrayOf("subject", "Greeting"))
+}
+
+val event: Event = signer.sign(template)
+```
+
+### TagArrayBuilder DSL methods
+
+```kotlin
+// In the DSL lambda:
+add(arrayOf("tagname", "value"))          // append
+addFirst(arrayOf("tagname", "value"))     // prepend
+addUnique(arrayOf("d", "my-slug"))        // replace all tags with same name
+addAll(listOf(arrayOf("t", "tag1"), ...)) // bulk add
+remove("tagname")                          // remove all with this name
+```
+
+## 6. Relay Client Setup (JVM / Android)
+
+The relay client requires an OkHttp WebSocket builder (available on JVM + Android).
+
+### Minimal setup
+
+```kotlin
+import com.vitorpamplona.quartz.nip01Core.relay.client.NostrClient
+import com.vitorpamplona.quartz.nip01Core.relay.sockets.okhttp.BasicOkHttpWebSocket
+import okhttp3.OkHttpClient
+
+// Build the WebSocket factory
+val okHttpClient = OkHttpClient.Builder().build()
+val wsBuilder = BasicOkHttpWebSocket.Builder { _ -> okHttpClient }
+
+// Create client (manages its own CoroutineScope internally)
+val nostrClient = NostrClient(websocketBuilder = wsBuilder)
+nostrClient.connect()
+```
+
+### With custom OkHttpClient per relay
+
+```kotlin
+val wsBuilder = BasicOkHttpWebSocket.Builder { normalizedUrl ->
+    if (normalizedUrl.url.contains(".onion")) {
+        torEnabledOkHttpClient   // Tor proxy for .onion relays
+    } else {
+        regularOkHttpClient
+    }
+}
+```
+
+### With custom CoroutineScope
+
+```kotlin
+val appScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+val nostrClient = NostrClient(wsBuilder, scope = appScope)
+```
+
+---
+
+## 7. Subscribing to Events
+
+### Normalize relay URLs first
+
+```kotlin
+import com.vitorpamplona.quartz.nip01Core.relay.normalizer.RelayUrlNormalizer
+
+// Returns NormalizedRelayUrl (wrapper with validated wss:// URL)
+val relayUrl = RelayUrlNormalizer.normalize("wss://relay.damus.io")
+val relayUrlOrNull = RelayUrlNormalizer.normalizeOrNull("wss://relay.damus.io")
+
+// Handles common fixes: https:// → wss://, strips whitespace, etc.
+```
+
+### Build a Filter
+
+```kotlin
+import com.vitorpamplona.quartz.nip01Core.relay.filters.Filter
+
+// Fetch a user's notes
+val filter = Filter(
+    authors = listOf(pubKeyHex),
+    kinds = listOf(1),
+    limit = 50
+)
+
+// Since a timestamp
+val filter = Filter(
+    kinds = listOf(1, 6),
+    since = System.currentTimeMillis() / 1000 - 3600  // last hour
+)
+
+// By event tags
+val filter = Filter(
+    kinds = listOf(7),
+    tags = mapOf("e" to listOf(eventId))   // reactions to an event
+)
+
+// AND tag filter (NIP-91)
+val filter = Filter(
+    kinds = listOf(1),
+    tagsAll = mapOf(
+        "t" to listOf("nostr"),
+        "p" to listOf(specificPubKey)
+    )
+)
+
+// Full-text search (NIP-50)
+val filter = Filter(
+    kinds = listOf(1),
+    search = "bitcoin lightning"
+)
+```
+
+### Open a subscription
+
+```kotlin
+import com.vitorpamplona.quartz.nip01Core.relay.client.listeners.IRelayClientListener
+import com.vitorpamplona.quartz.nip01Core.relay.client.single.IRelayClient
+import com.vitorpamplona.quartz.nip01Core.relay.commands.toClient.Message
+import com.vitorpamplona.quartz.nip01Core.relay.commands.toClient.EventMessage
+import com.vitorpamplona.quartz.nip01Core.relay.commands.toClient.EoseMessage
+
+val relay = RelayUrlNormalizer.normalize("wss://relay.damus.io")
+
+val subId = "my-sub-${System.currentTimeMillis()}"
+val filtersMap = mapOf(relay to listOf(filter))
+
+nostrClient.openReqSubscription(
+    subId = subId,
+    filters = filtersMap,
+    listener = object : IRequestListener {
+        override fun onEvent(subId: String, event: Event, relay: IRelayClient) {
+            println("Got event: ${event.id}")
+        }
+        override fun onEOSE(subId: String, relay: IRelayClient) {
+            println("End of stored events from ${relay.url}")
+        }
+    }
+)
+
+// Close when done
+nostrClient.close(subId)
+```
+
+### Global relay listener
+
+```kotlin
+nostrClient.subscribe(object : IRelayClientListener {
+    override fun onIncomingMessage(relay: IRelayClient, msgStr: String, msg: Message) {
+        when (msg) {
+            is EventMessage -> handleEvent(msg.subscriptionId, msg.event)
+            is EoseMessage  -> handleEose(msg.subscriptionId)
+            else -> {}
+        }
+    }
+    override fun onConnected(relay: IRelayClient, pingMillis: Int, compressed: Boolean) {
+        println("Connected to ${relay.url} in ${pingMillis}ms")
+    }
+    override fun onDisconnected(relay: IRelayClient) {
+        println("Disconnected from ${relay.url}")
+    }
+    // other callbacks: onConnecting, onSent, onCannotConnect
+})
+```
+
+---
+
+## 8. Publishing Events
+
+```kotlin
+import com.vitorpamplona.quartz.nip01Core.relay.normalizer.RelayUrlNormalizer
+
+val relaySet = setOf(
+    RelayUrlNormalizer.normalize("wss://relay.damus.io"),
+    RelayUrlNormalizer.normalize("wss://nos.lol"),
+)
+
+// Sign the event
+val template = TextNoteEvent.build("Hello Nostr!")
+val event: TextNoteEvent = signer.sign(template)
+
+// Send to relays (handles retry + reconnect automatically)
+nostrClient.send(event, relaySet)
+```
+
+---
+
+## 9. Event Serialization
+
+```kotlin
+import com.vitorpamplona.quartz.nip01Core.core.Event
+
+// Serialize to JSON string
+val json: String = event.toJson()
+
+// Parse from JSON string
+val event: Event = Event.fromJson(json)
+
+// Null-safe parse
+val event: Event? = Event.fromJsonOrNull(json)
+
+// Specific typed parse (returns base Event, cast if needed)
+val textNote = Event.fromJson(json) as? TextNoteEvent
+```
+
+---
+
+## 10. Bech32 Encoding / Decoding (NIP-19)
+
+```kotlin
+import com.vitorpamplona.quartz.nip19Bech32.Nip19Parser
+
+// Decode any bech32 entity
+val result = Nip19Parser.uriToRoute("npub1abc...")
+// Returns: NPub | NSec | Note | NEvent | NProfile | NAddr | null
+
+when (val r = Nip19Parser.uriToRoute(input)) {
+    is Nip19Parser.Return.NPub    -> println("pubkey: ${r.hex}")
+    is Nip19Parser.Return.Note    -> println("event id: ${r.hex}")
+    is Nip19Parser.Return.NEvent  -> println("event: ${r.hex}, relays: ${r.relays}")
+    is Nip19Parser.Return.NProfile -> println("profile: ${r.hex}")
+    is Nip19Parser.Return.NAddr   -> println("address: ${r.kind}:${r.pubKey}:${r.dTag}")
+    null -> println("not a valid bech32 entity")
+    else -> {}
+}
+
+// The parser also handles nostr: URI scheme
+val result = Nip19Parser.uriToRoute("nostr:npub1abc...")
+```
+
+---
+
+## 11. Encryption
+
+### NIP-44 (modern, recommended)
+
+```kotlin
+// Via signer (preferred)
+val encrypted = signer.nip44Encrypt(
+    plaintext = "Secret message",
+    toPublicKey = recipientPubKeyHex
+)
+val decrypted = signer.nip44Decrypt(
+    ciphertext = encrypted,
+    fromPublicKey = senderPubKeyHex
+)
+
+// Auto-detect format (NIP-04 or NIP-44)
+val plaintext = signer.decrypt(encryptedContent, fromPublicKeyHex)
+```
+
+### NIP-04 (legacy, avoid for new code)
+
+```kotlin
+val encrypted = signer.nip04Encrypt(plaintext, recipientPubKeyHex)
+val decrypted = signer.nip04Decrypt(ciphertext, senderPubKeyHex)
+```
+
+---
+
+## 12. Common NIP Event Builders
+
+### NIP-02 — Follow list (kind 3)
+
+```kotlin
+import com.vitorpamplona.quartz.nip02FollowList.ContactListEvent
+
+val template = ContactListEvent.build(
+    follows = listOf(
+        ContactListEvent.Contact(pubKey = alicePubKey, relayUrl = "wss://relay.damus.io", petname = "alice"),
+        ContactListEvent.Contact(pubKey = bobPubKey)
+    )
+)
+```
+
+### NIP-25 — Reaction (kind 7)
+
+```kotlin
+import com.vitorpamplona.quartz.nip25Reactions.ReactionEvent
+
+val like = ReactionEvent.build("+", targetEvent)
+val dislike = ReactionEvent.build("-", targetEvent)
+val custom = ReactionEvent.build("🤙", targetEvent)
+```
+
+### NIP-57 — Zap request (kind 9734)
+
+```kotlin
+import com.vitorpamplona.quartz.nip57Zaps.LnZapRequestEvent
+
+val template = LnZapRequestEvent.build(
+    message = "Great post!",
+    relays = listOf("wss://relay.damus.io"),
+    target = targetEvent,
+    zapType = LnZapRequestEvent.ZapType.PUBLIC
+)
+val zapRequest: LnZapRequestEvent = signer.sign(template)
+```
+
+### NIP-59 — Gift wrap / sealed DM (kind 1059 + 14)
+
+```kotlin
+import com.vitorpamplona.quartz.nip17Dm.NIP17Factory
+
+// Creates sealed rumor + gift wrap pair
+val (dmEvent, giftWrap) = NIP17Factory.create(
+    msg = "Private message",
+    fromSigner = senderSigner,
+    toUsers = listOf(recipientPubKey),
+    relayList = listOf("wss://relay.damus.io")
+)
+```
+
+### NIP-23 — Long-form article (kind 30023)
+
+```kotlin
+import com.vitorpamplona.quartz.nip23LongContent.LongTextNoteEvent
+
+val template = LongTextNoteEvent.build(
+    body = markdownContent,
+    title = "My Article",
+    image = "https://example.com/cover.jpg",
+    summary = "A brief summary",
+    slug = "my-article"   // d-tag
+)
+```
+
+---
+
+## 13. Platform-Specific Notes
+
+### JVM / Desktop
+
+```kotlin
+// jvmMain dependencies needed in consuming project:
+// secp256k1-kmp-jni-jvm and lazysodium-java are transitive from quartz
+// But you need JNA on the classpath for libsodium:
+implementation("net.java.dev.jna:jna:5.18.1")
+```
+
+### Android
+
+```kotlin
+// androidMain dependencies (transitive from quartz):
+// secp256k1-kmp-jni-android, lazysodium-android, jna (aar)
+// No extra setup needed beyond the maven dependency.
+
+// For NIP-55 (Android external signer apps):
+import com.vitorpamplona.quartz.nip55AndroidSigner.ExternalSignerLauncher
+```
+
+### iOS
+
+The library produces an XCFramework named `quartz-kmpKit`.
+
+```bash
+# Build XCFramework
+./gradlew :quartz:assembleQuartz-kmpKitReleaseXCFramework
+# Output: quartz/build/XCFrameworks/release/quartz-kmpKit.xcframework
+```
+
+In Xcode: drag & drop the `.xcframework` into your project, then use from Swift via Kotlin/Native interop.
+
+---
+
+## 14. Event Store (Android only)
+
+SQLite-based storage with full NIP support (NIP-09, NIP-40, NIP-45, NIP-50, NIP-62):
+
+```kotlin
+import com.vitorpamplona.quartz.nip01Core.store.EventStore
+import android.content.Context
+
+val store = EventStore()
+
+// Insert
+store.insert(event)
+
+// Query
+val events = store.query(
+    Filter(authors = listOf(pubKey), kinds = listOf(1), limit = 50)
+)
+
+// Count (NIP-45)
+val count = store.count(Filter(kinds = listOf(1)))
+
+// Full-text search (NIP-50)
+val results = store.query(Filter(search = "bitcoin"))
+```
+
+---
+
+## 15. Quick Reference
+
+| Task | API | Package |
+|------|-----|---------|
+| Generate keys | `KeyPair()` | `nip01Core.crypto` |
+| Create signer | `NostrSignerInternal(keyPair)` | `nip01Core.signers` |
+| Build event | `TextNoteEvent.build(...)` or `Event.build(kind, content) { tags }` | `nip10Notes`, `nip01Core.core` |
+| Sign event | `signer.sign(template)` | `nip01Core.signers` |
+| Serialize | `event.toJson()` | `nip01Core.core` |
+| Parse | `Event.fromJson(json)` | `nip01Core.core` |
+| Normalize relay URL | `RelayUrlNormalizer.normalize("wss://...")` | `nip01Core.relay.normalizer` |
+| Setup relay client | `NostrClient(BasicOkHttpWebSocket.Builder { okhttp })` | `nip01Core.relay.client` |
+| Subscribe | `client.openReqSubscription(subId, mapOf(relay to filters), listener)` | `nip01Core.relay.client` |
+| Publish | `client.send(event, setOf(relayUrl))` | `nip01Core.relay.client` |
+| NIP-44 encrypt | `signer.nip44Encrypt(text, recipientPubKey)` | `nip01Core.signers` |
+| Bech32 decode | `Nip19Parser.uriToRoute("npub1...")` | `nip19Bech32` |
+| Bech32 encode | `Nip19Bech32.createNPub(pubKeyHex)` | `nip19Bech32` |
+
+## Common Event Kinds
+
+| Kind | Event Type | NIP | Quartz class |
+|------|-----------|-----|-------------|
+| 0 | User metadata | 01 | `MetadataEvent` |
+| 1 | Text note | 10 | `TextNoteEvent` |
+| 3 | Follow list | 02 | `ContactListEvent` |
+| 4 | Legacy DM | 04 | `PrivateDmEvent` |
+| 5 | Deletion | 09 | `DeletionEvent` |
+| 6 | Repost | 18 | `RepostEvent` |
+| 7 | Reaction | 25 | `ReactionEvent` |
+| 14 | Chat message (sealed) | 17 | `NIP17GroupMessage` |
+| 1059 | Gift wrap | 59 | `GiftWrapEvent` |
+| 9734 | Zap request | 57 | `LnZapRequestEvent` |
+| 9735 | Zap receipt | 57 | `LnZapEvent` |
+| 10002 | Relay list | 65 | `AdvertisedRelayListEvent` |
+| 30023 | Long-form content | 23 | `LongTextNoteEvent` |
+
+## Related Skills
+
+- **nostr-expert** — Internal Quartz patterns for Amethyst development
+- **kotlin-multiplatform** — KMP source sets, expect/actual patterns
+- **kotlin-coroutines** — Flow patterns for relay event streams

.claude/skills/quartz-integration/references/gradle-setup.md

@@ -0,0 +1,142 @@
+# Quartz Gradle Dependency Setup
+
+## Current version
+
+```
+com.vitorpamplona.quartz:quartz:1.08.0
+```
+
+Check latest: https://central.sonatype.com/artifact/com.vitorpamplona.quartz/quartz
+
+---
+
+## KMP Project Setup
+
+### `gradle/libs.versions.toml`
+
+```toml
+[versions]
+quartz = "1.08.0"
+
+[libraries]
+quartz = { module = "com.vitorpamplona.quartz:quartz", version.ref = "quartz" }
+```
+
+### `build.gradle.kts` (library/app module)
+
+```kotlin
+plugins {
+    alias(libs.plugins.kotlinMultiplatform)
+    alias(libs.plugins.androidKotlinMultiplatformLibrary) // or androidLibrary/androidApplication
+}
+
+kotlin {
+    jvm()
+    androidLibrary {
+        namespace = "com.example.myapp"
+        compileSdk = 35
+        minSdk = 21
+    }
+    // optional: iOS targets
+
+    sourceSets {
+        commonMain.dependencies {
+            implementation(libs.quartz)
+        }
+        // No platform-specific deps needed — Quartz provides them transitively
+    }
+}
+```
+
+---
+
+## Android-only Project
+
+```kotlin
+// build.gradle.kts (app module)
+dependencies {
+    implementation("com.vitorpamplona.quartz:quartz:1.08.0")
+}
+```
+
+---
+
+## JVM (Desktop) standalone
+
+```kotlin
+// build.gradle.kts
+plugins {
+    kotlin("jvm")
+}
+
+dependencies {
+    implementation("com.vitorpamplona.quartz:quartz:1.08.0")
+    // JNA needed for libsodium (NIP-44) on JVM
+    implementation("net.java.dev.jna:jna:5.18.1")
+}
+```
+
+---
+
+## Transitive Dependencies (what you get automatically)
+
+### All platforms (`commonMain`)
+- `org.jetbrains.kotlin:kotlin-stdlib`
+- `org.jetbrains.kotlinx:kotlinx-coroutines-core`
+- `org.jetbrains.kotlinx:kotlinx-collections-immutable`
+- `org.jetbrains.kotlinx:kotlinx-serialization-json`
+- `androidx.collection:collection` (LruCache)
+- `androidx.compose.runtime:runtime-annotation` (@Immutable/@Stable)
+- `fr.acinq.secp256k1:secp256k1-kmp` (Schnorr crypto — common)
+
+### JVM + Android (`jvmAndroid`)
+- `com.github.anthonynsimon:rfc3986-normalizer` (URL normalization)
+- `com.fasterxml.jackson.module:jackson-module-kotlin` (JSON)
+- `com.squareup.okhttp3:okhttp` (WebSocket)
+- `ru.gildor.coroutines:kotlin-coroutines-okhttp`
+- `nl.bommber:kchesslib` (NIP-64 chess, version pinned to 1.0.0)
+
+### JVM only
+- `fr.acinq.secp256k1:secp256k1-kmp-jni-jvm`
+- `com.goterl:lazysodium-java` (NIP-44 encryption)
+- `net.java.dev.jna:jna`
+
+### Android only
+- `fr.acinq.secp256k1:secp256k1-kmp-jni-android`
+- `com.goterl:lazysodium-android`
+- `net.java.dev.jna:jna` (aar)
+- `androidx.core:core-ktx`
+
+---
+
+## Packaging / ProGuard
+
+Quartz ships consumer ProGuard rules automatically (`publish = true` in the library).
+You don't need to add manual keep rules for Quartz classes in your app.
+
+For Android release builds, these classes are preserved:
+- All `com.vitorpamplona.quartz.**` event and model classes
+- Jackson serialization annotations
+
+---
+
+## Common Build Errors
+
+### `Duplicate class kotlin.collections.jdk8`
+Add to `gradle.properties`:
+```properties
+android.useFullClasspathForDexingTransform=true
+```
+
+### `Could not find lazysodium-java` on JVM
+Ensure JNA is on the classpath:
+```kotlin
+implementation("net.java.dev.jna:jna:5.18.1")
+```
+
+### iOS: `Framework not found quartz-kmpKit`
+Build the XCFramework first:
+```bash
+./gradlew :quartz:assembleQuartz-kmpKitReleaseXCFramework
+```
+Then drag `quartz/build/XCFrameworks/release/quartz-kmpKit.xcframework` into Xcode.

.claude/skills/quartz-kmp.md

@@ -1,165 +1,23 @@
-# Quartz KMP Conversion Skill
+# Quartz KMP (Legacy Skill — Migration Complete)
 
-When working with Quartz library conversion to Kotlin Multiplatform:
+> The KMP migration of Quartz is **complete**. This file is kept for historical reference.
+>
+> For integrating Quartz into external projects, use the **`quartz-integration`** skill instead.
+> For working with Quartz internals within Amethyst, use the **`nostr-expert`** skill.
+
+## What was migrated
+
+The Quartz library was successfully converted from Android-only to full KMP supporting:
+- **commonMain** — All Nostr protocol logic, events, filters, tags
+- **jvmAndroid** — OkHttp WebSocket, Jackson JSON, relay serializers
+- **androidMain** — SQLite event store, NIP-55 Android signer
+- **jvmMain** — Desktop JVM crypto (lazysodium-java, secp256k1-jni-jvm)
+- **iosMain** — iOS targets (XCFramework `quartz-kmpKit`)
+
+## Current artifact
 
-## Current Structure (Android-only)
 ```
-quartz/
-├── build.gradle
-└── src/
-    ├── main/kotlin/          # All Nostr code here
-    ├── test/
-    └── androidTest/
+com.vitorpamplona.quartz:quartz:1.08.0
 ```
 
-## Target Structure (KMP)
-```
-quartz/
-├── build.gradle.kts
-└── src/
-    ├── commonMain/kotlin/    # Shared protocol code
-    ├── commonTest/kotlin/    # Shared tests
-    ├── androidMain/kotlin/   # Android crypto, storage
-    ├── androidTest/kotlin/
-    ├── jvmMain/kotlin/       # Desktop crypto, storage
-    └── jvmTest/kotlin/
-```
-
-## Platform Abstractions Required
-
-### 1. Cryptography (expect/actual)
-```kotlin
-// commonMain
-expect object Secp256k1 {
-    fun sign(data: ByteArray, privateKey: ByteArray): ByteArray
-    fun verify(data: ByteArray, signature: ByteArray, pubKey: ByteArray): Boolean
-    fun pubKeyCreate(privateKey: ByteArray): ByteArray
-}
-
-// androidMain - uses secp256k1-kmp-jni-android
-actual object Secp256k1 {
-    actual fun sign(data: ByteArray, privateKey: ByteArray): ByteArray {
-        return fr.acinq.secp256k1.Secp256k1.sign(data, privateKey)
-    }
-    // ...
-}
-
-// jvmMain - uses secp256k1-kmp-jni-jvm
-actual object Secp256k1 {
-    actual fun sign(data: ByteArray, privateKey: ByteArray): ByteArray {
-        return fr.acinq.secp256k1.Secp256k1.sign(data, privateKey)
-    }
-    // ...
-}
-```
-
-### 2. NIP-44 Encryption (Sodium)
-```kotlin
-// commonMain
-expect object Nip44 {
-    fun encrypt(plaintext: String, sharedSecret: ByteArray): String
-    fun decrypt(ciphertext: String, sharedSecret: ByteArray): String
-}
-
-// androidMain - lazysodium-android
-// jvmMain - lazysodium-java or libsodium-jni
-```
-
-### 3. Secure Random
-```kotlin
-// commonMain
-expect fun secureRandomBytes(size: Int): ByteArray
-
-// androidMain
-actual fun secureRandomBytes(size: Int): ByteArray {
-    return SecureRandom().let { random ->
-        ByteArray(size).also { random.nextBytes(it) }
-    }
-}
-
-// jvmMain
-actual fun secureRandomBytes(size: Int): ByteArray {
-    return java.security.SecureRandom().let { random ->
-        ByteArray(size).also { random.nextBytes(it) }
-    }
-}
-```
-
-## Build Configuration
-
-```kotlin
-// quartz/build.gradle.kts
-plugins {
-    kotlin("multiplatform")
-    id("com.android.library")
-}
-
-kotlin {
-    androidTarget {
-        compilations.all {
-            kotlinOptions.jvmTarget = "17"
-        }
-    }
-
-    jvm("desktop") {
-        compilations.all {
-            kotlinOptions.jvmTarget = "17"
-        }
-    }
-
-    sourceSets {
-        val commonMain by getting {
-            dependencies {
-                implementation(libs.kotlinx.coroutines.core)
-                implementation(libs.kotlinx.collections.immutable)
-            }
-        }
-
-        val androidMain by getting {
-            dependencies {
-                implementation(libs.secp256k1.kmp.jni.android)
-                implementation(libs.lazysodium.android)
-            }
-        }
-
-        val desktopMain by getting {
-            dependencies {
-                implementation(libs.secp256k1.kmp.jni.jvm)
-                // lazysodium-java or alternative
-            }
-        }
-    }
-}
-
-android {
-    namespace = "com.vitorpamplona.quartz"
-    compileSdk = 35
-    defaultConfig.minSdk = 26
-}
-```
-
-## Migration Steps
-
-1. **Convert build.gradle to build.gradle.kts** with KMP plugin
-2. **Move pure Kotlin code** to `commonMain/`
-3. **Identify platform dependencies** (crypto, JNA, Android APIs)
-4. **Create expect declarations** for platform-specific APIs
-5. **Implement actuals** in androidMain and jvmMain
-6. **Update imports** in amethyst module
-7. **Test on both platforms**
-
-## Files to Move to commonMain
-
-Most of Quartz can be shared:
-- Event classes and parsing
-- Filter definitions
-- Relay message types
-- NIP implementations (logic only)
-- Utilities (hex encoding, bech32)
-
-## Files Needing expect/actual
-
-- `Secp256k1.kt` - Signature operations
-- `Nip04.kt` - Legacy encryption (uses AES)
-- `Nip44.kt` - Modern encryption (uses ChaCha)
-- `KeyPair.kt` - Key generation
+See `.claude/skills/quartz-integration/SKILL.md` for full integration guide.

.git-hooks/pre-push

@@ -12,8 +12,11 @@ echo "$JAVA_HOME"
 echo "$(java -version)"
 echo "Running test... "
 
-./gradlew test
-
+if [ "${CLAUDE_CODE_REMOTE:-}" = "true" ]; then
+  ./gradlew test --quiet -x :desktopApp:test -x :desktopApp:upxDownload -x :desktopApp:vlcDownload
+else
+  ./gradlew test --quiet
+fi
 status=$?
 
 if [ "$status" = 0 ] ; then

.github/workflows/build.yml

@@ -1,4 +1,4 @@
-name: Test/Build Android
+name: Test/Build
 
 on:
   pull_request:
@@ -6,78 +6,201 @@ on:
   push:
     branches: [main]
 
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
+permissions:
+  contents: read
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Set up JDK 21
-        uses: actions/setup-java@v4
+        uses: actions/setup-java@v5
         with:
           distribution: 'zulu'
           java-version: 21
 
       - name: Cache gradle
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
-          path: ~/.gradle/caches
-          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*') }}
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
           restore-keys: |
             ${{ runner.os }}-gradle-
 
       - name: Linter (gradle)
         run: ./gradlew spotlessCheck
 
+  test:
+    needs: lint
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 30
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+
+      - name: Set up JDK 21
+        uses: actions/setup-java@v5
+        with:
+          distribution: 'zulu'
+          java-version: 21
+
+      - name: Cache gradle
+        uses: actions/cache@v5
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+
       - name: Test (gradle)
         run: ./gradlew test --no-daemon
 
+      - name: Stop Gradle Daemon
+        if: always()
+        run: ./gradlew --stop
+
       - name: Android Test Report
         uses: asadmansr/android-test-report-action@v1.2.0
-        if: ${{ always() }} # IMPORTANT: run Android Test Report regardless
+        if: ${{ always() && matrix.os == 'ubuntu-latest' }}
+
+      - name: Upload Test Results
+        uses: actions/upload-artifact@v6
+        if: ${{ always() && matrix.os == 'ubuntu-latest' }}
+        with:
+          name: Test Reports
+          path: amethyst/build/reports
+
+  build-android:
+    needs: test
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+
+      - name: Set up JDK 21
+        uses: actions/setup-java@v5
+        with:
+          distribution: 'zulu'
+          java-version: 21
+
+      - name: Cache gradle
+        uses: actions/cache@v5
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
 
       - name: Build APK (gradle)
         run: ./gradlew assembleDebug
 
       - name: Upload Play APK
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v6
         with:
           name: Play Debug APK
           path: amethyst/build/outputs/apk/play/debug/amethyst-play-universal-debug.apk
 
       - name: Upload FDroid APK
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v6
         with:
           name: FDroid Debug APK
           path: amethyst/build/outputs/apk/fdroid/debug/amethyst-fdroid-universal-debug.apk
 
-      - name: Build APK (gradle)
+      - name: Build Benchmark APK (gradle)
         run: ./gradlew assembleBenchmark
 
       - name: Upload Play APK Benchmark
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v6
         with:
           name: Play Benchmark APK
           path: amethyst/build/outputs/apk/play/benchmark/amethyst-play-universal-benchmark.apk
 
       - name: Upload FDroid APK Benchmark
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v6
         with:
           name: FDroid Benchmark APK
           path: amethyst/build/outputs/apk/fdroid/benchmark/amethyst-fdroid-universal-benchmark.apk
 
       - name: Upload Compose Reports
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v6
         with:
           name: Compose Reports
           path: amethyst/build/compose_compiler
 
-      - name: Upload Test Results
-        uses: actions/upload-artifact@v4
-        with:
-          name: Test Reports
-          path: amethyst/build/reports
+  build-desktop:
+    needs: test
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            task: packageDeb
+            artifact-name: Desktop Linux DEB
+            artifact-path: desktopApp/build/compose/binaries/main/deb/*.deb
+          - os: macos-latest
+            task: packageDmg
+            artifact-name: Desktop macOS DMG
+            artifact-path: desktopApp/build/compose/binaries/main/dmg/*.dmg
+          - os: windows-latest
+            task: packageMsi
+            artifact-name: Desktop Windows MSI
+            artifact-path: desktopApp/build/compose/binaries/main/msi/*.msi
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 30
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
 
+      - name: Set up JDK 21
+        uses: actions/setup-java@v5
+        with:
+          distribution: 'zulu'
+          java-version: 21
+
+      - name: Cache gradle
+        uses: actions/cache@v5
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+
+      - name: Build Desktop Distribution
+        run: ./gradlew :desktopApp:${{ matrix.task }}
+
+      - name: Stop Gradle Daemon
+        if: always()
+        run: ./gradlew --stop
+
+      - name: Upload Desktop Distribution
+        uses: actions/upload-artifact@v6
+        with:
+          name: ${{ matrix.artifact-name }}
+          path: ${{ matrix.artifact-path }}

.github/workflows/create-release.yml

@@ -5,24 +5,46 @@ on:
     tags:
     - 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10
 
+permissions:
+  contents: write
+
 jobs:
-  deploy:
+  create-release:
+    runs-on: ubuntu-latest
+    outputs:
+      upload_url: ${{ steps.create_release.outputs.upload_url }}
+    steps:
+      - name: Create Release
+        id: create_release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ github.ref }}
+          release_name: Release ${{ github.ref }}
+          draft: false
+          prerelease: true
+
+  deploy-android:
+    needs: create-release
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Set up JDK 21
-        uses: actions/setup-java@v4
+        uses: actions/setup-java@v5
         with:
           distribution: 'zulu'
           java-version: 21
 
       - name: Cache gradle
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
-          path: ~/.gradle/caches
-          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*') }}
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
           restore-keys: |
             ${{ runner.os }}-gradle-
 
@@ -38,7 +60,6 @@ jobs:
           keyStorePassword: ${{ secrets.KEY_STORE_PASSWORD }}
           keyPassword: ${{ secrets.KEY_PASSWORD }}
         env:
-          # override default build-tools version (29.0.3) -- optional
           BUILD_TOOLS_VERSION: "36.0.0"
 
       - name: Sign AAB (F-Droid)
@@ -50,7 +71,6 @@ jobs:
           keyStorePassword: ${{ secrets.KEY_STORE_PASSWORD }}
           keyPassword: ${{ secrets.KEY_PASSWORD }}
         env:
-          # override default build-tools version (29.0.3) -- optional
           BUILD_TOOLS_VERSION: "36.0.0"
 
       - name: Build APK
@@ -65,7 +85,6 @@ jobs:
           keyStorePassword: ${{ secrets.KEY_STORE_PASSWORD }}
           keyPassword: ${{ secrets.KEY_PASSWORD }}
         env:
-          # override default build-tools version (29.0.3) -- optional
           BUILD_TOOLS_VERSION: "36.0.0"
 
       - name: Sign APK (F-Droid)
@@ -77,20 +96,8 @@ jobs:
           keyStorePassword: ${{ secrets.KEY_STORE_PASSWORD }}
           keyPassword: ${{ secrets.KEY_PASSWORD }}
         env:
-          # override default build-tools version (29.0.3) -- optional
           BUILD_TOOLS_VERSION: "36.0.0"
 
-      - name: Create Release
-        id: create_release
-        uses: actions/create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          tag_name: ${{ github.ref }}
-          release_name: Release ${{ github.ref }}
-          draft: false
-          prerelease: true
-
       # Google Play APK
       - name: Upload Play APK Universal Asset
         id: upload-release-asset-play-universal-apk
@@ -98,7 +105,7 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          upload_url: ${{ needs.create-release.outputs.upload_url }}
           asset_path: amethyst/build/outputs/apk/play/release/amethyst-play-universal-release-unsigned-signed.apk
           asset_name: amethyst-googleplay-universal-${{ github.ref_name }}.apk
           asset_content_type: application/zip
@@ -109,7 +116,7 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          upload_url: ${{ needs.create-release.outputs.upload_url }}
           asset_path: amethyst/build/outputs/apk/play/release/amethyst-play-x86-release-unsigned-signed.apk
           asset_name: amethyst-googleplay-x86-${{ github.ref_name }}.apk
           asset_content_type: application/zip
@@ -120,7 +127,7 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          upload_url: ${{ needs.create-release.outputs.upload_url }}
           asset_path: amethyst/build/outputs/apk/play/release/amethyst-play-x86_64-release-unsigned-signed.apk
           asset_name: amethyst-googleplay-x86_64-${{ github.ref_name }}.apk
           asset_content_type: application/zip
@@ -131,7 +138,7 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          upload_url: ${{ needs.create-release.outputs.upload_url }}
           asset_path: amethyst/build/outputs/apk/play/release/amethyst-play-arm64-v8a-release-unsigned-signed.apk
           asset_name: amethyst-googleplay-arm64-v8a-${{ github.ref_name }}.apk
           asset_content_type: application/zip
@@ -142,7 +149,7 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          upload_url: ${{ needs.create-release.outputs.upload_url }}
           asset_path: amethyst/build/outputs/apk/play/release/amethyst-play-armeabi-v7a-release-unsigned-signed.apk
           asset_name: amethyst-googleplay-armeabi-v7a-${{ github.ref_name }}.apk
           asset_content_type: application/zip
@@ -154,7 +161,7 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          upload_url: ${{ needs.create-release.outputs.upload_url }}
           asset_path: amethyst/build/outputs/apk/fdroid/release/amethyst-fdroid-universal-release-unsigned-signed.apk
           asset_name: amethyst-fdroid-universal-${{ github.ref_name }}.apk
           asset_content_type: application/zip
@@ -165,7 +172,7 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          upload_url: ${{ needs.create-release.outputs.upload_url }}
           asset_path: amethyst/build/outputs/apk/fdroid/release/amethyst-fdroid-x86-release-unsigned-signed.apk
           asset_name: amethyst-fdroid-x86-${{ github.ref_name }}.apk
           asset_content_type: application/zip
@@ -176,7 +183,7 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          upload_url: ${{ needs.create-release.outputs.upload_url }}
           asset_path: amethyst/build/outputs/apk/fdroid/release/amethyst-fdroid-x86_64-release-unsigned-signed.apk
           asset_name: amethyst-fdroid-x86_64-${{ github.ref_name }}.apk
           asset_content_type: application/zip
@@ -187,7 +194,7 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          upload_url: ${{ needs.create-release.outputs.upload_url }}
           asset_path: amethyst/build/outputs/apk/fdroid/release/amethyst-fdroid-arm64-v8a-release-unsigned-signed.apk
           asset_name: amethyst-fdroid-arm64-v8a-${{ github.ref_name }}.apk
           asset_content_type: application/zip
@@ -198,13 +205,11 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          upload_url: ${{ needs.create-release.outputs.upload_url }}
           asset_path: amethyst/build/outputs/apk/fdroid/release/amethyst-fdroid-armeabi-v7a-release-unsigned-signed.apk
           asset_name: amethyst-fdroid-armeabi-v7a-${{ github.ref_name }}.apk
           asset_content_type: application/zip
 
-
-
       # Google Play AAB
       - name: Upload Google Play AAB Asset
         id: upload-release-asset-play-aab
@@ -212,7 +217,7 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          upload_url: ${{ needs.create-release.outputs.upload_url }}
           asset_path: amethyst/build/outputs/bundle/playRelease/amethyst-play-release.aab
           asset_name: amethyst-googleplay-${{ github.ref_name }}.aab
           asset_content_type: application/zip
@@ -224,7 +229,7 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          upload_url: ${{ needs.create-release.outputs.upload_url }}
           asset_path: amethyst/build/outputs/bundle/fdroidRelease/amethyst-fdroid-release.aab
           asset_name: amethyst-fdroid-${{ github.ref_name }}.aab
           asset_content_type: application/zip
@@ -236,3 +241,65 @@ jobs:
           ORG_GRADLE_PROJECT_mavenCentralPassword: ${{ secrets.SONATYPE_PASSWORD }}
           ORG_GRADLE_PROJECT_signingInMemoryKey: ${{ secrets.SIGNING_PRIVATE_KEY }}
           ORG_GRADLE_PROJECT_signingInMemoryKeyPassword: ${{ secrets.SIGNING_PASSWORD }}
+
+  deploy-desktop:
+    needs: create-release
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            task: packageDeb
+            format: deb
+            platform: linux
+          - os: macos-latest
+            task: packageDmg
+            format: dmg
+            platform: macos
+          - os: windows-latest
+            task: packageMsi
+            format: msi
+            platform: windows
+    runs-on: ${{ matrix.os }}
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+
+      - name: Set up JDK 21
+        uses: actions/setup-java@v5
+        with:
+          distribution: 'zulu'
+          java-version: 21
+
+      - name: Cache gradle
+        uses: actions/cache@v5
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+
+      - name: Build Desktop Distribution
+        run: ./gradlew :desktopApp:${{ matrix.task }}
+
+      - name: Find distribution file
+        id: find-dist
+        run: |
+          DIST_FILE=$(find desktopApp/build/compose/binaries/main/${{ matrix.format }} -type f \( -name "*.deb" -o -name "*.dmg" -o -name "*.msi" \) | head -1)
+          echo "path=$DIST_FILE" >> $GITHUB_OUTPUT
+          echo "name=$(basename $DIST_FILE)" >> $GITHUB_OUTPUT
+
+      - name: Upload Desktop Distribution to Release
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ needs.create-release.outputs.upload_url }}
+          asset_path: ${{ steps.find-dist.outputs.path }}
+          asset_name: amethyst-desktop-${{ matrix.platform }}-${{ github.ref_name }}.${{ matrix.format }}
+          asset_content_type: application/octet-stream

.github/workflows/crowdin.yml

@@ -5,13 +5,17 @@ on:
     # paths: ["app/src/main/res/**/strings.xml"] // removes filter to allow downloads at any moment.
     branches: [ main ]
 
+permissions:
+  contents: write
+  pull-requests: write
+
 jobs:
   synchronize-with-crowdin:
     runs-on: ubuntu-latest
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: crowdin action
         uses: crowdin/github-action@v2

.gitignore

@@ -22,11 +22,22 @@
 /.idea/AndroidProjectSystem.xml
 /.idea/deviceManager.xml
 /.idea/inspectionProfiles/
+/.idea/migrations.xml
+/desktopApp/vlc-temp/
+/commons/.idea/gradle.xml
+/commons/.idea/misc.xml
+/commons/.idea/workspace.xml
+/quartz/.idea/modules.xml
+/quartz/.idea/workspace.xml
 .DS_Store
 /build
 /captures
 .cxx
 
+# superpowers skill
+.superpowers
+docs/brainstorms
+docs/superpowers
 
 # Built application files
 *.apk
@@ -144,3 +155,14 @@ lint/tmp/
 
 # Local task tracking
 TASKS.md
+
+# Claude Code local settings
+.claude/settings.local.json
+
+# Downloaded VLC binaries (vlc-setup plugin)
+desktopApp/src/jvmMain/appResources/linux/
+desktopApp/src/jvmMain/appResources/macos/
+desktopApp/src/jvmMain/appResources/windows/
+
+# Git worktrees
+.worktrees/

.idea/kotlinc.xml

@@ -6,11 +6,8 @@
   <component name="Kotlin2JvmCompilerArguments">
     <option name="jvmTarget" value="21" />
   </component>
-  <component name="KotlinCommonCompilerArguments">
-    <option name="apiVersion" value="2.3" />
-    <option name="languageVersion" value="2.3" />
-  </component>
   <component name="KotlinJpsPluginSettings">
-    <option name="version" value="2.3.0" />
+    <option name="externalSystemId" value="Gradle" />
+    <option name="version" value="2.3.20" />
   </component>
 </project>

.spotless/copyright.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

CHANGELOG.md

@@ -1,5 +1,508 @@
+<a id="v1.08.0"></a>
+# [Release v1.08.0: Arti](https://github.com/vitorpamplona/amethyst/releases/tag/v1.08.0) - 2026-04-01
+
+- Migrates C Tor to Arti Tor (hopefully no more random crashes)
+- Fixes highlight of users when composing and tagging
+
+<a id="v1.07.5"></a>
+# [Release v1.07.5: Image upload fix](https://github.com/vitorpamplona/amethyst/releases/tag/v1.07.5) - 2026-03-31
+
+- Fixes Image uploads crashing the app
+
+<a id="v1.07.4"></a>
+# [Release v1.07.4: NWC fix](https://github.com/vitorpamplona/amethyst/releases/tag/v1.07.4) - 2026-03-31
+
+- Fixes Nostr wallet connect receiving the secret.
+
+<a id="v1.07.3"></a>
+# [Release v1.07.3: GIF Keyboard](https://github.com/vitorpamplona/amethyst/releases/tag/v1.07.3) - 2026-03-31
+
+- Migrates Shorts UI out of a paged design
+- New edge-to-edge feed for Pictures only
+- New edge-to-edge feed for Shorts only
+- New edge-to-edge feed for long Videos only
+- Migrates Badges to kind 10008
+- Migrates Bookmarks to kind 10003
+- Fixes AOSP keyboard auto-correction bug
+- Fixes Poll's top nav filter
+- Fixes loading of Bookmark sets
+- Fixes sorting stability by including event ids
+- Fixes cursor position in quote post field
+- Fixes rendering of nostr: uris when composing notes
+- Adds Basic support for reaction notifications
+- Refactors NIP-58 Badges on Quartz
+- Refactors LocalCache methods
+- Improvements to the Chess engine (debug only)
+- Add error handling to Tor service initialization and control
+
+<a id="v1.07.2"></a>
+# [Release v1.07.2: GIF Keyboard](https://github.com/vitorpamplona/amethyst/releases/tag/v1.07.2) - 2026-03-30
+
+- Adds GIF uploads support from Keyboard
+- Migrates text fields and @ modifiers to the new Jetpack Compose states
+- Fixes Bug that wasn't openning Amber to sign
+- Fixes Bug on rejections using old Ambers
+- Replaces hex input with user search dialog in relay management (allow/ban user)
+
+<a id="v1.07.1"></a>
+# [Release v1.07.1: Fixes](https://github.com/vitorpamplona/amethyst/releases/tag/v1.07.1) - 2026-03-30
+
+- New translations
+- Fixes BLE's module need for synchronized events.
+
+<a id="v1.07.0"></a>
+# [Release v1.07.0: Vanish, Relay Management, Pin Notes](https://github.com/vitorpamplona/amethyst/releases/tag/v1.07.0) - 2026-03-30
+
+Amethyst:
+- Adds support to Pin Notes
+- Adds support to Polls feed screen
+- Adds support for Requests to Vanish
+- Adds support for Relay management (NIP-86) from Amethyst
+- Adds support for Relay monitor assessments (NIP-66) in the Relay Info screen.
+- Adds support for Relay member information (NIP-43) in the Relay Info screen
+- Adds support for WebBookmarks
+- Adds support for Zap Goals
+
+Quartz:
+- Rewords the NostrClient API for simpler commands.
+- Adds NIP-15: Nostr Marketplace protocol — product listings, stalls, merchant events (#2020)
+- Adds NIP-24: Birthday field support added to UserMetadata (#1979)
+- Adds NIP-29: Relay-based groups — group events, member management, moderation (#2021)
+- Adds NIP-32: Labeling protocol — LabelEvent and tag parsing (#1975)
+- Adds NIP-43: Relay access metadata and membership management with UI screens (#2010)
+- Adds NIP-60: Cashu wallet and spending history event support (#2009)
+- Adds NIP-61: Nutzaps protocol support (#2008)
+- Adds NIP-62: Request to Vanish feature — data deletion with relay compliance testing (#1958)
+- Adds NIP-66: Relay monitor discovery events — UI, filter assembler, subscription composable (#1968)
+- Adds NIP-69: P2P Order Events (kind 38383) (#2019)
+- Adds NIP-75: Zap Goals support with creation and rendering (#1965)
+- Adds NIP-77: Negentropy set reconciliation protocol support (#1955)
+- Adds NIP-7D: Thread events (kind 11) rendering (#2016)
+- Adds NIP-85: Trusted Assertions — assertions for events and addressables (#1981)
+- Adds NIP-86: Relay management UI and client implementation (#1954)
+- Adds NIP-87: Ecash mint discoverability — Cashu and Fedimint event types (#2015)
+- Adds NIP-89: Compliance fixes, PlatformLinkTag parsing, app handler extensions (#2030)
+- Adds NIP-90: All DVM kind event classes from data-vending-machines spec, restructured packages (#2023, #2025)
+- Adds NIP-A4: Add k tag to zap requests and enforce e tag prohibition (#1978)
+- Adds NIP-BE: Bluetooth Low Energy mesh networking / Nostr BLE Communications Protocol (#2022)
+- Adds NIP-C7: Chat messages (kind 9) implementation (#2018)
+- Adds NIP-5A: Static website event rendering (#2017)
+- Adds NIP-51, kind 10001: Pinned notes feature (#1956)
+
+Improvements and Fixes:
+- Show toast instead of dialog on media download success
+- Dynamically adjust preferred Blossom server when list changes
+- Add relay discovery to node master rendering list
+- Add scroll to settings page
+- Solves crashing when multiple relays with the same url are included in the resulting list.
+- Keep screen on during PiP playback and survive screen lock (#1999)
+- Desktop feed loading — missing events, broken profile navigation (#2027)
+- Use getOrCreateNote for reply linking to fix flaky thread test (#2027)
+- Route ReadsScreen following-mode events through cache (#2027)
+- Pin ElectrumX server certs for Samsung One UI 7 / Android 16 compatibility (#1937)
+- Duplicate keys in relay management lazy column — sort pubkeys
+- URL detector — fixes localhost:3030 strings, Japanese character URLs
+- Web Bookmarks floating action button shape (circle) and open graph previews.
+- NIP-86 requests now send Accept and Content-Type headers
+- On DMs, activates decryption for all filetypes that match decryption url with the cipher info, not only binaries
+- Adds a try/finally to subscriptions to make sure they close even in crashes.
+- Protects against crashes when the signer sends an unverifiable payload back to Amethyst
+
+Desktop:
+- Cache-centric architecture for desktop feeds (#1905)
+- Render reposts and quoted notes in feed (#2027)
+
+Performance
+- Faster startup procedures with less loading on the main thread.
+- 20x Faster Rfc3986Normalizer and way less objects being created.
+- Url Detector without using regex
+- Parallelize preference file access at startup for faster launch
+- Remove internal runBlocking calls
+- Lazy loading the memory trimming service
+- Speeding up DrawerContent rendering
+- Eagerly delete intermediate temp files in upload pipeline
+
+Refactoring:
+- Simplify NostrClient API for beginner-friendliness (#1986)
+- Simplify relay API with AutoCloseable and serve() helper (#2031)
+- URL detector performance and readability improvements (#2013)
+- Restructure NIP-90 DVMs to match NIP-88 Polls pattern (#2023)
+- Reorganize NIP-BE into subpackages
+- Move public messages and trusted assertions out of experimental
+
+Migrations & Deprecation Fixes
+
+- Migrate `LocalClipboardManager` to `LocalClipboard` (#1995)
+- Migrate `LocalAutofillTree` to semantics-based Autofill API (#1996)
+- Migrate `TabRow`/`ScrollableTabRow` to Material 3 Secondary variants (#1994)
+- Replace `ContextCompat.startActivity` with `Context.startActivity` (#1993)
+- Suppress deprecation and unchecked cast warnings in Quartz internal code (#1985)
+
+Platform & Build
+
+- Add linuxX64 target and restructure native source sets
+- Add explicit permissions to GitHub Actions workflows
+- Stop Gradle daemons after build steps
+- Increase Android CI build timeout to 45 minutes
+- Update video compression library to latest
+- Update dependencies, add local maven repo for easier library development
+- Remove libsodium files
+- Git hooks installation in worktrees (.git file vs directory)
+- Fixes lack of proxy access to download VLC files in claude's web environment.
+- Log level filtering — LogLevel enum, PlatformLog, lambda overloads for 194+ Log.d() calls (#2005)
+- Parallelize BaseDBTest forEachDB using coroutines
+
+Documentation
+
+- Add CLIENT.md guide for building Nostr clients with Quartz
+- Add RELAY.md guide for building relays with Ktor, NostrServer, SQLite
+
+Contributors
+
+- @npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z — Primary development
+- @npub1e2yuky03caw4ke3zy68lg0fz3r4gkt94hx4fjmlelacyljgyk79svn3eef — Log level filtering, video compression, toast downloads, CI fixes, git worktree fix
+- @npub12cfje6nl2nuxplcqfvhg7ljt89fmpj0n0fd24zxsukja5qm9wmtqd7y76c — Desktop cache architecture, desktop bugfixes
+- @npub1w4uswmv6lu9yel005l3qgheysmr7tk9uvwluddznju3nuxalevvs2d0jr5 — CI workflow permissions
+- @npub1a3tx8wcrt789skl6gg7rqwj4wey0j53eesr4z6asd4h4jwrd62jq0wkq4k — Remove libsodium files
+- **mstrofnone** — ElectrumX cert pinning for Samsung One UI 7
+
+Translations
+
+- Czech, German, Swedish, and Portuguese by @npub1e2yuky03caw4ke3zy68lg0fz3r4gkt94hx4fjmlelacyljgyk79svn3eef
+- Hungarian by @npub1dnvslq0vvrs8d603suykc4harv94yglcxwna9sl2xu8grt2afm3qgfh0tp
+- French by @npub106efcyntxc5qwl3w8krrhyt626m59ya2nk9f40px5s968u5xdwhsjsr8fz
+- Polish by @npub16gjyljum0ksrrm28zzvejydgxwfm7xse98zwc4hlgq8epxeuggushqwyrm
+- Hindi by @npub1ww6huwu3xye6r05n3qkjeq62wds5pq0jswhl7uc59lchc0n0ns4sdtw5e6
+- Slovenian by @npub1qqqqqqz7nhdqz3uuwmzlflxt46lyu7zkuqhcapddhgz66c4ddynswreecw
+- Bengali by @npub13qtw3yu0uc9r4yj5x0rhgy8nj5q0uyeq0pavkgt9ly69uuzxgkfqwvx23t
+- Spanish by @npub1luhyzgce7qtcs6r6v00ryjxza8av8u4dzh3avg0zks38tjktnmxspxq903
+- Chinese by hypnotichemionus4 and @npub1gd8e0xfkylc7v8c5a6hkpj4gelwwcy99jt90lqjseqjj2t253s2s6ch58h
+- Russian by Anton Zhao
+
+<a id="v1.06.3"></a>
+# [Release v1.06.3: Anon Posting](https://github.com/vitorpamplona/amethyst/releases/tag/v1.06.3) - 2026-03-24
+
+Improvements to Anon Posting and Reply navigation on DMs
+
+<a id="v1.06.2"></a>
+# [Release v1.06.2: Multi-choice Polls](https://github.com/vitorpamplona/amethyst/releases/tag/v1.06.2) - 2026-03-24
+
+- Add poll type selector for single and multiple choice polls
+- Add drag-to-seek support on the video progress indicator
+- Hide video controls on playback start
+- Recording indicator bar stops recording when tapped, not just the small stop icon.
+- Fixes non http uris in the references tag
+- Makes sure quote tags only happen once in events.
+- Removes the clickable NIP-05 URL in the @ tagging of users
+- Reduces the need to compute naddr to index articles in bookmarks
+- Checks if p tags are user pubkeys when loading drafts.
+- Scroll to the replied message when clicking reply preview in chat
+- Add an anonymous reply with a throwaway keypair
+- Fixes pool rendering when one label is large and the other is small
+- Use uri-reference-kmp in commonMain. Remove platform-specific implementations.
+- Avoids crashing the app in URLs with japanese chars
+- Sorts followers into a set to avoid LazyColumn key conflicts.
+- Clickable relay rows on the profile page
+- Move cache lookups from NavHost route lambdas into screen composables
+- Improvements to the status of attestations. Validity first, then Processing status.
+- Fixes Tor Manager flow value and improves Tor binding lifecycle.
+- Simplifies the report feed in the user profile
+- Clears some inconsistencies in translated strings
+- Fixes client tags
+- Fixes routes for AppDefinition events.
+
+<a id="v1.06.1"></a>
+# [Release v1.06.1: Fixes](https://github.com/vitorpamplona/amethyst/releases/tag/v1.06.1) - 2026-03-23
+
+- Improvements to the rendering of Polls.
+- Solves some of the crashes of the concurrent modification exception
+- Fixes URL parsers with Japanese chars
+- Fixes Wallet import from Primal on Poco phones
+- Improves the wording of the Last Seen
+- Fixes for "Cannot disable reuse from root if it was caused by other groups"
+- Fixes comparator to avoid Comparison method violates its general contract!
+- Improves zap-store settings
+
+<a id="v1.06.0"></a>
+# [Release v1.06.0: Polls, Relay Feeds, Wallets and much more](https://github.com/vitorpamplona/amethyst/releases/tag/v1.06.0) - 2026-03-21
+
+Polls:
+- Adds support for creating and rendering NIP-85
+- Redesign of the poll and zap poll cards
+- Adds special notification card while the poll is running
+
+Relay Feeds
+- Adds support for rendering relay feeds
+- Adds support for NIP-51 favorite relay feeds
+- Shows favorite relays in the top navigation filter
+- Clicking wss:// links shows the global feed for that relay.
+- New user account adds nostr.wine to favorite relay feeds
+
+Media Player
+- Redesigned player controls for videos, audios, and picture-in-picture.
+- Adds our own buttons and indicators for the video playback
+- Adds Music support with waveform animations
+- Migrates to new Media3 content view frames
+- Improved Picture in Picture actions
+- Turn video controller creation into a flow to fix playback lifecycle issues
+- Adds support for uploading audio
+
+NWC Wallets:
+- Adds support for NIP-47 Wallets and compete NWC spec
+- Adds views for Balance and Transactions
+- Add transaction filtering and pagination to wallet screen
+- Added several test cases from other repos to guarantee interoperability
+
+Calendar:
+- Adds support for NIP-52 Calendar appointments
+- Adds proper display of calendar time slot and date slot events in the note feed
+- Refactored the early implementation on Quartz for easier use
+
+Code Snippets:
+- Adds support for NIP-C0 Code Snippets
+- Replies using NIP-22
+
+NIPs on Nostr
+- Adds support for event kind 30817
+- Replies using NIP-22
+
+PayTo:
+- Adds support for NIP-A3 Payment targets by @npub1w4uswmv6lu9yel005l3qgheysmr7tk9uvwluddznju3nuxalevvs2d0jr5
+
+Blossom BUD-10:
+- Adds support for "Blossom:" URIs on the post
+- Supports automatic discovery of blossom servers
+- Renders/Previews images, audios, videos, and documents
+- Includes support for encryption when using it in NIP-17 DMs.
+
+Expirations
+- Adds enhanced support for custom expirations in any new post.
+- Displays expirations on posts and DMs
+
+Relay Monitors:
+- Adds support for NIP-66 Relay monitor and discovery support to Quartz
+
+Attestations:
+- Adds support for rendering Attestations (https://attestr.xyz/)
+- Recommendations, Requests and Attestor Declarations are also included.
+
+Chess:
+- Adds basic support for Chess with Jester protocol
+- Full chess game implemented
+- Supports for game challenges and view external games
+- Running on debug only for now
+
+DMs:
+- Removes NIP-04 DMs
+- Blocks DM sending if the receiver doesn't have NIP-17 relay lists.
+- Removed incognito icon from the new post field.
+
+Push Notifications:
+- Adds support for inline reply
+- Adds support for notification grouping
+- Adds support for Async image Loading
+- Removed NIP-04 notifications
+
+Long Form:
+- Adds support for writing Long Form/Markdown content
+- Includes support for automatic Draft saving and editing
+- Includes support for editing
+
+Uploads:
+- Adds support to upload Documents to all new post screens.
+- Adds toggle to stip file metadata regardless of compression by @npub1e2yuky03caw4ke3zy68lg0fz3r4gkt94hx4fjmlelacyljgyk79svn3eef
+- Adds encrypted file upload fallback option for NIP-17 chats
+- Removes support for NIP-96 and updates Blossom recommendations
+
+Content Warning:
+- Adds an optional description field for sensitive content warnings in new posts.
+- Displays additional information on warning composables
+
+Settings redesign:
+- Consolidate drawer settings into a single Settings hub screen
+- Redesigns Zap Amount and NWC setup screens
+- Redesigns Custom zap amount screens
+- Adds brand new Translation Settings screen
+- Adds blockchain explorer settings page for OTS verification
+- Adds reactions row settings (enable/disable, order, show/hide counters) by @npub1w4uswmv6lu9yel005l3qgheysmr7tk9uvwluddznju3nuxalevvs2d0jr5
+- Tapping on Zap without any pre-configured amount opens the custom dialog
+
+Content parsers:
+- URL/URI parser rewrite in Kotlin multiplatform (KMP)
+- Fixes characters attached to URLs or nostr URLs without a space
+- Massively increases parsing performance
+- Treat multibyte characters as URL terminators in RichTextParser by @npub1k0jrarx8um0lyw3nmysn50539ky4k8p7gfgzgrsvn8d7lccx3d0s38dczd
+- Adds a parser for blossom: uris
+
+UI Improvements:
+- Minimizes parent thread rendering in quoted notes by @npub1aeh2zw4elewy5682lxc6xnlqzjnxksq303gwu2npfaxd49vmde6qcq4nwx
+- New Material 3 UI for DropDowns by @npub1e2yuky03caw4ke3zy68lg0fz3r4gkt94hx4fjmlelacyljgyk79svn3eef
+- New Material 3 UI for feed filters by @npub1e2yuky03caw4ke3zy68lg0fz3r4gkt94hx4fjmlelacyljgyk79svn3eef
+- Draft Screen requests confirmation before deleting drafts on swipe
+- Swipe to switch tabs. Main screen and messages by @npub1e2yuky03caw4ke3zy68lg0fz3r4gkt94hx4fjmlelacyljgyk79svn3eef
+- Adds support for rendering Zap events when quoted inside of posts.
+- Adds a Broadcasting feedback pop-up in the Complete UI mode
+
+Relay Management:
+- Adds relay search tooltip when adding relays
+- Adds the list of keys using each relay to the relay information
+- Adds active subscriptions and outbox event in the queue to relay information
+- Adds a complete list of event kind names to the subscription card to relay information
+- Tracks and displays connection success rate on relay settings
+- Adds relay settings export functionality
+- Adds NIP-45 count queries to show how many events each relay has.
+- Adds Relay sync utility to help users move posts between relays.
+
+Search:
+- Breaks the search filter into two subscriptions to prioritize Metadata without punishing content.
+- Fixes the need to start user searches with @ in user fields
+- Fixes the stability of the search feed when the user navigates away and back.
+- Replaces about me for NIP-05 in the user search results
+- Adds relay URL search to the search page
+- Forces returning one user when searching by nip-05
+- Removes outdated versions of addressables from the search results
+
+Profiles:
+- Adds support for NIP-39 External Identities with kind 10011
+- Adds a profile picture upload button when the user has no picture
+- Adds last seen to the user profile
+- Adds nprofile and npub copy options to the profile
+- Groups received zap amounts by sending the user in the profile tab
+- Increases the limit of Zap downloads for profiles to 1000
+- Simplifies profile edit screen layout by @npub1aeh2zw4elewy5682lxc6xnlqzjnxksq303gwu2npfaxd49vmde6qcq4nwx
+- Migrates profile galleries to display a thumbnail for videos
+- Fixes profile galleries' aspect ratios
+- Adds support for Namecoin .bit urls to NIP-05 and choice of ElectrumX server to resolve namecoins.
+
+Onboarding
+- Adds bulk follow screens to search for a user and to copy his/her follow list
+
+Voice message by @npub1e2yuky03caw4ke3zy68lg0fz3r4gkt94hx4fjmlelacyljgyk79svn3eef
+- Adds voice anonymization
+- Change from "hold to record" to "click to start, click to stop"
+- Display kind 1 voice replies as an audio waveform
+- Increases max voice record duration to 600 seconds
+- Switches the public message event to use quoted posts for replies
+
+Fixes:
+- Fixes "forked from" label rendering over the name
+- Avoids crashing when the `k` tag cannot be parsed to a number
+- Only use Voice Reply events when replying to voice notes. Others just receive a URL.
+- Fixes the lack of update in the follow count on the UserProfile page
+- Fixes out of memory when downloading large videos
+- Fixes Jackson deserialization for empty Filters and add regression test by @npub1w4uswmv6lu9yel005l3qgheysmr7tk9uvwluddznju3nuxalevvs2d0jr5
+- Fixes NullPointerException when the filter contains tags
+- Fixes download cancellations when screen components disappear
+- Migrates to use "title" instead of "name" tags for NIP-51 lists
+- Adds a longer crop for npubs so that we can see vanity keys better
+- Fixes the need to have tags and kinds for inbox.nostr.wine to work
+- Blocks the size of Relay Auth Status arrays from growing forever with auth messages
+- Fixes crash when getting OpenGraph tags of invalid URLs
+- Fixes NIP-44 key mutation in NIP-46 connect
+- Location permission watcher moved outside screens to avoid recreation
+- Solves the sorting contract crash on search by precaching all values before sorting users.
+- Fixes lingering relay connections from loading follows outbox's settings.
+- Enhance NIP-38 user status display with emoji support and metadata tags
+- Fixes bug on Show More calculations for very long texts without spaces
+- Fixing IO Dispatchers and coroutine scopes of choice
+- Fixes anySync parallel operation that was returning the first result, not the first positive "any".
+- Fixes Req onCannotConnect listeners to the relays that actually sent the req
+- Fixes hanging subscriptions when exceptions happen during NostrClient utility methods
+
+Defaults:
+- Switches wss://nostr.band to wss://antiprimal.net, wss://relay.ditto.pub on app defaults
+- Adds wss://nostr.wine, wss://news.utxo.one as favorite relay feeds
+- Adds wss://directory.yabu.me and wss://profiles.nostr1.com as index relays
+- Adds electrumx.testls.space, nmc2.bitcoins.sk, 46.229.238.187 and i665jpwsq46zlsdbnj4axgzd3s56uzey5uhotsnxzsknzbn36jaddsid.onion as ElectrumX servers
+
+Quartz:
+- Adds Relay Server implementation with NIP-45 COUNT and NIP-42 AUTH support
+- Adds support for dynamic auth policies to the relay implementation.
+- Migrates Quartz EventStore from Android-only to KMP
+- Adds a reqUntilEoseAsFlow extension to the Nostr Client
+- Adds a reqBypassingRelayLimits extension to the Nostr Client
+- Adds comprehensive NIP-46 Bunker support
+- Adds comprehensive support for NIP-47 non-payment methods.
+
+Adds complete support for iOS to Quartz by @npub1a3tx8wcrt789skl6gg7rqwj4wey0j53eesr4z6asd4h4jwrd62jq0wkq4k
+- Provide implementation for Rfc3986 on iOS, using the Swift Rfc3986UriBridge.
+- Provide implementation for LargeCache, using a CacheMap
+- Provide implementation for fastFindURLs()
+- Provide implementation for makeAbsoluteIfRelativeUrl() in ServerInfoParser.ios.kt
+- Provide implementation for UrlEncoder
+- Provide implementation for UnicodeNormalizer
+- Provide implementation for GZip compression/decompression. Some small fixes in URLs.ios.kt
+- Provide implementation for AESCBC
+- Provide implementation for AESGCM
+- Provide implementation for DigestInstance
+- Provide implementation for LibSodium
+
+Amethyst Desktop by @npub12cfje6nl2nuxplcqfvhg7ljt89fmpj0n0fd24zxsukja5qm9wmtqd7y76c
+- Adds NIP-46 Bunker Login
+- Adds Support for Chess
+- Adds Thread Screens
+- Adds advanced search with query engine and filter panel
+- Adds encrypted DMs (NIP-04/NIP-17)
+- Adds proper empty states with EOSE tracking
+- Adds multi-column deck layout
+- Adds Full media parity — images, video, audio, encrypted DMs, upload, lightbox
+- Adds advanced search with NIP-50, collapsible sections, and nav state preservation
+- Clear stored credentials on logout
+- Adds bunker heartbeat indicator
+- Adds QR-based signer pairing
+- Migrates lifecycle-viewmodel KMP dependencies to KMP/Commons
+- Migrates drawReplyLevel modifier to KMP/Commons
+- Migrates ThreadFilter to KMP/Commons
+- Migrates Card interface and CardFeedState to KMP/Commons
+- Migrates Channels (public chats, ephemeral channels, and live streams) Account modules to KMP/Commons
+- Migrates private chatroom models to KMP/Commons
+- Migrates reports states to KMP/Commons
+- Migrates Emoji State to KMP/Commons
+- Migrates lud06 to lud16 mapping to KMP/Quartz
+- Migrates the new LocalCache observables to KMP/Commons
+- Migrates rich text parser from JVM to KMP/Commons
+
+Code Quality
+- Migrates to AGP 9.0
+- Adds Amethyst Desktop to CI/CD and Release builds
+- Removes the in-app memory counter methods
+- Refactors the old NIP-05 code on Quartz
+- Migrates contact list management to addressable notes
+- Creates new observable flows for LocalCache.
+- Moves metadata methods from User to UserCache objects
+- Separate Addressable vs Replaceable event class bases
+- Avoid dependency on AccountSettings for NwcSignerState
+- Finishes the transition to EventHint objects for building events.
+- Lots of code review fixes by @npub1e2yuky03caw4ke3zy68lg0fz3r4gkt94hx4fjmlelacyljgyk79svn3eef
+- Large accessibility review by @npub1e2yuky03caw4ke3zy68lg0fz3r4gkt94hx4fjmlelacyljgyk79svn3eef
+- Moves Top Nav Filter markers from Strings to full objects.
+- Removes support for feed definitions
+- AccountState refactoring
+
+AI:
+- Add SKILL.md for AI agent customization
+- Add settings and hooks to setup Android Development for the agent
+
+Updated translations:
+- Czech, German, Swedish, and Portuguese by @npub1e2yuky03caw4ke3zy68lg0fz3r4gkt94hx4fjmlelacyljgyk79svn3eef
+- Hungarian by @npub1dnvslq0vvrs8d603suykc4harv94yglcxwna9sl2xu8grt2afm3qgfh0tp
+- French by @npub106efcyntxc5qwl3w8krrhyt626m59ya2nk9f40px5s968u5xdwhsjsr8fz
+- Polish by @npub16gjyljum0ksrrm28zzvejydgxwfm7xse98zwc4hlgq8epxeuggushqwyrm
+- Hindi by @npub1ww6huwu3xye6r05n3qkjeq62wds5pq0jswhl7uc59lchc0n0ns4sdtw5e6
+- Slovenian by @npub1qqqqqqz7nhdqz3uuwmzlflxt46lyu7zkuqhcapddhgz66c4ddynswreecw
+- Bengali by @npub13qtw3yu0uc9r4yj5x0rhgy8nj5q0uyeq0pavkgt9ly69uuzxgkfqwvx23t
+- Chinese by hypnotichemionus4
+- Spanish by @npub1luhyzgce7qtcs6r6v00ryjxza8av8u4dzh3avg0zks38tjktnmxspxq903
+- Russian by Anton Zhao
+
+<a id="v1.05.1"></a>
+# [Release v1.05.1: BugFixes](https://github.com/vitorpamplona/amethyst/releases/tag/v1.05.0) - 2026-01-08
+
+- Fixed mixed DMs between logged in users.
+- Fixed draft screen click to edit post.
+
 <a id="v1.05.0"></a>
-# [Release v1.05.0: Bookmark Lists and WoT Scores](https://github.com/vitorpamplona/amethyst/releases/tag/v1.05.0) - 2025-01-08
+# [Release v1.05.0: Bookmark Lists and WoT Scores](https://github.com/vitorpamplona/amethyst/releases/tag/v1.05.0) - 2026-01-08
 
 #Amethyst v1.05.0: Bookmark Lists, Voice Notes, and WoT Scores
 
@@ -6800,4 +7303,4 @@ First public version with:
 [v0.4]: https://github.com/vitorpamplona/amethyst/compare/v0.3...v0.4
 [v0.3]: https://github.com/vitorpamplona/amethyst/compare/v0.2...v0.3
 [v0.2]: https://github.com/vitorpamplona/amethyst/compare/v0.1...v0.2
-[v0.1]: https://github.com/vitorpamplona/amethyst/tree/v0.1
+[v0.1]: https://github.com/vitorpamplona/amethyst/tree/v0.1

README.md

@@ -39,85 +39,104 @@ height="70">](https://github.com/vitorpamplona/amethyst/releases)
 
 <img align="right" src="./docs/screenshots/home.png" data-canonical-src="./docs/screenshots/home.png" width="350px">
 
-- [x] Events / Relay Subscriptions (NIP-01)
+- [x] Basic protocol flow (NIP-01)
 - [x] Follow List (NIP-02)
 - [x] OpenTimestamps Attestations (NIP-03)
-- [x] Private Messages (NIP-04)
-- [x] DNS Address (NIP-05)
-- [x] Mnemonic seed phrase (NIP-06)
-- [ ] WebBrowser Signer (NIP-07, Not applicable)
-- [x] Old-style mentions (NIP-08)
-- [x] Event Deletion (NIP-09)
-- [x] Replies, mentions, Threads, and Notifications (NIP-10)
+- [x] Encrypted Direct Message (NIP-04)
+- [x] DNS-based Identifiers (NIP-05)
+- [x] Key Derivation from Mnemonic (NIP-06)
+- [ ] window.nostr for Web Browsers (NIP-07, Not applicable)
+- [x] Handling Mentions (NIP-08)
+- [x] Event Deletion Request (NIP-09)
+- [x] Text Notes and Threads (NIP-10)
 - [x] Relay Information Document (NIP-11)
-- [x] Generic Tag Queries (NIP-12)
-- [x] Proof of Work Display (NIP-13)
-- [ ] Proof of Work Calculations (NIP-13)
-- [x] Events with a Subject (NIP-14)
-- [ ] Marketplace (NIP-15)
-- [x] Event Treatment (NIP-16)
+- [x] Proof of Work (NIP-13)
+- [x] Subject Tag in Text Events (NIP-14)
+- [x] Nostr Marketplace (NIP-15)
 - [x] Private Direct Messages (NIP-17)
-- [x] Image/Video/Url/LnInvoice Previews
-- [x] Reposts, Quotes, Generic Reposts (NIP-18)
-- [x] Bech Encoding support (NIP-19)
-- [x] Command Results (NIP-20)
-- [x] URI Support (NIP-21)
-- [x] Long-form Content (NIP-23) (view only)
-- [x] User Profile Fields / Relay list (NIP-24)
+- [x] Reposts (NIP-18)
+- [x] bech32-encoded Entities (NIP-19)
+- [x] nostr: URI Scheme (NIP-21)
+- [x] Comment (NIP-22)
+- [x] Long-form Content (NIP-23)
+- [x] Extra Metadata Fields and Tags (NIP-24)
 - [x] Reactions (NIP-25)
-- [ ] Delegated Event Signing (NIP-26, Will not implement)
+- [x] Delegated Event Signing (NIP-26)
 - [x] Text Note References (NIP-27)
-- [x] Public Chats (NIP-28)
-- [ ] Relay-based Groups (NIP-29)
+- [x] Public Chat (NIP-28)
+- [x] Relay-based Groups (NIP-29)
 - [x] Custom Emoji (NIP-30)
-- [x] Event kind summaries (NIP-31)
-- [ ] Labeling (NIP-32)
-- [x] Parameterized Replaceable Events (NIP-33)
-- [x] Git Stuff (NIP-34)
-- [ ] Torrents (NIP-35)
+- [x] Dealing with Unknown Events (NIP-31)
+- [x] Labeling (NIP-32)
+- [x] git stuff (NIP-34)
+- [x] Torrents (NIP-35)
 - [x] Sensitive Content (NIP-36)
-- [x] Edits (NIP-37/Draft)
-- [x] User Status Event (NIP-38)
-- [x] External Identities (NIP-39)
-- [x] Expiration Support (NIP-40)
-- [x] Relay Authentication (NIP-42)
-- [x] Versioned Encrypted Payloads (NIP-44)
-- [ ] Event Counts (NIP-45, Will not implement)
-- [ ] Nostr Connect (NIP-46)
-- [x] Wallet Connect API (NIP-47)
-- [ ] Proxy Tags (NIP-48, Not applicable)
-- [x] Private key encryption for import/export (NIP-49)
-- [x] Online Relay Search (NIP-50)
+- [x] Draft Events (NIP-37)
+- [x] User Statuses (NIP-38)
+- [x] External Identities in Profiles (NIP-39)
+- [x] Expiration Timestamp (NIP-40)
+- [x] Authentication of Clients to Relays (NIP-42)
+- [x] Relay Access Metadata and Requests (NIP-43)
+- [x] Encrypted Payloads / Versioned (NIP-44)
+- [x] Counting Results (NIP-45)
+- [x] Nostr Remote Signing (NIP-46)
+- [x] Nostr Wallet Connect (NIP-47)
+- [x] Proxy Tags (NIP-48)
+- [x] Private Key Encryption (NIP-49)
+- [x] Search Capability (NIP-50)
 - [x] Lists (NIP-51)
-- [ ] Calendar Events (NIP-52)
-- [x] Live Activities & Live Chats (NIP-53)
+- [x] Calendar Events (NIP-52)
+- [x] Live Activities (NIP-53)
 - [x] Wiki (NIP-54)
-- [x] Inline Metadata (NIP-55 - Draft)
+- [x] Android Signer Application (NIP-55)
 - [x] Reporting (NIP-56)
-- [x] Lightning Tips
-- [x] Zaps (NIP-57)
-- [x] Private Zaps
+- [x] Lightning Zaps (NIP-57)
 - [x] Zap Splits (NIP-57)
+- [x] Private Zaps (NIP-57)
+- [x] Zapraiser (NIP-57)
 - [x] Badges (NIP-58)
-- [x] Gift Wraps & Seals (NIP-59)
-- [x] Zapraiser (NIP-TBD)
-- [ ] Relay List Metadata (NIP-65)
-- [x] Polls (NIP-69)
+- [x] Gift Wrap (NIP-59)
+- [x] Pubkey Static Websites (NIP-5A)
+- [x] Cashu Wallet (NIP-60)
+- [x] Nutzaps (NIP-61)
+- [x] Request to Vanish (NIP-62)
+- [x] Chess / PGN (NIP-64)
+- [x] Relay List Metadata (NIP-65)
+- [x] Relay Discovery and Liveness Monitoring (NIP-66)
+- [x] Picture-first Feeds (NIP-68)
+- [x] Peer-to-peer Order Events (NIP-69)
+- [x] Protected Events (NIP-70)
 - [x] Video Events (NIP-71)
 - [x] Moderated Communities (NIP-72)
-- [ ] Zap Goals (NIP-75)
-- [x] Arbitrary Custom App Data (NIP-78)
+- [x] External Content IDs (NIP-73)
+- [x] Zap Goals (NIP-75)
+- [x] Negentropy Syncing (NIP-77)
+- [x] Application-specific Data (NIP-78)
+- [x] Threads (NIP-7D)
 - [x] Highlights (NIP-84)
-- [x] Notify Request (NIP-88/Draft)
+- [x] Trusted Assertions (NIP-85)
+- [x] Relay Management API (NIP-86)
+- [x] Ecash Mint Discoverability (NIP-87)
+- [x] Polls (NIP-88)
 - [x] Recommended Application Handlers (NIP-89)
-- [x] Data Vending Machine (NIP-90)
-- [x] Inline Metadata (NIP-92)
-- [x] Verifiable file URLs (NIP-94)
+- [x] Data Vending Machines (NIP-90)
+- [x] Media Attachments (NIP-92)
+- [x] File Metadata (NIP-94)
 - [x] Binary Blobs (NIP-95/Draft)
 - [x] HTTP File Storage Integration (NIP-96)
 - [x] HTTP Auth (NIP-98)
-- [x] Classifieds (NIP-99)
+- [x] Classified Listings (NIP-99)
+- [x] Voice Messages (NIP-A0)
+- [x] Public Messages (NIP-A4)
+- [x] Web Bookmarks (NIP-B0)
+- [x] Blossom (NIP-B7)
+- [x] Nostr BLE Communications Protocol (NIP-BE)
+- [x] Code Snippets (NIP-C0)
+- [x] Chats (NIP-C7)
+- [ ] MLS Protocol (NIP-EE)
 - [x] Audio Tracks (zapstr.live) (kind:31337)
+- [x] Lightning Tips
+- [x] Image/Video/Url/LnInvoice/Cashu Previews
 - [x] Push Notifications (Google and Unified Push)
 - [x] In-Device Automatic Translations
 - [x] Hashtag Following and Custom Hashtags
@@ -128,18 +147,15 @@ height="70">](https://github.com/vitorpamplona/amethyst/releases)
 - [x] Markdown Support
 - [x] Medical Data (NIP-xx/Draft)
 - [x] Embed events (NIP-xx/Draft)
-- [x] Draft Events (NIP-xx/Draft)
-- [ ] Event Sets (NIP-xx/Draft)
-- [ ] Topical Notes  (NIP-xx/Draft)
+- [x] Edit Short Notes (NIP-xx/Draft)
+- [x] NIP Events (NIP-xx/Draft)
 - [ ] Relationship Status (NIP-xx/Draft)
 - [ ] Signed Filters (NIP-xx/Draft)
 - [ ] Key Migration (NIP-xx/Draft)
-- [ ] Time-based Sync (NIP-xx/Draft)
 - [x] Image Capture in the app
 - [x] Video Capture in the app
 - [ ] Local Database
 - [ ] Workspaces
-- [ ] Infinity Scroll
 
 ## Privacy and Information Permanence
 
@@ -199,6 +215,13 @@ Build and run the Desktop app (requires Java 21+):
 ```bash
 ./gradlew :desktopApp:run
 ```
+Full build (including tests)
+```bash
+./gradlew build
+```
+Requirements:
+- Xcode and iOS simulator
+- libsodium installed (e.g. via brew: `brew install libsodium`
 
 ## Testing
 ```bash
@@ -379,24 +402,24 @@ to `onPause` methods.
 
 ### Feature Parity Table
 
-| Feature Category | Feature / Component | Android / JVM Support | iOS Support | Notes |
-| :--- | :--- | :---: | :---: | :--- |
-| **Cryptography** | Secp256k1 (Schnorr, Keys) | ✅ Full | ❌ No | Core Nostr signing/verification is missing on iOS. |
-| | LibSodium (ChaCha20, Poly1305) | ✅ Full | ❌ No | AEAD and stream ciphers are unimplemented. |
-| | AES Encryption (CBC & GCM) | ✅ Full | ❌ No | `AESCBC` and `AESGCM` are stubs on iOS. |
-| | Hashing (SHA-256, etc.) | ✅ Full | ❌ No | `DigestInstance` is unimplemented. |
-| | MAC (HmacSHA256, etc.) | ✅ Full | ❌ No | `MacInstance` is unimplemented. |
-| **Data & Serialization** | JSON Mapping (Optimized) | ✅ Full | ❌ No | `OptimizedJsonMapper` is a stub; cannot parse/serialize Events. |
-| | GZip Compression | ✅ Full | ❌ No | `GZip` implementation is missing. |
-| | BitSet | ✅ Full | ❌ No | `BitSet` utility is unimplemented. |
-| | LargeCache | ✅ Full | ❌ No | `LargeCache` methods (get, keys, size, etc.) are stubs. |
-| **NIP Support** | NIP-96 (File Storage Info) | ✅ Full | ❌ No | `ServerInfoParser` is unimplemented. |
-| | NIP-46 (Remote Signer) | ✅ Full | ⚠️ Partial | Some methods in `NostrSignerRemote` are unimplemented in `commonMain`. |
-| | NIP-03 (OTS / Timestamps) | ✅ Full | ❌ No | `BitcoinExplorer` and `RemoteCalendar` have stubs in `commonMain`. |
-| **Utilities** | URL Encoding / Decoding | ✅ Full | ❌ No | `UrlEncoder` and `URLs.ios.kt` are unimplemented. |
-| | Unicode Normalization | ✅ Full | ❌ No | `UnicodeNormalizer` is a stub. |
-| | Platform Logging | ✅ Full | ✅ Full | iOS uses `NSLog`, Android uses standard Log. |
-| | Current Time | ✅ Full | ✅ Full | Implemented using `NSDate` on iOS. |
+| Feature Category         | Feature / Component            | Android / JVM Support | iOS Support | Notes                                                                  |
+|:-------------------------|:-------------------------------|:---------------------:|:-----------:|:-----------------------------------------------------------------------|
+| **Cryptography**         | Secp256k1 (Schnorr, Keys)      |        ✅ Full         |   ✅ Full    |                                                                        |
+|                          | LibSodium (ChaCha20, Poly1305) |        ✅ Full         |   ✅ Full    |                                                                        |
+|                          | AES Encryption (CBC & GCM)     |        ✅ Full         |   ✅ Full    |                                                                        |
+|                          | Hashing (SHA-256, etc.)        |        ✅ Full         |   ✅ Full    |                                                                        |
+|                          | MAC (HmacSHA256, etc.)         |        ✅ Full         |   ✅ Full    |                                                                        |
+| **Data & Serialization** | JSON Mapping (Optimized)       |        ✅ Full         |   ✅ Full    | A fully custom implementation exists in `commonMain`.                  |
+|                          | GZip Compression               |        ✅ Full         |   ✅ Full    |                                                                        |
+|                          | BitSet                         |        ✅ Full         |   ✅ Full    |                                                                        |
+|                          | LargeCache                     |        ✅ Full         |   ✅ Full    |                                                                        |
+| **NIP Support**          | NIP-96 (File Storage Info)     |        ✅ Full         |   ✅ Full    |                                                                        |
+|                          | NIP-46 (Remote Signer)         |        ✅ Full         | ⚠️ Partial  | Some methods in `NostrSignerRemote` are unimplemented in `commonMain`. |
+|                          | NIP-03 (OTS / Timestamps)      |        ✅ Full         |    ❌ No     | `BitcoinExplorer` and `RemoteCalendar` have stubs in `commonMain`.     |
+| **Utilities**            | URL Encoding / Decoding        |        ✅ Full         |   ✅ Full    |                                                                        |
+|                          | Unicode Normalization          |        ✅ Full         |   ✅ Full    |                                                                        |
+|                          | Platform Logging               |        ✅ Full         |   ✅ Full    | iOS uses `NSLog`, Android uses standard Log.                           |
+|                          | Current Time                   |        ✅ Full         |   ✅ Full    | Implemented using `NSDate` on iOS.                                     |
 
 
 ## Contributing

SKILL.md

@@ -0,0 +1,230 @@
+# Amethyst Builder Skill
+
+Build customized Amethyst Nostr clients for Android. Fork, rebrand, customize, and distribute your own version.
+
+## Overview
+
+[Amethyst](https://github.com/vitorpamplona/amethyst) is the premier Nostr client for Android. This skill enables you to:
+- Create rebranded versions (custom name, package, icons)
+- Build F-Droid-compatible releases (no Google Play dependencies)
+- Add or modify features
+- Sign and distribute APKs
+
+## Prerequisites
+
+### Required Tools
+
+1. **Java 21** (via SDKMAN)
+   ```bash
+   curl -s "https://get.sdkman.io" | bash
+   source "$HOME/.sdkman/bin/sdkman-init.sh"
+   sdk install java 21.0.5-tem
+   sdk use java 21.0.5-tem
+   ```
+
+2. **Android SDK**
+   - Command-line tools from https://developer.android.com/studio#command-line-tools-only
+   - Required components: build-tools, platform-tools, platforms;android-35
+
+3. **Git** for cloning the repository
+
+### Environment Setup
+
+```bash
+export ANDROID_HOME=$HOME/Android/Sdk
+export PATH=$PATH:$ANDROID_HOME/cmdline-tools/latest/bin
+export PATH=$PATH:$ANDROID_HOME/platform-tools
+```
+
+## Build Workflow
+
+### 1. Clone the Repository
+
+```bash
+mkdir -p ~/projects/your-app-name
+cd ~/projects/your-app-name
+git clone https://github.com/vitorpamplona/amethyst.git .
+```
+
+### 2. Create Signing Key
+
+```bash
+keytool -genkeypair -v \
+  -keystore ./release-key.jks \
+  -alias your-app \
+  -keyalg RSA -keysize 2048 \
+  -validity 10000
+```
+
+Create `keystore.properties` in project root:
+```properties
+storeFile=release-key.jks
+storePassword=your-password
+keyAlias=your-app
+keyPassword=your-password
+```
+
+### 3. Configure Signing
+
+Add to `amethyst/build.gradle` inside the `android {}` block:
+
+```gradle
+def keystorePropertiesFile = rootProject.file("keystore.properties")
+def keystoreProperties = new Properties()
+if (keystorePropertiesFile.exists()) {
+    keystoreProperties.load(new FileInputStream(keystorePropertiesFile))
+}
+
+signingConfigs {
+    release {
+        if (keystorePropertiesFile.exists()) {
+            storeFile rootProject.file(keystoreProperties['storeFile'])
+            storePassword keystoreProperties['storePassword']
+            keyAlias keystoreProperties['keyAlias']
+            keyPassword keystoreProperties['keyPassword']
+        }
+    }
+}
+```
+
+Update the release buildType to use the signing config:
+```gradle
+buildTypes {
+    release {
+        signingConfig signingConfigs.release
+        // ... existing config
+    }
+}
+```
+
+### 4. Disable Google Services (Required for F-Droid)
+
+**⚠️ CRITICAL:** The Google Services plugin fails when you change the package name. For F-Droid builds, disable it.
+
+Edit `amethyst/build.gradle`, comment out the plugin:
+```gradle
+plugins {
+    alias(libs.plugins.androidApplication)
+    alias(libs.plugins.jetbrainsKotlinAndroid)
+    // alias(libs.plugins.googleServices)  // DISABLED for F-Droid
+    alias(libs.plugins.jetbrainsComposeCompiler)
+}
+```
+
+### 5. Build
+
+```bash
+source "$HOME/.sdkman/bin/sdkman-init.sh"
+sdk use java 21.0.5-tem
+./gradlew assembleFdroidRelease
+```
+
+**Build time:** ~9 minutes first build, faster on subsequent builds.
+
+### 6. Locate APKs
+
+Output directory: `amethyst/build/outputs/apk/fdroid/release/`
+
+Files generated:
+- `amethyst-fdroid-arm64-v8a-release.apk` - ARM64 (most phones)
+- `amethyst-fdroid-universal-release.apk` - All architectures (larger)
+
+## Customizations
+
+### Change App Name
+
+Edit `amethyst/src/main/res/values/strings.xml`:
+```xml
+<string name="app_name" translatable="false">YourAppName</string>
+<string name="app_name_debug" translatable="false">YourAppName Debug</string>
+```
+
+### Change Package ID
+
+Edit `amethyst/build.gradle`:
+```gradle
+android {
+    defaultConfig {
+        applicationId = "com.yourcompany.yourapp"
+    }
+}
+```
+
+### Change Project Name
+
+Edit `settings.gradle`:
+```gradle
+rootProject.name = "YourAppName"
+```
+
+### Change App Icon
+
+Replace icon files in:
+- `amethyst/src/main/res/mipmap-*/ic_launcher.webp`
+- `amethyst/src/main/res/mipmap-*/ic_launcher_round.webp`
+
+### Add Client Tag to Posts
+
+Make your app identify itself on posts with `["client", "YourAppName"]`.
+
+**1. Create tag builder extension:**
+
+Create `quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/nip01Core/tags/clientTag/TagArrayBuilderExt.kt`:
+```kotlin
+package com.vitorpamplona.quartz.nip01Core.tags.clientTag
+
+import com.vitorpamplona.quartz.nip01Core.core.Event
+import com.vitorpamplona.quartz.nip01Core.core.TagArrayBuilder
+
+fun <T : Event> TagArrayBuilder<T>.client(clientName: String) = 
+    addUnique(arrayOf(ClientTag.TAG_NAME, clientName))
+```
+
+**2. Add to TextNoteEvent:**
+
+Edit `quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/nip10Notes/TextNoteEvent.kt`:
+
+Add import:
+```kotlin
+import com.vitorpamplona.quartz.nip01Core.tags.clientTag.client
+```
+
+In both `build()` functions, add after `alt(...)`:
+```kotlin
+client("YourAppName")
+```
+
+### Modify Default Relays
+
+Edit relay configuration in `quartz/src/main/java/com/vitorpamplona/quartz/nip01Core/relay/` or the UI settings files.
+
+## Troubleshooting
+
+### google-services.json error
+Disable the Google Services plugin (see step 4).
+
+### Java version error
+```bash
+sdk use java 21.0.5-tem
+java -version  # Must show 21.x
+```
+
+### Out of memory
+Edit `gradle.properties`:
+```properties
+org.gradle.jvmargs=-Xmx4g -XX:MaxMetaspaceSize=512m
+```
+
+### Clean build
+```bash
+./gradlew --stop
+./gradlew clean
+./gradlew assembleFdroidRelease
+```
+
+## Distribution
+
+Deploy APKs via:
+- **Surge.sh:** `surge ./releases your-app.surge.sh`
+- **Zapstore:** Submit to zapstore.dev
+- **Direct download:** Host on any web server

amethyst/build.gradle

@@ -2,11 +2,9 @@ import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
 plugins {
     alias(libs.plugins.androidApplication)
-    alias(libs.plugins.jetbrainsKotlinAndroid)
     alias(libs.plugins.googleServices)
     alias(libs.plugins.jetbrainsComposeCompiler)
     alias(libs.plugins.serialization)
-    alias(libs.plugins.stability.analyzer)
 }
 
 def getCurrentBranch() {
@@ -37,6 +35,17 @@ def generateVersionName(String baseVersion) {
     }
 }
 
+// Workaround: stability.analyzer plugin doesn't declare task dependencies properly for Gradle 9.x
+afterEvaluate {
+    def stabilityNames = tasks.names.findAll { it.contains("StabilityCheck") }
+    def compileNames = tasks.names.findAll { it.matches("compile.*UnitTestKotlin") }
+    stabilityNames.each { scName ->
+        compileNames.each { ctName ->
+            tasks.named(scName).configure { mustRunAfter(tasks.named(ctName)) }
+        }
+    }
+}
+
 android {
     namespace = 'com.vitorpamplona.amethyst'
     compileSdk = libs.versions.android.compileSdk.get().toInteger()
@@ -45,9 +54,9 @@ android {
         applicationId = "com.vitorpamplona.amethyst"
         minSdk = libs.versions.android.minSdk.get().toInteger()
         targetSdk = libs.versions.android.targetSdk.get().toInteger()
-        versionCode = 431
-        versionName = generateVersionName("1.05.0")
-        buildConfigField "String", "RELEASE_NOTES_ID", "\"b457a20195ffcf501389fcb708f0ef73f4ee263e3bba63f1b893a896129e4c79\""
+        versionCode = 442
+        versionName = generateVersionName("1.08.0")
+        buildConfigField "String", "RELEASE_NOTES_ID", "\"be99e8c8d4df0f54b44eb6c96976ccb38baeea0192436a1c6fc8bc5e930da6b0\""
 
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
         vectorDrawables {
@@ -192,6 +201,7 @@ android {
     buildFeatures {
         compose = true
         buildConfig = true
+        resValues = true
     }
 
     packagingOptions {
@@ -280,7 +290,7 @@ dependencies {
     // view videos
     implementation libs.androidx.media3.exoplayer
     implementation libs.androidx.media3.exoplayer.hls
-    implementation libs.androidx.media3.ui
+    implementation libs.androidx.media3.ui.compose.material3
     implementation libs.androidx.media3.session
 
     // important for proxy / tor
@@ -294,6 +304,10 @@ dependencies {
     implementation libs.coil.svg
     // enables network for coil
     implementation libs.coil.okhttp
+    // loads thumbnails for media3
+    // TODO: Replace this to the FrameExtractor in media 3
+    // when FrameExtractor accepts custom data sources.
+    implementation(libs.coil.video)
 
     // Permission to upload pictures:
     implementation libs.accompanist.permissions
@@ -332,9 +346,7 @@ dependencies {
     fdroidImplementation libs.unifiedpush
 
     // Charts
-    implementation libs.vico.charts.core
     implementation libs.vico.charts.compose
-    implementation libs.vico.charts.views
     implementation libs.vico.charts.m3
 
     // GeoHash
@@ -348,15 +360,18 @@ dependencies {
     // Image compression lib
     implementation libs.zelory.image.compressor
 
+    // EXIF metadata stripping
+    implementation libs.androidx.exifinterface
+
+    // Voice anonymization DSP
+    implementation libs.tarsosdsp
+
     // Cbor for cashuB format
     implementation libs.kotlinx.serialization.cbor
 
     // Kotlin serialization for the times where we need the Json tree and performance is not that important.
     implementation(libs.kotlinx.serialization.json)
 
-    implementation libs.tor.android
-    implementation libs.jtorctl
-
     testImplementation libs.junit
     testImplementation libs.mockk
     testImplementation libs.kotlinx.coroutines.test

amethyst/src/androidTest/java/com/vitorpamplona/amethyst/CashuBTest.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

amethyst/src/androidTest/java/com/vitorpamplona/amethyst/DMFileDecryptionTest.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

amethyst/src/androidTest/java/com/vitorpamplona/amethyst/ImageUploadTesting.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -80,7 +80,7 @@ class ImageUploadTesting {
             .addInterceptor(DefaultContentTypeInterceptor("Amethyst/${BuildConfig.VERSION_NAME}"))
             .build()
 
-    private suspend fun getBitmap(): ByteArray {
+    private fun getBitmap(): ByteArray {
         val bitmap = Bitmap.createBitmap(200, 300, Bitmap.Config.ARGB_8888)
         for (x in 0 until bitmap.width) {
             for (y in 0 until bitmap.height) {
@@ -121,20 +121,20 @@ class ImageUploadTesting {
                     context = InstrumentationRegistry.getInstrumentation().targetContext,
                 )
 
-        assertEquals("image/png", result.type)
-        assertEquals(paylod.size.toLong(), result.size)
-        assertEquals(initialHash, result.sha256)
-        assertEquals("${server.baseUrl}/$initialHash", result.url?.removeSuffix(".png"))
+        assertEquals(server.baseUrl, "image/png", result.type)
+        assertEquals(server.baseUrl, paylod.size.toLong(), result.size)
+        assertEquals(server.baseUrl, initialHash, result.sha256)
+        // assertEquals(server.baseUrl, "${server.baseUrl}/$initialHash", result.url?.removeSuffix(".png"))
 
         val imageData: ByteArray =
-            ImageDownloader().waitAndGetImage(result.url!!, { client })?.bytes
+            ImageDownloader().waitAndGetImage(result.url!!) { client }?.bytes
                 ?: run {
                     fail("${server.name}: Should not be null")
                     return
                 }
 
         val downloadedHash = sha256(imageData).toHexKey()
-        assertEquals(initialHash, downloadedHash)
+        assertEquals(server.baseUrl, initialHash, downloadedHash)
     }
 
     private suspend fun testNip96(server: ServerName) {
@@ -142,8 +142,7 @@ class ImageUploadTesting {
             ServerInfoRetriever()
                 .loadInfo(
                     server.baseUrl,
-                    { client },
-                )
+                ) { client }
 
         val payload = getBitmap()
         val inputStream = payload.inputStream()
@@ -172,7 +171,7 @@ class ImageUploadTesting {
         Assert.assertTrue("${server.name}: Invalid result url", url.startsWith("http"))
 
         val imageData: ByteArray =
-            ImageDownloader().waitAndGetImage(url, { client })?.bytes
+            ImageDownloader().waitAndGetImage(url) { client }?.bytes
                 ?: run {
                     fail("${server.name}: Should not be null")
                     return
@@ -207,8 +206,13 @@ class ImageUploadTesting {
         runBlocking {
             DEFAULT_MEDIA_SERVERS.forEach {
                 // skip paid servers and primal server is buggy.
-                if (!it.name.contains("Paid") && !it.name.contains("Primal")) {
-                    testBase(it)
+                try {
+                    if (!it.name.contains("Paid") && !it.name.contains("Primal")) {
+                        testBase(it)
+                    }
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                    fail("Could not upload to: ${it.baseUrl}: ${e.message}")
                 }
             }
         }
@@ -226,14 +230,6 @@ class ImageUploadTesting {
             testBase(ServerName("nostrage", "https://nostrage.com", ServerType.NIP96))
         }
 
-    @Test()
-    @Ignore("Not Working anymore")
-    fun testSove() =
-        runBlocking {
-            testBase(ServerName("sove", "https://sove.rent", ServerType.NIP96))
-        }
-
-    @Ignore("Not Working anymore")
     @Test()
     fun testNostrBuild() =
         runBlocking {
@@ -241,10 +237,10 @@ class ImageUploadTesting {
         }
 
     @Test()
-    @Ignore("Not Working anymore")
+    @Ignore("Returns invalid hash")
     fun testSovbit() =
         runBlocking {
-            testBase(ServerName("sovbit", "https://files.sovbit.host", ServerType.NIP96))
+            testBase(ServerName("sovbit", "https://cdn.sovbit.host", ServerType.Blossom))
         }
 
     @Test()
@@ -260,13 +256,6 @@ class ImageUploadTesting {
             testBase(ServerName("sprovoost.nl", "https://img.sprovoost.nl/", ServerType.NIP96))
         }
 
-    @Test()
-    @Ignore("Not Working anymore")
-    fun testNostrOnch() =
-        runBlocking {
-            testBase(ServerName("nostr.onch.services", "https://nostr.onch.services", ServerType.NIP96))
-        }
-
     @Ignore("Changes sha256")
     fun testPrimalBlossom() =
         runBlocking {

amethyst/src/androidTest/java/com/vitorpamplona/amethyst/OkHttpOtsTest.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

amethyst/src/androidTest/java/com/vitorpamplona/amethyst/ThreadDualAxisChartAssemblerTest.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -22,13 +22,13 @@ package com.vitorpamplona.amethyst
 
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.fasterxml.jackson.module.kotlin.readValue
+import com.vitorpamplona.amethyst.commons.viewmodels.thread.ThreadFeedFilter
 import com.vitorpamplona.amethyst.model.Account
 import com.vitorpamplona.amethyst.model.AccountSettings
 import com.vitorpamplona.amethyst.model.LocalCache
 import com.vitorpamplona.amethyst.service.location.LocationState
 import com.vitorpamplona.amethyst.service.okhttp.OkHttpWebSocket
 import com.vitorpamplona.amethyst.service.relayClient.reqCommand.nwc.NWCPaymentFilterAssembler
-import com.vitorpamplona.amethyst.ui.screen.loggedIn.threadview.dal.ThreadFeedFilter
 import com.vitorpamplona.quartz.nip01Core.core.Event
 import com.vitorpamplona.quartz.nip01Core.crypto.KeyPair
 import com.vitorpamplona.quartz.nip01Core.crypto.verify
@@ -70,9 +70,9 @@ class ThreadDualAxisChartAssemblerTest {
             Account(
                 settings = AccountSettings(keyPair = keyPair),
                 signer = NostrSignerInternal(keyPair),
-                geolocationFlow = MutableStateFlow<LocationState.LocationResult>(LocationState.LocationResult.Loading),
-                nwcFilterAssembler = NWCPaymentFilterAssembler(client),
-                otsResolverBuilder = EmptyOtsResolverBuilder,
+                geolocationFlow = { MutableStateFlow<LocationState.LocationResult>(LocationState.LocationResult.Loading) },
+                nwcFilterAssembler = { NWCPaymentFilterAssembler(client) },
+                otsResolverBuilder = { EmptyOtsResolverBuilder.build() },
                 cache = LocalCache,
                 client = client,
                 scope = scope,
@@ -174,7 +174,7 @@ class ThreadDualAxisChartAssemblerTest {
                     null,
                 )
 
-            val filter = ThreadFeedFilter(account, naddr.toTag())
+            val filter = ThreadFeedFilter(account, naddr.toTag(), LocalCache)
             val calculatedFeed = filter.feed()
 
             val expectedOrder =

amethyst/src/androidTest/java/com/vitorpamplona/amethyst/URIParserTest.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

amethyst/src/androidTest/java/com/vitorpamplona/amethyst/UrlUserTagTransformationTest.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -28,6 +28,7 @@ import androidx.test.platform.app.InstrumentationRegistry
 import com.vitorpamplona.amethyst.model.LocalCache
 import com.vitorpamplona.amethyst.ui.actions.buildAnnotatedStringWithUrlHighlighting
 import com.vitorpamplona.quartz.nip01Core.core.toHexKey
+import com.vitorpamplona.quartz.nip01Core.metadata.MetadataEvent
 import com.vitorpamplona.quartz.nip01Core.metadata.UserMetadata
 import com.vitorpamplona.quartz.nip19Bech32.decodePublicKey
 import org.junit.Assert.assertEquals
@@ -77,8 +78,19 @@ class UrlUserTagTransformationTest {
                 decodePublicKey("npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z")
                     .toHexKey(),
             )
-        user.info = UserMetadata()
-        user.info?.displayName = "Vitor Pamplona"
+        user.metadata().newMetadata(
+            UserMetadata().also {
+                it.displayName = "Vitor Pamplona"
+            },
+            MetadataEvent(
+                id = "",
+                pubKey = "",
+                createdAt = 0,
+                tags = emptyArray(),
+                content = "",
+                sig = "",
+            ),
+        )
 
         val original = "@npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z"
 
@@ -185,8 +197,19 @@ class UrlUserTagTransformationTest {
                 decodePublicKey("npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z")
                     .toHexKey(),
             )
-        user.info = UserMetadata()
-        user.info?.displayName = "Vitor Pamplona"
+        user.metadata().newMetadata(
+            UserMetadata().also {
+                it.displayName = "Vitor Pamplona"
+            },
+            MetadataEvent(
+                id = "",
+                pubKey = "",
+                createdAt = 0,
+                tags = emptyArray(),
+                content = "",
+                sig = "",
+            ),
+        )
 
         val transformedText =
             buildAnnotatedStringWithUrlHighlighting(
@@ -224,8 +247,20 @@ class UrlUserTagTransformationTest {
                 decodePublicKey("npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z")
                     .toHexKey(),
             )
-        user.info = UserMetadata()
-        user.info?.displayName = "Vitor Pamplona"
+
+        user.metadata().newMetadata(
+            UserMetadata().also {
+                it.displayName = "Vitor Pamplona"
+            },
+            MetadataEvent(
+                id = "",
+                pubKey = "",
+                createdAt = 0,
+                tags = emptyArray(),
+                content = "",
+                sig = "",
+            ),
+        )
 
         val transformedText =
             buildAnnotatedStringWithUrlHighlighting(

amethyst/src/androidTest/java/com/vitorpamplona/amethyst/ui/screen/loggedIn/relays/eventsync/EventSyncTest.kt

@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2025 Vitor Pamplona
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+ * Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package com.vitorpamplona.amethyst.ui.screen.loggedIn.relays.eventsync
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.vitorpamplona.amethyst.model.Constants
+import com.vitorpamplona.amethyst.service.okhttp.DefaultContentTypeInterceptor
+import com.vitorpamplona.quartz.nip01Core.crypto.KeyPair
+import com.vitorpamplona.quartz.nip01Core.relay.client.NostrClient
+import com.vitorpamplona.quartz.nip01Core.relay.client.accessories.RelayLogger
+import com.vitorpamplona.quartz.nip01Core.relay.client.auth.RelayAuthenticator
+import com.vitorpamplona.quartz.nip01Core.relay.normalizer.normalizeRelayUrl
+import com.vitorpamplona.quartz.nip01Core.relay.sockets.okhttp.BasicOkHttpWebSocket
+import com.vitorpamplona.quartz.nip01Core.signers.NostrSignerInternal
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.runBlocking
+import okhttp3.OkHttpClient
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class EventSyncTest {
+    companion object {
+        val vitor = "wss://vitor.nostr1.com".normalizeRelayUrl()
+        val fiatjaf = "wss://pyramid.fiatjaf.com".normalizeRelayUrl()
+        val appScope = CoroutineScope(Dispatchers.Default + SupervisorJob())
+
+        val rootClient =
+            OkHttpClient
+                .Builder()
+                .followRedirects(true)
+                .followSslRedirects(true)
+                .addInterceptor(DefaultContentTypeInterceptor("Amethyst/v1.05"))
+                .build()
+        val socketBuilder = BasicOkHttpWebSocket.Builder { url -> rootClient }
+    }
+
+    @Test
+    fun testSync() =
+        runBlocking {
+            val sync =
+                EventSync(
+                    accountPubKey = "460c25e682fda7832b52d1f22d3d22b3176d972f60dcdc3212ed8c92ef85065c",
+                    relayDb = {
+                        listOf(Constants.mom, Constants.nos)
+                    },
+                    outboxTargets = { setOf(vitor) },
+                    inboxTargets = { setOf(vitor) },
+                    dmTargets = { setOf(vitor) },
+                    clientBuilder = {
+                        NostrClient(socketBuilder, appScope)
+                    },
+                    scope = appScope,
+                )
+
+            sync.runSync()
+        }
+
+    @Test
+    fun testFiatjafSync() =
+        runBlocking {
+            val sync =
+                EventSync(
+                    accountPubKey = "460c25e682fda7832b52d1f22d3d22b3176d972f60dcdc3212ed8c92ef85065c",
+                    relayDb = { listOf(fiatjaf) },
+                    outboxTargets = { setOf(vitor) },
+                    inboxTargets = { setOf(vitor) },
+                    dmTargets = { setOf(vitor) },
+                    clientBuilder = {
+                        val newClient = NostrClient(socketBuilder, appScope)
+                        val logger = RelayLogger(newClient, debugSending = true, debugReceiving = false)
+
+                        val signer = NostrSignerInternal(KeyPair())
+
+                        // Authenticates with relays.
+                        val auth =
+                            RelayAuthenticator(
+                                newClient,
+                                appScope,
+                                signWithAllLoggedInUsers = { authTemplate ->
+                                    listOf(signer.sign(authTemplate))
+                                },
+                            )
+
+                        newClient
+                    },
+                    scope = appScope,
+                )
+
+            sync.runSync()
+        }
+}

amethyst/src/androidTestPlay/java/com/vitorpamplona/amethyst/TranslationsTest.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

amethyst/src/fdroid/java/com/vitorpamplona/amethyst/service/lang/LanguageTranslatorService.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

amethyst/src/fdroid/java/com/vitorpamplona/amethyst/service/notifications/PushDistributorHandler.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -46,7 +46,7 @@ object PushDistributorHandler : PushDistributorActions {
 
     fun setEndpoint(newEndpoint: String) {
         endpointInternal = newEndpoint
-        Log.d("PushHandler", "New endpoint saved : $endpointInternal")
+        Log.d("PushHandler") { "New endpoint saved : $endpointInternal" }
     }
 
     fun removeEndpoint() {

amethyst/src/fdroid/java/com/vitorpamplona/amethyst/service/notifications/PushMessageReceiver.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -53,7 +53,7 @@ class PushMessageReceiver : MessagingReceiver() {
         instance: String,
     ) {
         val messageStr = message.content.decodeToString()
-        Log.d(TAG, "New message $messageStr for Instance: $instance")
+        Log.d(TAG) { "New message $messageStr for Instance: $instance" }
         scope.launch {
             try {
                 parseMessage(messageStr)?.let {
@@ -61,7 +61,7 @@ class PushMessageReceiver : MessagingReceiver() {
                 }
             } catch (e: Exception) {
                 if (e is CancellationException) throw e
-                Log.d(TAG, "Message could not be parsed: ${e.message}")
+                Log.d(TAG) { "Message could not be parsed: ${e.message}" }
             }
         }
     }
@@ -87,7 +87,7 @@ class PushMessageReceiver : MessagingReceiver() {
     ) {
         val sanitizedEndpoint = if (endpoint.url.endsWith("?up=1")) endpoint.url.dropLast(5) else endpoint.url
         if (sanitizedEndpoint != pushHandler.getSavedEndpoint()) {
-            Log.d(TAG, "New endpoint provided:- $endpoint for Instance: $instance ${pushHandler.getSavedEndpoint()} $sanitizedEndpoint")
+            Log.d(TAG) { "New endpoint provided:- $endpoint for Instance: $instance ${pushHandler.getSavedEndpoint()} $sanitizedEndpoint" }
             pushHandler.setEndpoint(sanitizedEndpoint)
             scope.launch(Dispatchers.IO) {
                 PushNotificationUtils.checkAndInit(sanitizedEndpoint, LocalPreferences.allSavedAccounts()) {
@@ -97,7 +97,7 @@ class PushMessageReceiver : MessagingReceiver() {
                 NotificationUtils.getOrCreateDMChannel(appContext)
             }
         } else {
-            Log.d(TAG, "Same endpoint provided:- $endpoint for Instance: $instance $sanitizedEndpoint")
+            Log.d(TAG) { "Same endpoint provided:- $endpoint for Instance: $instance $sanitizedEndpoint" }
         }
     }
 
@@ -106,7 +106,7 @@ class PushMessageReceiver : MessagingReceiver() {
         reason: FailedReason,
         instance: String,
     ) {
-        Log.d(TAG, "Registration failed for Instance: $instance")
+        Log.d(TAG) { "Registration failed for Instance: $instance" }
         pushHandler.forceRemoveDistributor(context)
     }
 
@@ -115,7 +115,7 @@ class PushMessageReceiver : MessagingReceiver() {
         instance: String,
     ) {
         val removedEndpoint = pushHandler.getSavedEndpoint()
-        Log.d(TAG, "Endpoint: $removedEndpoint removed for Instance: $instance")
+        Log.d(TAG) { "Endpoint: $removedEndpoint removed for Instance: $instance" }
         Log.d(TAG, "App is unregistered. ")
         pushHandler.forceRemoveDistributor(context)
         pushHandler.removeEndpoint()

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

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -35,7 +35,7 @@ object PushNotificationUtils {
         accounts: List<AccountInfo>,
         okHttpClient: (String) -> OkHttpClient,
     ) = with(Dispatchers.IO) {
-        if (!pushHandler.savedDistributorExists()) return
+        if (!pushHandler.savedDistributorExists()) return@with
 
         val currentDistributor = PushDistributorHandler.getSavedDistributor()
         PushDistributorHandler.saveDistributor(currentDistributor)

amethyst/src/fdroid/java/com/vitorpamplona/amethyst/ui/components/SelectNotificationProvider.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

amethyst/src/fdroid/java/com/vitorpamplona/amethyst/ui/components/TranslatableRichTextViewer.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -26,10 +26,10 @@ import androidx.compose.runtime.getValue
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
+import com.vitorpamplona.amethyst.commons.model.ImmutableListOfLists
 import com.vitorpamplona.amethyst.ui.navigation.navs.INav
 import com.vitorpamplona.amethyst.ui.screen.loggedIn.AccountViewModel
 import com.vitorpamplona.amethyst.ui.theme.MaxWidthPaddingTop5dp
-import com.vitorpamplona.quartz.nip01Core.core.ImmutableListOfLists
 
 @Composable
 fun TranslatableRichTextViewer(

amethyst/src/main/AndroidManifest.xml

@@ -76,7 +76,6 @@
             android:launchMode="singleInstance"
             android:windowSoftInputMode="adjustResize"
             android:configChanges="orientation|screenSize|screenLayout"
-            android:taskAffinity=".service.playback.pip.PipVideoActivity"
             android:theme="@style/Theme.Amethyst">
 
             <intent-filter android:label="Amethyst">
@@ -241,6 +240,11 @@
                 <action android:name="com.shared.NOSTR" />
             </intent-filter>
         </receiver>
+
+        <receiver
+            android:name=".service.notifications.NotificationReplyReceiver"
+            android:exported="false" />
+
     </application>
 
 

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

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -23,10 +23,12 @@ package com.vitorpamplona.amethyst
 import android.app.Application
 import com.vitorpamplona.amethyst.service.logging.Logging
 import com.vitorpamplona.quartz.utils.Log
+import com.vitorpamplona.quartz.utils.LogLevel
 
 class Amethyst : Application() {
     init {
-        Log.d("AmethystApp", "Creating App $this")
+        Log.minLevel = if (BuildConfig.DEBUG) LogLevel.DEBUG else LogLevel.ERROR
+        Log.d("AmethystApp") { "Creating App $this" }
     }
 
     companion object {
@@ -36,7 +38,7 @@ class Amethyst : Application() {
 
     override fun onCreate() {
         super.onCreate()
-        Log.d("AmethystApp", "onCreate $this")
+        Log.d("AmethystApp") { "onCreate $this" }
         instance = AppModules(this)
 
         if (isDebug) {
@@ -48,7 +50,7 @@ class Amethyst : Application() {
 
     override fun onTerminate() {
         super.onTerminate()
-        Log.d("AmethystApp", "onTerminate $this")
+        Log.d("AmethystApp") { "onTerminate $this" }
         instance.terminate(this)
     }
 
@@ -59,7 +61,7 @@ class Amethyst : Application() {
      */
     override fun onTrimMemory(level: Int) {
         super.onTrimMemory(level)
-        Log.d("AmethystApp", "onTrimMemory $level")
+        Log.d("AmethystApp") { "onTrimMemory $level" }
         instance.trim()
     }
 }

amethyst/src/main/java/com/vitorpamplona/amethyst/AppModules.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -20,16 +20,21 @@
  */
 package com.vitorpamplona.amethyst
 
-import android.content.ContentResolver
 import android.content.Context
 import androidx.security.crypto.EncryptedSharedPreferences
 import coil3.disk.DiskCache
 import coil3.memory.MemoryCache
+import com.vitorpamplona.amethyst.commons.model.NoteState
+import com.vitorpamplona.amethyst.commons.robohash.CachedRobohash
+import com.vitorpamplona.amethyst.model.Account
 import com.vitorpamplona.amethyst.model.LocalCache
+import com.vitorpamplona.amethyst.model.UiSettings
 import com.vitorpamplona.amethyst.model.accountsCache.AccountCacheState
 import com.vitorpamplona.amethyst.model.nip03Timestamp.IncomingOtsEventVerifier
 import com.vitorpamplona.amethyst.model.nip03Timestamp.TorAwareOkHttpOtsResolverBuilder
 import com.vitorpamplona.amethyst.model.nip11RelayInfo.Nip11CachedRetriever
+import com.vitorpamplona.amethyst.model.preferences.NamecoinSharedPreferences
+import com.vitorpamplona.amethyst.model.preferences.OtsSharedPreferences
 import com.vitorpamplona.amethyst.model.preferences.TorSharedPreferences
 import com.vitorpamplona.amethyst.model.preferences.UiSharedPreferences
 import com.vitorpamplona.amethyst.model.privacyOptions.RoleBasedHttpClientBuilder
@@ -44,6 +49,7 @@ import com.vitorpamplona.amethyst.service.images.ImageLoaderSetup
 import com.vitorpamplona.amethyst.service.location.LocationState
 import com.vitorpamplona.amethyst.service.notifications.PokeyReceiver
 import com.vitorpamplona.amethyst.service.okhttp.DualHttpClientManager
+import com.vitorpamplona.amethyst.service.okhttp.DualHttpClientManagerForRelays
 import com.vitorpamplona.amethyst.service.okhttp.EncryptionKeyCache
 import com.vitorpamplona.amethyst.service.okhttp.OkHttpWebSocket
 import com.vitorpamplona.amethyst.service.playback.diskCache.VideoCache
@@ -53,10 +59,17 @@ import com.vitorpamplona.amethyst.service.relayClient.RelayProxyClientConnector
 import com.vitorpamplona.amethyst.service.relayClient.authCommand.model.AuthCoordinator
 import com.vitorpamplona.amethyst.service.relayClient.notifyCommand.model.NotifyCoordinator
 import com.vitorpamplona.amethyst.service.relayClient.reqCommand.RelaySubscriptionsCoordinator
+import com.vitorpamplona.amethyst.service.relayClient.reqCommand.event.EventFinderQueryState
+import com.vitorpamplona.amethyst.service.relayClient.reqCommand.user.UserFinderQueryState
 import com.vitorpamplona.amethyst.service.relayClient.speedLogger.RelaySpeedLogger
+import com.vitorpamplona.amethyst.service.uploads.blossom.bud10.BlossomServerResolver
 import com.vitorpamplona.amethyst.service.uploads.nip95.Nip95CacheFactory
+import com.vitorpamplona.amethyst.ui.resourceCacheInit
+import com.vitorpamplona.amethyst.ui.screen.AccountSessionManager
 import com.vitorpamplona.amethyst.ui.screen.UiSettingsState
 import com.vitorpamplona.amethyst.ui.tor.TorManager
+import com.vitorpamplona.amethyst.ui.tor.TorSettings
+import com.vitorpamplona.quartz.nip01Core.core.Address
 import com.vitorpamplona.quartz.nip01Core.relay.client.INostrClient
 import com.vitorpamplona.quartz.nip01Core.relay.client.NostrClient
 import com.vitorpamplona.quartz.nip01Core.relay.client.accessories.RelayLogger
@@ -65,13 +78,27 @@ import com.vitorpamplona.quartz.nip01Core.relay.client.reqs.stats.RelayReqStats
 import com.vitorpamplona.quartz.nip01Core.relay.client.stats.RelayStats
 import com.vitorpamplona.quartz.nip03Timestamp.VerificationStateCache
 import com.vitorpamplona.quartz.nip03Timestamp.ots.OtsBlockHeightCache
+import com.vitorpamplona.quartz.nip05DnsIdentifiers.Nip05Client
+import com.vitorpamplona.quartz.nip05DnsIdentifiers.OkHttpNip05Fetcher
+import com.vitorpamplona.quartz.nip05DnsIdentifiers.namecoin.DEFAULT_ELECTRUMX_SERVERS
+import com.vitorpamplona.quartz.nip05DnsIdentifiers.namecoin.ElectrumXClient
+import com.vitorpamplona.quartz.nip05DnsIdentifiers.namecoin.NamecoinNameResolver
+import com.vitorpamplona.quartz.nip05DnsIdentifiers.namecoin.TOR_ELECTRUMX_SERVERS
+import com.vitorpamplona.quartz.nipB7Blossom.BlossomServersEvent
 import com.vitorpamplona.quartz.utils.Log
 import kotlinx.coroutines.CoroutineExceptionHandler
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.async
 import kotlinx.coroutines.cancel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.onCompletion
+import kotlinx.coroutines.flow.onStart
+import kotlinx.coroutines.flow.transform
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
 import java.io.File
 
 class AppModules(
@@ -86,23 +113,55 @@ class AppModules(
         }
 
     val applicationIOScope = CoroutineScope(Dispatchers.IO + SupervisorJob() + exceptionHandler)
-    val applicationDefaultScope = CoroutineScope(Dispatchers.IO + SupervisorJob() + exceptionHandler)
+
+    // Pre-load both preference DataStores in parallel on IO threads.
+    // Both constructors use runBlocking internally, so starting them concurrently
+    // reduces total blocking time from (torPrefs + uiPrefs) to ~max(torPrefs, uiPrefs).
+    private val uiPrefsDeferred =
+        applicationIOScope.async {
+            val prefs = UiSharedPreferences.uiPreferences(appContext) ?: UiSettings()
+            UiSharedPreferences(prefs, appContext, applicationIOScope)
+        }
+
+    private val torPrefsDeferred =
+        applicationIOScope.async {
+            val prefs = TorSharedPreferences.torPreferences(appContext) ?: TorSettings()
+            TorSharedPreferences(prefs, appContext, applicationIOScope)
+        }
 
     // Blocking load of UI Preferences to avoid theme/language blinking
     val uiPrefs by lazy {
-        UiSharedPreferences(appContext, applicationIOScope)
+        Log.d("AppModules", "UiSharedPreferences Init")
+        runBlocking { uiPrefsDeferred.await() }
     }
 
     // Blocking load of Tor Settings to avoid connection leaks
     val torPrefs by lazy {
-        TorSharedPreferences(appContext, applicationIOScope)
+        Log.d("AppModules", "TorSharedPreferences Init")
+        runBlocking { torPrefsDeferred.await() }
+    }
+
+    // Namecoin ElectrumX server preferences (global, like Tor settings)
+    val namecoinPrefs by lazy {
+        Log.d("AppModules", "NamecoinSharedPreferences Init")
+        NamecoinSharedPreferences(appContext, applicationIOScope)
+    }
+
+    // OTS blockchain explorer preferences (global, like Tor settings)
+    val otsPrefs by lazy {
+        Log.d("AppModules", "OtsSharedPreferences Init")
+        OtsSharedPreferences(appContext, applicationIOScope)
     }
 
     // App services that should be run as soon as there are subscribers to their flows
-    val locationManager = LocationState(appContext, applicationIOScope)
+    val locationManager by lazy {
+        Log.d("AppModules", "LocationManager Init")
+        LocationState(appContext, applicationIOScope)
+    }
     val connManager = ConnectivityManager(appContext, applicationIOScope)
 
     val uiState by lazy {
+        Log.d("AppModules", "UiSettingsState Init")
         UiSettingsState(uiPrefs.value, connManager.isMobileOrFalse, applicationIOScope)
     }
 
@@ -124,40 +183,88 @@ class AppModules(
             scope = applicationIOScope,
         )
 
-    // manages all relay connections
-    val okHttpClientForRelays =
-        DualHttpClientManager(
-            userAgent = appAgent,
-            proxyPortProvider = torManager.activePortOrNull,
-            isMobileDataProvider = connManager.isMobileOrNull,
-            keyCache = keyCache,
-            scope = applicationIOScope,
-        )
-
     // Offers easy methods to know when connections are happening through Tor or not
     val roleBasedHttpClientBuilder = RoleBasedHttpClientBuilder(okHttpClients, torPrefs.value)
 
-    // Application-wide block height request cache
-    val otsBlockHeightCache by lazy { OtsBlockHeightCache() }
+    val electrumXClient by lazy {
+        Log.d("AppModules", "ElectrumXClient Init")
+        val client =
+            ElectrumXClient(
+                socketFactory = { roleBasedHttpClientBuilder.socketFactoryForNip05() },
+            )
+        applicationIOScope.launch {
+            try {
+                val pinnedCerts = namecoinPrefs.loadPinnedCerts()
+                if (pinnedCerts.isNotEmpty()) {
+                    client.setDynamicCerts(pinnedCerts)
+                }
+            } catch (_: Exception) {
+                // Non-fatal — defaults will still work
+            }
+        }
+        client
+    }
 
-    val otsResolverBuilder: TorAwareOkHttpOtsResolverBuilder =
-        TorAwareOkHttpOtsResolverBuilder(
-            roleBasedHttpClientBuilder::okHttpClientForMoney,
-            roleBasedHttpClientBuilder::shouldUseTorForMoneyOperations,
-            otsBlockHeightCache,
-        )
+    val namecoinResolver by
+        lazy {
+            Log.d("AppModules", "Namecoin Resolver Init")
+            NamecoinNameResolver(
+                electrumxClient = electrumXClient,
+                serverListProvider = {
+                    // User-configured custom servers take priority
+                    namecoinPrefs.customServersOrNull
+                        ?: if (roleBasedHttpClientBuilder.shouldUseTorForNIP05("https://electrumx.example.com")) {
+                            TOR_ELECTRUMX_SERVERS
+                        } else {
+                            DEFAULT_ELECTRUMX_SERVERS
+                        }
+                },
+            )
+        }
+
+    val nip05Client by
+        lazy {
+            Log.d("AppModules", "NIP05Client Init")
+            Nip05Client(
+                fetcher = OkHttpNip05Fetcher(roleBasedHttpClientBuilder::okHttpClientForNip05),
+                namecoinResolverBuilder = { namecoinResolver },
+            )
+        }
+
+    val otsResolverBuilder by
+        lazy {
+            Log.d("AppModules", "OtsResolverBuilder Init")
+            TorAwareOkHttpOtsResolverBuilder(
+                roleBasedHttpClientBuilder::okHttpClientForMoney,
+                roleBasedHttpClientBuilder::shouldUseTorForMoneyOperations,
+                OtsBlockHeightCache(),
+                customExplorerUrl = { otsPrefs.current.normalizedUrl() },
+            )
+        }
 
     // Application-wide ots verification cache
-    val otsVerifCache by lazy { VerificationStateCache(otsResolverBuilder) }
+    val otsVerifCache by lazy {
+        Log.d("AppModules", "OtsCache Init")
+        VerificationStateCache(otsResolverBuilder)
+    }
 
     val torEvaluatorFlow =
         TorRelayState(
             okHttpClients,
             torPrefs.value,
-            applicationDefaultScope,
+            applicationIOScope,
         )
 
-    // Connects the NostrClient class with okHttp
+    // manages all relay connections
+    val okHttpClientForRelays =
+        DualHttpClientManagerForRelays(
+            userAgent = appAgent,
+            proxyPortProvider = torManager.activePortOrNull,
+            isMobileDataProvider = connManager.isMobileOrNull,
+            scope = applicationIOScope,
+        )
+
+    // Connects the INostrClient class with okHttp
     val websocketBuilder =
         OkHttpWebSocket.Builder { url ->
             val useTor = torEvaluatorFlow.flow.value.useTor(url)
@@ -168,7 +275,7 @@ class AppModules(
     val cache: LocalCache = LocalCache
 
     // Provides a relay pool
-    val client: INostrClient = NostrClient(websocketBuilder, applicationDefaultScope)
+    val client: INostrClient = NostrClient(websocketBuilder, applicationIOScope)
 
     // Watches for changes on Tor and Relay List Settings
     val relayProxyClientConnector =
@@ -178,7 +285,7 @@ class AppModules(
             connManager,
             torManager,
             client,
-            applicationDefaultScope,
+            applicationIOScope,
         )
 
     // Verifies and inserts in the cache from all relays, all subscriptions
@@ -188,10 +295,15 @@ class AppModules(
     val notifyCoordinator = NotifyCoordinator(client)
 
     // Authenticates with relays.
-    val authCoordinator = AuthCoordinator(client, applicationDefaultScope)
+    val authCoordinator = AuthCoordinator(client, applicationIOScope)
 
     // Tries to verify new OTS events when they arrive.
-    val otsEventVerifier = IncomingOtsEventVerifier(otsVerifCache, cache, applicationDefaultScope)
+    val otsEventVerifier =
+        IncomingOtsEventVerifier(
+            otsVerifCache = { otsVerifCache },
+            cache = cache,
+            scope = applicationIOScope,
+        )
 
     // Tracks if it is possible to connect to relays.
     val failureTracker = RelayOfflineTracker(client)
@@ -200,7 +312,7 @@ class AppModules(
     val relayStats = RelayStats(client)
 
     // Logs debug messages when needed
-    val detailedLogger = if (isDebug) RelayLogger(client, false, false) else null
+    val detailedLogger = if (isDebug) RelayLogger(client, debugSending = false, debugReceiving = false) else null
     val relayReqStats = if (isDebug) RelayReqStats(client) else null
     val logger = if (isDebug) RelaySpeedLogger(client) else null
 
@@ -211,53 +323,121 @@ class AppModules(
             client,
             authCoordinator.receiver,
             failureTracker,
-            applicationDefaultScope,
+            applicationIOScope,
         )
 
     // keeps all accounts live
     val accountsCache =
         AccountCacheState(
-            geolocationFlow = locationManager.geohashStateFlow,
-            nwcFilterAssembler = sources.nwc,
-            contentResolverFn = ::contentResolverFn,
-            otsResolverBuilder = otsResolverBuilder,
+            geolocationFlow = { locationManager.geohashStateFlow },
+            nwcFilterAssembler = { sources.nwc },
+            contentResolverFn = { appContext.contentResolver },
+            otsResolverBuilder = { otsResolverBuilder.build() },
             cache = cache,
             client = client,
         )
 
+    val sessionManager =
+        AccountSessionManager(
+            accountsCache = accountsCache,
+            nip05ClientBuilder = { nip05Client },
+            clientBuilder = { client },
+            localPreferences = LocalPreferences,
+            scope = applicationIOScope,
+        )
+
+    fun subscribedFlow(
+        address: Address,
+        account: Account,
+    ): Flow<NoteState> {
+        val note = cache.getOrCreateAddressableNote(address)
+
+        val userSub = UserFinderQueryState(note.author ?: cache.getOrCreateUser(address.pubKeyHex), account)
+        val noteSub = EventFinderQueryState(note, account)
+
+        return note
+            .flow()
+            .metadata.stateFlow
+            .onStart {
+                sources.userFinder.subscribe(userSub)
+                sources.eventFinder.subscribe(noteSub)
+            }.onCompletion {
+                sources.eventFinder.unsubscribe(noteSub)
+                sources.userFinder.unsubscribe(userSub)
+            }
+    }
+
+    val blossomResolver by lazy {
+        Log.d("AppModules", "BlossomServerResolver Init")
+        BlossomServerResolver(
+            loggedInUsers = { listOfNotNull(sessionManager.loggedInAccount()?.pubKey) },
+            blossomServers = { addressesToSubscribe ->
+                val account = sessionManager.loggedInAccount() ?: return@BlossomServerResolver listOf()
+                addressesToSubscribe.map { address ->
+                    subscribedFlow(address, account).transform {
+                        val event = it.note.event as? BlossomServersEvent
+                        if (event != null) {
+                            emit(event)
+                        }
+                    }
+                }
+            },
+            httpClientBuilder = roleBasedHttpClientBuilder,
+        )
+    }
+
     // Organizes cache clearing
-    val trimmingService = MemoryTrimmingService(cache)
+    val trimmingService by
+        lazy {
+            MemoryTrimmingService(cache)
+        }
 
     // as new accounts are loaded, updates the state of the TorRelaySettings, which produces new TorRelayEvaluator
     // and reconnects relays if the configuration has been changed.
-    val accountsTorStateConnector = AccountsTorStateConnector(accountsCache, torEvaluatorFlow, applicationDefaultScope)
+    val accountsTorStateConnector = AccountsTorStateConnector(accountsCache, torEvaluatorFlow, applicationIOScope)
 
     // saves the .content of NIP-95 blobs in disk to save memory
-    val nip95cache: File by lazy { Nip95CacheFactory.new(appContext) }
+    val nip95cache: File by lazy {
+        Log.d("AppModules", "NIP95 Cache Init")
+        Nip95CacheFactory.new(appContext)
+    }
 
     // local video cache with disk + memory
-    val videoCache: VideoCache by lazy { VideoCacheFactory.new(appContext) }
+    val videoCache: VideoCache by lazy {
+        Log.d("AppModules", "VideoCache Init")
+        VideoCacheFactory.new(appContext)
+    }
 
     // image cache in disk for coil
-    val diskCache: DiskCache by lazy { ImageCacheFactory.newDisk(appContext) }
+    val diskCache: DiskCache by lazy {
+        Log.d("AppModules", "ImageCacheFactory Init")
+        ImageCacheFactory.newDisk(appContext)
+    }
 
     // image cache in memory for coil
-    val memoryCache: MemoryCache by lazy { ImageCacheFactory.newMemory(appContext) }
+    val memoryCache: MemoryCache by lazy {
+        Log.d("AppModules", "MemoryCache Init")
+        ImageCacheFactory.newMemory(appContext)
+    }
 
     // crash report storage
-    val crashReportCache: CrashReportCache by lazy { CrashReportCache(appContext) }
+    val crashReportCache = CrashReportCache(appContext)
 
     // cache for NIP-11 documents
     val nip11Cache: Nip11CachedRetriever by lazy {
+        Log.d("AppModules", "Nip11CachedRetriever Init")
         Nip11CachedRetriever(torEvaluatorFlow::okHttpClientForRelay)
     }
 
-    fun contentResolverFn(): ContentResolver = appContext.contentResolver
-
     fun setImageLoader() {
-        ImageLoaderSetup.setup(appContext, { diskCache }, { memoryCache }) { url ->
-            okHttpClients.getHttpClient(roleBasedHttpClientBuilder.shouldUseTorForImageDownload(url))
-        }
+        Log.d("AppModules", "ImageLoaderSetup Init")
+        ImageLoaderSetup.setup(
+            app = appContext,
+            diskCache = { diskCache },
+            memoryCache = { memoryCache },
+            blossomServerResolver = { blossomResolver },
+            callFactory = { okHttpClients.getHttpClient(roleBasedHttpClientBuilder.shouldUseTorForImageDownload(it)) },
+        )
     }
 
     fun encryptedStorage(npub: String? = null): EncryptedSharedPreferences = EncryptedStorage.preferences(appContext, npub)
@@ -268,6 +448,7 @@ class AppModules(
         applicationIOScope.launch {
             // loads main account quickly.
             LocalPreferences.loadAccountConfigFromEncryptedStorage()
+            sessionManager.loginWithDefaultAccountIfLoggedOff()
         }
 
         // forces initialization of uiPrefs in the main thread to avoid blinking themes
@@ -275,29 +456,41 @@ class AppModules(
 
         // initializes diskcache on an IO thread.
         applicationIOScope.launch {
-            // preloads tor preferences
-            torPrefs
+            // Sets Coil - Tor - OkHttp link
+            setImageLoader()
         }
 
         // initializes diskcache on an IO thread.
         applicationIOScope.launch {
             // Sets Coil - Tor - OkHttp link
-            setImageLoader()
+            uiState
+        }
+
+        // LRUCache should not be instanciated in the Main thread due to blocking
+        applicationIOScope.launch {
+            CachedRobohash
+            resourceCacheInit()
         }
 
         // registers to receive events
         pokeyReceiver.register(appContext)
+
+        // initializes diskcache on an IO thread.
+        applicationIOScope.launch {
+            // Prepares video cache later
+            delay(10_000)
+            videoCache
+        }
     }
 
     fun terminate(appContext: Context) {
         pokeyReceiver.unregister(appContext)
         applicationIOScope.cancel("Application onTerminate $appContext")
-        applicationDefaultScope.cancel("Application onTerminate $appContext")
         accountsCache.clear()
     }
 
     fun trim() {
-        applicationDefaultScope.launch {
+        applicationIOScope.launch {
             val loggedIn = accountsCache.accounts.value.values
             trimmingService.run(loggedIn, LocalPreferences.allSavedAccounts())
         }

amethyst/src/main/java/com/vitorpamplona/amethyst/DebugUtils.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -26,8 +26,11 @@ import android.content.pm.ApplicationInfo
 import android.os.Debug
 import androidx.core.content.getSystemService
 import com.vitorpamplona.amethyst.model.LocalCache
+import com.vitorpamplona.quartz.nip01Core.core.Event
 import com.vitorpamplona.quartz.nip01Core.relay.normalizer.normalizedUrls
 import com.vitorpamplona.quartz.utils.Log
+import com.vitorpamplona.quartz.utils.bytesUsedInMemory
+import com.vitorpamplona.quartz.utils.pointerSizeInBytes
 import kotlin.time.DurationUnit
 import kotlin.time.measureTimedValue
 
@@ -43,19 +46,19 @@ fun debugState(context: Context) {
 
     val jvmHeapAllocatedMb = totalMemoryMb - freeMemoryMb
 
-    Log.d(STATE_DUMP_TAG, "Total Heap Allocated: $jvmHeapAllocatedMb/$maxMemoryMb MB")
+    Log.d(STATE_DUMP_TAG) { "Total Heap Allocated: $jvmHeapAllocatedMb/$maxMemoryMb MB" }
 
     val nativeHeap = Debug.getNativeHeapAllocatedSize() / (1024 * 1024)
     val maxNative = Debug.getNativeHeapSize() / (1024 * 1024)
 
-    Log.d(STATE_DUMP_TAG, "Total Native Heap Allocated: $nativeHeap/$maxNative MB")
+    Log.d(STATE_DUMP_TAG) { "Total Native Heap Allocated: $nativeHeap/$maxNative MB" }
 
     val activityManager: ActivityManager? = context.getSystemService()
     if (activityManager != null) {
         val isLargeHeap = (context.applicationInfo.flags and ApplicationInfo.FLAG_LARGE_HEAP) != 0
         val memClass = if (isLargeHeap) activityManager.largeMemoryClass else activityManager.memoryClass
 
-        Log.d(STATE_DUMP_TAG, "Memory Class $memClass MB (largeHeap $isLargeHeap)")
+        Log.d(STATE_DUMP_TAG) { "Memory Class $memClass MB (largeHeap $isLargeHeap)" }
     }
 
     Log.d(
@@ -65,14 +68,8 @@ fun debugState(context: Context) {
                 .size() + "/" + normalizedUrls.size(),
     )
 
-    Log.d(
-        STATE_DUMP_TAG,
-        "Image Disk Cache ${(Amethyst.instance.diskCache.size) / (1024 * 1024)}/${(Amethyst.instance.diskCache.maxSize) / (1024 * 1024)} MB",
-    )
-    Log.d(
-        STATE_DUMP_TAG,
-        "Image Memory Cache ${(Amethyst.instance.memoryCache.size) / (1024 * 1024)}/${(Amethyst.instance.memoryCache.maxSize) / (1024 * 1024)} MB",
-    )
+    Log.d(STATE_DUMP_TAG) { "Image Disk Cache ${(Amethyst.instance.diskCache.size) / (1024 * 1024)}/${(Amethyst.instance.diskCache.maxSize) / (1024 * 1024)} MB" }
+    Log.d(STATE_DUMP_TAG) { "Image Memory Cache ${(Amethyst.instance.memoryCache.size) / (1024 * 1024)}/${(Amethyst.instance.memoryCache.maxSize) / (1024 * 1024)} MB" }
 
     Log.d(
         STATE_DUMP_TAG,
@@ -95,9 +92,7 @@ fun debugState(context: Context) {
     Log.d(
         STATE_DUMP_TAG,
         "Users: " +
-            LocalCache.users.filter { _, it -> it.flowSet != null }.size +
-            " / " +
-            LocalCache.users.filter { _, it -> it.latestMetadata != null }.size +
+            LocalCache.users.filter { _, it -> it.metadataOrNull() != null }.size +
             " / " +
             LocalCache.users.size(),
     )
@@ -129,13 +124,12 @@ fun debugState(context: Context) {
             LocalCache.ephemeralChannels.values().sumOf { it.notes.size() },
     )
     LocalCache.chatroomList.forEach { key, room ->
-        Log.d(
-            STATE_DUMP_TAG,
+        Log.d(STATE_DUMP_TAG) {
             "Private Chats $key: " +
                 room.rooms.size() +
                 " / " +
-                room.rooms.sumOf { key, value -> value.messages.size },
-        )
+                room.rooms.sumOf { key, value -> value.messages.size }
+        }
     }
     Log.d(
         STATE_DUMP_TAG,
@@ -144,10 +138,8 @@ fun debugState(context: Context) {
     )
     Log.d(
         STATE_DUMP_TAG,
-        "Observable Events: " +
-            LocalCache.observablesByKindAndETag.size +
-            " / " +
-            LocalCache.observablesByKindAndAuthor.size,
+        "Observables: " +
+            LocalCache.observables.size,
     )
 
     Log.d(
@@ -174,10 +166,10 @@ fun debugState(context: Context) {
             .sumByGroup(groupMap = { _, it -> it.event?.kind }, sumOf = { _, it -> it.event?.countMemory()?.toLong() ?: 0L })
 
     qttNotes.toList().sortedByDescending { bytesNotes[it.first] }.forEach { (kind, qtt) ->
-        Log.d(STATE_DUMP_TAG, "Kind ${kind.toString().padStart(5,' ')}:\t${qtt.toString().padStart(6,' ')} elements\t${bytesNotes[kind]?.div((1024 * 1024))}MB ")
+        Log.d(STATE_DUMP_TAG) { "Kind ${kind.toString().padStart(5,' ')}:\t${qtt.toString().padStart(6,' ')} elements\t${bytesNotes[kind]?.div((1024 * 1024))}MB " }
     }
     qttAddressables.toList().sortedByDescending { bytesNotes[it.first] }.forEach { (kind, qtt) ->
-        Log.d(STATE_DUMP_TAG, "Kind ${kind.toString().padStart(5,' ')}:\t${qtt.toString().padStart(6,' ')} elements\t${bytesAddressables[kind]?.div((1024 * 1024))}MB ")
+        Log.d(STATE_DUMP_TAG) { "Kind ${kind.toString().padStart(5,' ')}:\t${qtt.toString().padStart(6,' ')} elements\t${bytesAddressables[kind]?.div((1024 * 1024))}MB " }
     }
 }
 
@@ -189,7 +181,7 @@ inline fun <T> logTime(
     if (isDebug) {
         val (result, elapsed) = measureTimedValue(block)
         if (elapsed.inWholeMilliseconds > minToReportMs) {
-            Log.d("DEBUG-TIME", "${elapsed.toString(DurationUnit.MILLISECONDS, 3).padStart(12)}: $debugMessage")
+            Log.d("DEBUG-TIME") { "${elapsed.toString(DurationUnit.MILLISECONDS, 3).padStart(12)}: $debugMessage" }
         }
         result
     } else {
@@ -204,7 +196,7 @@ inline fun <T> logTime(
     if (isDebug) {
         val (result, elapsed) = measureTimedValue(block)
         if (elapsed.inWholeMilliseconds > minToReportMs) {
-            Log.d("DEBUG-TIME", "${elapsed.toString(DurationUnit.MILLISECONDS, 3).padStart(12)}: ${debugMessage(result)}")
+            Log.d("DEBUG-TIME") { "${elapsed.toString(DurationUnit.MILLISECONDS, 3).padStart(12)}: ${debugMessage(result)}" }
         }
         result
     } else {
@@ -228,3 +220,12 @@ inline fun debug(
         Log.d(tag, debugMessage())
     }
 }
+
+fun Event.countMemory(): Int =
+    7 * pointerSizeInBytes + // 7 fields, 4 bytes each reference (32bit)
+        12 + // createdAt + kind
+        id.bytesUsedInMemory() +
+        pubKey.bytesUsedInMemory() +
+        tags.sumOf { pointerSizeInBytes + it.sumOf { pointerSizeInBytes + it.bytesUsedInMemory() } } +
+        content.bytesUsedInMemory() +
+        sig.bytesUsedInMemory()

amethyst/src/main/java/com/vitorpamplona/amethyst/EncryptedStorage.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

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

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -25,15 +25,14 @@ import android.content.Context
 import android.content.SharedPreferences
 import androidx.compose.runtime.Immutable
 import androidx.core.content.edit
-import com.vitorpamplona.amethyst.model.ALL_FOLLOWS
 import com.vitorpamplona.amethyst.model.AccountSettings
-import com.vitorpamplona.amethyst.model.GLOBAL_FOLLOWS
+import com.vitorpamplona.amethyst.model.TopFilter
 import com.vitorpamplona.amethyst.model.UiSettings
 import com.vitorpamplona.amethyst.service.checkNotInMainThread
 import com.vitorpamplona.amethyst.ui.actions.mediaServers.DEFAULT_MEDIA_SERVERS
 import com.vitorpamplona.amethyst.ui.actions.mediaServers.ServerName
 import com.vitorpamplona.quartz.experimental.ephemChat.list.EphemeralChatListEvent
-import com.vitorpamplona.quartz.experimental.trustedAssertions.list.TrustProviderListEvent
+import com.vitorpamplona.quartz.experimental.nipA3.PaymentTargetsEvent
 import com.vitorpamplona.quartz.nip01Core.core.Event
 import com.vitorpamplona.quartz.nip01Core.core.HexKey
 import com.vitorpamplona.quartz.nip01Core.core.JsonMapper
@@ -54,13 +53,16 @@ import com.vitorpamplona.quartz.nip51Lists.hashtagList.HashtagListEvent
 import com.vitorpamplona.quartz.nip51Lists.muteList.MuteListEvent
 import com.vitorpamplona.quartz.nip51Lists.relayLists.BlockedRelayListEvent
 import com.vitorpamplona.quartz.nip51Lists.relayLists.IndexerRelayListEvent
+import com.vitorpamplona.quartz.nip51Lists.relayLists.RelayFeedsListEvent
 import com.vitorpamplona.quartz.nip51Lists.relayLists.TrustedRelayListEvent
 import com.vitorpamplona.quartz.nip65RelayList.AdvertisedRelayListEvent
 import com.vitorpamplona.quartz.nip72ModCommunities.follow.CommunityListEvent
 import com.vitorpamplona.quartz.nip78AppData.AppSpecificDataEvent
+import com.vitorpamplona.quartz.nip85TrustedAssertions.list.TrustProviderListEvent
 import com.vitorpamplona.quartz.utils.Log
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
@@ -90,10 +92,15 @@ private object PrefKeys {
     const val NOSTR_PUBKEY = "nostr_pubkey"
     const val LOCAL_RELAY_SERVERS = "localRelayServers"
     const val DEFAULT_FILE_SERVER = "defaultFileServer"
+    const val STRIP_LOCATION_ON_UPLOAD = "stripLocationOnUpload"
     const val DEFAULT_HOME_FOLLOW_LIST = "defaultHomeFollowList"
     const val DEFAULT_STORIES_FOLLOW_LIST = "defaultStoriesFollowList"
     const val DEFAULT_NOTIFICATION_FOLLOW_LIST = "defaultNotificationFollowList"
     const val DEFAULT_DISCOVERY_FOLLOW_LIST = "defaultDiscoveryFollowList"
+    const val DEFAULT_POLLS_FOLLOW_LIST = "defaultPollsFollowList"
+    const val DEFAULT_PICTURES_FOLLOW_LIST = "defaultPicturesFollowList"
+    const val DEFAULT_SHORTS_FOLLOW_LIST = "defaultShortsFollowList"
+    const val DEFAULT_LONGS_FOLLOW_LIST = "defaultLongsFollowList"
     const val ZAP_PAYMENT_REQUEST_SERVER = "zapPaymentServer"
     const val LATEST_USER_METADATA = "latestUserMetadata"
     const val LATEST_CONTACT_LIST = "latestContactList"
@@ -101,6 +108,7 @@ private object PrefKeys {
     const val LATEST_NIP65_RELAY_LIST = "latestNIP65RelayList"
     const val LATEST_SEARCH_RELAY_LIST = "latestSearchRelayList"
     const val LATEST_INDEX_RELAY_LIST = "latestIndexRelayList"
+    const val LATEST_RELAY_FEEDS_LIST = "latestRelayFeedsList"
     const val LATEST_BLOCKED_RELAY_LIST = "latestBlockedRelayList"
     const val LATEST_TRUSTED_RELAY_LIST = "latestTrustedRelayList"
     const val LATEST_MUTE_LIST = "latestMuteList"
@@ -126,6 +134,7 @@ private object PrefKeys {
 
     const val ALL_ACCOUNT_INFO = "all_saved_accounts_info"
     const val SHARED_SETTINGS = "shared_settings"
+    const val LATEST_PAYMENT_TARGETS = "latestPaymentTargets"
 }
 
 object LocalPreferences {
@@ -249,7 +258,7 @@ object LocalPreferences {
             val prefsDir = File(prefsDirPath)
             prefsDir.list()?.forEach {
                 if (it.contains(npub) && !File(prefsDir, it).delete()) {
-                    Log.w("LocalPreferences", "Failed to delete preference file: $it")
+                    Log.w("LocalPreferences") { "Failed to delete preference file: $it" }
                 }
             }
         }
@@ -277,7 +286,7 @@ object LocalPreferences {
      */
     @SuppressLint("ApplySharedPref")
     suspend fun deleteAccount(accountInfo: AccountInfo) {
-        Log.d("LocalPreferences", "Saving to encrypted storage updatePrefsForLogout ${accountInfo.npub}")
+        Log.d("LocalPreferences") { "Saving to encrypted storage updatePrefsForLogout ${accountInfo.npub}" }
         withContext(Dispatchers.IO) {
             encryptedPreferences(accountInfo.npub).edit(commit = true) { clear() }
             removeAccount(accountInfo)
@@ -318,16 +327,18 @@ object LocalPreferences {
                         PrefKeys.DEFAULT_FILE_SERVER,
                         JsonMapper.toJson(settings.defaultFileServer),
                     )
-                    putString(PrefKeys.DEFAULT_HOME_FOLLOW_LIST, settings.defaultHomeFollowList.value)
-                    putString(PrefKeys.DEFAULT_STORIES_FOLLOW_LIST, settings.defaultStoriesFollowList.value)
-                    putString(
-                        PrefKeys.DEFAULT_NOTIFICATION_FOLLOW_LIST,
-                        settings.defaultNotificationFollowList.value,
-                    )
-                    putString(
-                        PrefKeys.DEFAULT_DISCOVERY_FOLLOW_LIST,
-                        settings.defaultDiscoveryFollowList.value,
-                    )
+
+                    putBoolean(PrefKeys.STRIP_LOCATION_ON_UPLOAD, settings.stripLocationOnUpload)
+
+                    putString(PrefKeys.DEFAULT_HOME_FOLLOW_LIST, JsonMapper.toJson(settings.defaultHomeFollowList.value))
+                    putString(PrefKeys.DEFAULT_STORIES_FOLLOW_LIST, JsonMapper.toJson(settings.defaultStoriesFollowList.value))
+                    putString(PrefKeys.DEFAULT_NOTIFICATION_FOLLOW_LIST, JsonMapper.toJson(settings.defaultNotificationFollowList.value))
+                    putString(PrefKeys.DEFAULT_DISCOVERY_FOLLOW_LIST, JsonMapper.toJson(settings.defaultDiscoveryFollowList.value))
+
+                    putString(PrefKeys.DEFAULT_POLLS_FOLLOW_LIST, JsonMapper.toJson(settings.defaultPollsFollowList.value))
+                    putString(PrefKeys.DEFAULT_PICTURES_FOLLOW_LIST, JsonMapper.toJson(settings.defaultPicturesFollowList.value))
+                    putString(PrefKeys.DEFAULT_SHORTS_FOLLOW_LIST, JsonMapper.toJson(settings.defaultShortsFollowList.value))
+                    putString(PrefKeys.DEFAULT_LONGS_FOLLOW_LIST, JsonMapper.toJson(settings.defaultLongsFollowList.value))
 
                     putOrRemove(PrefKeys.ZAP_PAYMENT_REQUEST_SERVER, settings.zapPaymentRequest.value?.denormalize())
 
@@ -338,6 +349,7 @@ object LocalPreferences {
                     putOrRemove(PrefKeys.LATEST_NIP65_RELAY_LIST, settings.backupNIP65RelayList)
                     putOrRemove(PrefKeys.LATEST_SEARCH_RELAY_LIST, settings.backupSearchRelayList)
                     putOrRemove(PrefKeys.LATEST_INDEX_RELAY_LIST, settings.backupIndexRelayList)
+                    putOrRemove(PrefKeys.LATEST_RELAY_FEEDS_LIST, settings.backupRelayFeedsList)
                     putOrRemove(PrefKeys.LATEST_BLOCKED_RELAY_LIST, settings.backupBlockedRelayList)
                     putOrRemove(PrefKeys.LATEST_TRUSTED_RELAY_LIST, settings.backupTrustedRelayList)
 
@@ -357,6 +369,7 @@ object LocalPreferences {
                     putOrRemove(PrefKeys.LATEST_GEOHASH_LIST, settings.backupGeohashList)
                     putOrRemove(PrefKeys.LATEST_EPHEMERAL_LIST, settings.backupEphemeralChatList)
                     putOrRemove(PrefKeys.LATEST_TRUST_PROVIDER_LIST, settings.backupTrustProviderList)
+                    putOrRemove(PrefKeys.LATEST_PAYMENT_TARGETS, settings.backupNipA3PaymentTargets)
 
                     putBoolean(PrefKeys.HIDE_DELETE_REQUEST_DIALOG, settings.hideDeleteRequestDialog)
                     putBoolean(PrefKeys.HIDE_NIP_17_WARNING_DIALOG, settings.hideNIP17WarningDialog)
@@ -442,106 +455,155 @@ object LocalPreferences {
     }
 
     private suspend fun innerLoadCurrentAccountFromEncryptedStorage(npub: String?): AccountSettings? {
-        Log.d("LocalPreferences", "Load account from file $npub")
+        Log.d("LocalPreferences") { "Load account from file $npub" }
         val result =
             withContext(Dispatchers.IO) {
-                checkNotInMainThread()
-
                 return@withContext with(encryptedPreferences(npub)) {
+                    Log.d("LocalPreferences") { "Load account from file $npub - opened file" }
                     val privKey = getString(PrefKeys.NOSTR_PRIVKEY, null)
                     val pubKey = getString(PrefKeys.NOSTR_PUBKEY, null) ?: return@with null
-                    val externalSignerPackageName =
-                        getString(PrefKeys.SIGNER_PACKAGE_NAME, null)
-                            ?: if (getBoolean(PrefKeys.LOGIN_WITH_EXTERNAL_SIGNER, false)) "com.greenart7c3.nostrsigner" else null
+                    val externalSignerPackageName = getString(PrefKeys.SIGNER_PACKAGE_NAME, null) ?: if (getBoolean(PrefKeys.LOGIN_WITH_EXTERNAL_SIGNER, false)) "com.greenart7c3.nostrsigner" else null
 
-                    val defaultHomeFollowList =
-                        getString(PrefKeys.DEFAULT_HOME_FOLLOW_LIST, null) ?: ALL_FOLLOWS
-                    val defaultStoriesFollowList =
-                        getString(PrefKeys.DEFAULT_STORIES_FOLLOW_LIST, null) ?: GLOBAL_FOLLOWS
-                    val defaultNotificationFollowList =
-                        getString(PrefKeys.DEFAULT_NOTIFICATION_FOLLOW_LIST, null) ?: GLOBAL_FOLLOWS
-                    val defaultDiscoveryFollowList =
-                        getString(PrefKeys.DEFAULT_DISCOVERY_FOLLOW_LIST, null) ?: GLOBAL_FOLLOWS
+                    val keyPair = KeyPair(privKey = privKey?.hexToByteArray(), pubKey = pubKey.hexToByteArray())
 
-                    val zapPaymentRequestServer = parseOrNull<Nip47WalletConnect.Nip47URI>(PrefKeys.ZAP_PAYMENT_REQUEST_SERVER)
-                    val defaultFileServer = parseOrNull<ServerName>(PrefKeys.DEFAULT_FILE_SERVER) ?: DEFAULT_MEDIA_SERVERS[0]
-
-                    val pendingAttestations = parseOrNull<Map<HexKey, String>>(PrefKeys.PENDING_ATTESTATIONS) ?: mapOf()
-                    val localRelayServers = getStringSet(PrefKeys.LOCAL_RELAY_SERVERS, null) ?: setOf()
-
-                    val latestUserMetadata = parseEventOrNull<MetadataEvent>(PrefKeys.LATEST_USER_METADATA)
-                    val latestContactList = parseEventOrNull<ContactListEvent>(PrefKeys.LATEST_CONTACT_LIST)
-                    val latestDmRelayList = parseEventOrNull<ChatMessageRelayListEvent>(PrefKeys.LATEST_DM_RELAY_LIST)
-                    val latestNip65RelayList = parseEventOrNull<AdvertisedRelayListEvent>(PrefKeys.LATEST_NIP65_RELAY_LIST)
-                    val latestSearchRelayList = parseEventOrNull<SearchRelayListEvent>(PrefKeys.LATEST_SEARCH_RELAY_LIST)
-                    val latestIndexRelayList = parseEventOrNull<IndexerRelayListEvent>(PrefKeys.LATEST_INDEX_RELAY_LIST)
-                    val latestBlockedRelayList = parseEventOrNull<BlockedRelayListEvent>(PrefKeys.LATEST_BLOCKED_RELAY_LIST)
-                    val latestTrustedRelayList = parseEventOrNull<TrustedRelayListEvent>(PrefKeys.LATEST_TRUSTED_RELAY_LIST)
-                    val latestMuteList = parseEventOrNull<MuteListEvent>(PrefKeys.LATEST_MUTE_LIST)
-                    val latestPrivateHomeRelayList = parseEventOrNull<PrivateOutboxRelayListEvent>(PrefKeys.LATEST_PRIVATE_HOME_RELAY_LIST)
-                    val latestAppSpecificData = parseEventOrNull<AppSpecificDataEvent>(PrefKeys.LATEST_APP_SPECIFIC_DATA)
-                    val latestChannelList = parseEventOrNull<ChannelListEvent>(PrefKeys.LATEST_CHANNEL_LIST)
-                    val latestCommunityList = parseEventOrNull<CommunityListEvent>(PrefKeys.LATEST_COMMUNITY_LIST)
-                    val latestHashtagList = parseEventOrNull<HashtagListEvent>(PrefKeys.LATEST_HASHTAG_LIST)
-                    val latestGeohashList = parseEventOrNull<GeohashListEvent>(PrefKeys.LATEST_GEOHASH_LIST)
-                    val latestEphemeralList = parseEventOrNull<EphemeralChatListEvent>(PrefKeys.LATEST_EPHEMERAL_LIST)
-                    val latestTrustProviderList = parseEventOrNull<TrustProviderListEvent>(PrefKeys.LATEST_TRUST_PROVIDER_LIST)
+                    Log.d("LocalPreferences") { "Load account from file $npub - keys ready" }
 
+                    val stripLocationOnUpload = getBoolean(PrefKeys.STRIP_LOCATION_ON_UPLOAD, true)
                     val hideDeleteRequestDialog = getBoolean(PrefKeys.HIDE_DELETE_REQUEST_DIALOG, false)
                     val hideBlockAlertDialog = getBoolean(PrefKeys.HIDE_BLOCK_ALERT_DIALOG, false)
                     val hideNIP17WarningDialog = getBoolean(PrefKeys.HIDE_NIP_17_WARNING_DIALOG, false)
+                    val hasDonatedInVersion = getStringSet(PrefKeys.HAS_DONATED_IN_VERSION, null) ?: setOf()
+                    val localRelayServers = getStringSet(PrefKeys.LOCAL_RELAY_SERVERS, null) ?: setOf()
+
+                    val defaultHomeFollowListStr = getString(PrefKeys.DEFAULT_HOME_FOLLOW_LIST, null)
+                    val defaultStoriesFollowListStr = getString(PrefKeys.DEFAULT_STORIES_FOLLOW_LIST, null)
+                    val defaultNotificationFollowListStr = getString(PrefKeys.DEFAULT_NOTIFICATION_FOLLOW_LIST, null)
+                    val defaultDiscoveryFollowListStr = getString(PrefKeys.DEFAULT_DISCOVERY_FOLLOW_LIST, null)
+
+                    val defaultPollsFollowListStr = getString(PrefKeys.DEFAULT_POLLS_FOLLOW_LIST, null)
+                    val defaultPicturesFollowListStr = getString(PrefKeys.DEFAULT_PICTURES_FOLLOW_LIST, null)
+                    val defaultShortsFollowListStr = getString(PrefKeys.DEFAULT_SHORTS_FOLLOW_LIST, null)
+                    val defaultLongsFollowListStr = getString(PrefKeys.DEFAULT_LONGS_FOLLOW_LIST, null)
+
+                    val zapPaymentRequestServerStr = getString(PrefKeys.ZAP_PAYMENT_REQUEST_SERVER, null)
+                    val defaultFileServerStr = getString(PrefKeys.DEFAULT_FILE_SERVER, null)
+
+                    val pendingAttestationsStr = getString(PrefKeys.PENDING_ATTESTATIONS, null)
+                    val latestUserMetadataStr = getString(PrefKeys.LATEST_USER_METADATA, null)
+                    val latestContactListStr = getString(PrefKeys.LATEST_CONTACT_LIST, null)
+                    val latestDmRelayListStr = getString(PrefKeys.LATEST_DM_RELAY_LIST, null)
+                    val latestNip65RelayListStr = getString(PrefKeys.LATEST_NIP65_RELAY_LIST, null)
+                    val latestSearchRelayListStr = getString(PrefKeys.LATEST_SEARCH_RELAY_LIST, null)
+                    val latestIndexRelayListStr = getString(PrefKeys.LATEST_INDEX_RELAY_LIST, null)
+                    val latestRelayFeedsListStr = getString(PrefKeys.LATEST_RELAY_FEEDS_LIST, null)
+                    val latestBlockedRelayListStr = getString(PrefKeys.LATEST_BLOCKED_RELAY_LIST, null)
+                    val latestTrustedRelayListStr = getString(PrefKeys.LATEST_TRUSTED_RELAY_LIST, null)
+                    val latestMuteListStr = getString(PrefKeys.LATEST_MUTE_LIST, null)
+                    val latestPrivateHomeRelayListStr = getString(PrefKeys.LATEST_PRIVATE_HOME_RELAY_LIST, null)
+                    val latestAppSpecificDataStr = getString(PrefKeys.LATEST_APP_SPECIFIC_DATA, null)
+                    val latestChannelListStr = getString(PrefKeys.LATEST_CHANNEL_LIST, null)
+                    val latestCommunityListStr = getString(PrefKeys.LATEST_COMMUNITY_LIST, null)
+                    val latestHashtagListStr = getString(PrefKeys.LATEST_HASHTAG_LIST, null)
+                    val latestGeohashListStr = getString(PrefKeys.LATEST_GEOHASH_LIST, null)
+                    val latestEphemeralListStr = getString(PrefKeys.LATEST_EPHEMERAL_LIST, null)
+                    val latestTrustProviderListStr = getString(PrefKeys.LATEST_TRUST_PROVIDER_LIST, null)
+                    val latestPaymentTargetsStr = getString(PrefKeys.LATEST_PAYMENT_TARGETS, null)
+                    val lastReadPerRouteStr = getString(PrefKeys.LAST_READ_PER_ROUTE, null)
+
+                    Log.d("LocalPreferences") { "Load account from file $npub - before parsing events" }
+
+                    val defaultHomeFollowList = async { parseOrNull<TopFilter>(defaultHomeFollowListStr) ?: TopFilter.AllFollows }
+                    val defaultStoriesFollowList = async { parseOrNull<TopFilter>(defaultStoriesFollowListStr) ?: TopFilter.Global }
+                    val defaultNotificationFollowList = async { parseOrNull<TopFilter>(defaultNotificationFollowListStr) ?: TopFilter.Global }
+                    val defaultDiscoveryFollowList = async { parseOrNull<TopFilter>(defaultDiscoveryFollowListStr) ?: TopFilter.Global }
+
+                    val defaultPollsFollowList = async { parseOrNull<TopFilter>(defaultPollsFollowListStr) ?: TopFilter.Global }
+                    val defaultPicturesFollowList = async { parseOrNull<TopFilter>(defaultPicturesFollowListStr) ?: TopFilter.Global }
+                    val defaultShortsFollowList = async { parseOrNull<TopFilter>(defaultShortsFollowListStr) ?: TopFilter.Global }
+                    val defaultLongsFollowList = async { parseOrNull<TopFilter>(defaultLongsFollowListStr) ?: TopFilter.Global }
+
+                    val zapPaymentRequestServer = async { parseOrNull<Nip47WalletConnect.Nip47URI>(zapPaymentRequestServerStr) }
+                    val defaultFileServer = async { parseOrNull<ServerName>(defaultFileServerStr) ?: DEFAULT_MEDIA_SERVERS[0] }
+
+                    val pendingAttestations = async { parseOrNull<Map<HexKey, String>>(pendingAttestationsStr) ?: mapOf() }
+                    val latestUserMetadata = async { parseEventOrNull<MetadataEvent>(latestUserMetadataStr) }
+                    val latestContactList = async { parseEventOrNull<ContactListEvent>(latestContactListStr) }
+                    val latestDmRelayList = async { parseEventOrNull<ChatMessageRelayListEvent>(latestDmRelayListStr) }
+                    val latestNip65RelayList = async { parseEventOrNull<AdvertisedRelayListEvent>(latestNip65RelayListStr) }
+                    val latestSearchRelayList = async { parseEventOrNull<SearchRelayListEvent>(latestSearchRelayListStr) }
+                    val latestIndexRelayList = async { parseEventOrNull<IndexerRelayListEvent>(latestIndexRelayListStr) }
+                    val latestRelayFeedsList = async { parseEventOrNull<RelayFeedsListEvent>(latestRelayFeedsListStr) }
+                    val latestBlockedRelayList = async { parseEventOrNull<BlockedRelayListEvent>(latestBlockedRelayListStr) }
+                    val latestTrustedRelayList = async { parseEventOrNull<TrustedRelayListEvent>(latestTrustedRelayListStr) }
+                    val latestMuteList = async { parseEventOrNull<MuteListEvent>(latestMuteListStr) }
+                    val latestPrivateHomeRelayList = async { parseEventOrNull<PrivateOutboxRelayListEvent>(latestPrivateHomeRelayListStr) }
+                    val latestAppSpecificData = async { parseEventOrNull<AppSpecificDataEvent>(latestAppSpecificDataStr) }
+                    val latestChannelList = async { parseEventOrNull<ChannelListEvent>(latestChannelListStr) }
+                    val latestCommunityList = async { parseEventOrNull<CommunityListEvent>(latestCommunityListStr) }
+                    val latestHashtagList = async { parseEventOrNull<HashtagListEvent>(latestHashtagListStr) }
+                    val latestGeohashList = async { parseEventOrNull<GeohashListEvent>(latestGeohashListStr) }
+                    val latestEphemeralList = async { parseEventOrNull<EphemeralChatListEvent>(latestEphemeralListStr) }
+                    val latestTrustProviderList = async { parseEventOrNull<TrustProviderListEvent>(latestTrustProviderListStr) }
+                    val latestPaymentTargets = async { parseEventOrNull<PaymentTargetsEvent>(latestPaymentTargetsStr) }
 
                     val lastReadPerRoute =
-                        parseOrNull<Map<String, Long>>(PrefKeys.LAST_READ_PER_ROUTE)?.mapValues {
-                            MutableStateFlow(it.value)
-                        } ?: mapOf()
+                        async {
+                            parseOrNull<Map<String, Long>>(lastReadPerRouteStr)?.mapValues {
+                                MutableStateFlow(it.value)
+                            } ?: mapOf()
+                        }
 
-                    val keyPair = KeyPair(privKey = privKey?.hexToByteArray(), pubKey = pubKey.hexToByteArray())
-                    val hasDonatedInVersion = getStringSet(PrefKeys.HAS_DONATED_IN_VERSION, null) ?: setOf()
+                    Log.d("LocalPreferences") { "Load account from file $npub - asyncs created" }
 
                     return@with AccountSettings(
                         keyPair = keyPair,
                         transientAccount = false,
                         externalSignerPackageName = externalSignerPackageName,
                         localRelayServers = MutableStateFlow(localRelayServers),
-                        defaultFileServer = defaultFileServer,
-                        defaultHomeFollowList = MutableStateFlow(defaultHomeFollowList),
-                        defaultStoriesFollowList = MutableStateFlow(defaultStoriesFollowList),
-                        defaultNotificationFollowList = MutableStateFlow(defaultNotificationFollowList),
-                        defaultDiscoveryFollowList = MutableStateFlow(defaultDiscoveryFollowList),
-                        zapPaymentRequest = MutableStateFlow(zapPaymentRequestServer?.normalize()),
+                        defaultFileServer = defaultFileServer.await(),
+                        stripLocationOnUpload = stripLocationOnUpload,
+                        defaultHomeFollowList = MutableStateFlow(defaultHomeFollowList.await()),
+                        defaultStoriesFollowList = MutableStateFlow(defaultStoriesFollowList.await()),
+                        defaultNotificationFollowList = MutableStateFlow(defaultNotificationFollowList.await()),
+                        defaultDiscoveryFollowList = MutableStateFlow(defaultDiscoveryFollowList.await()),
+                        defaultPollsFollowList = MutableStateFlow(defaultPollsFollowList.await()),
+                        defaultPicturesFollowList = MutableStateFlow(defaultPicturesFollowList.await()),
+                        defaultShortsFollowList = MutableStateFlow(defaultShortsFollowList.await()),
+                        defaultLongsFollowList = MutableStateFlow(defaultLongsFollowList.await()),
+                        zapPaymentRequest = MutableStateFlow(zapPaymentRequestServer.await()?.normalize()),
                         hideDeleteRequestDialog = hideDeleteRequestDialog,
                         hideBlockAlertDialog = hideBlockAlertDialog,
                         hideNIP17WarningDialog = hideNIP17WarningDialog,
-                        backupUserMetadata = latestUserMetadata,
-                        backupContactList = latestContactList,
-                        backupNIP65RelayList = latestNip65RelayList,
-                        backupDMRelayList = latestDmRelayList,
-                        backupSearchRelayList = latestSearchRelayList,
-                        backupIndexRelayList = latestIndexRelayList,
-                        backupBlockedRelayList = latestBlockedRelayList,
-                        backupTrustedRelayList = latestTrustedRelayList,
-                        backupPrivateHomeRelayList = latestPrivateHomeRelayList,
-                        backupMuteList = latestMuteList,
-                        backupAppSpecificData = latestAppSpecificData,
-                        backupChannelList = latestChannelList,
-                        backupCommunityList = latestCommunityList,
-                        backupHashtagList = latestHashtagList,
-                        backupGeohashList = latestGeohashList,
-                        backupEphemeralChatList = latestEphemeralList,
-                        backupTrustProviderList = latestTrustProviderList,
-                        lastReadPerRoute = MutableStateFlow(lastReadPerRoute),
+                        backupUserMetadata = latestUserMetadata.await(),
+                        backupContactList = latestContactList.await(),
+                        backupNIP65RelayList = latestNip65RelayList.await(),
+                        backupDMRelayList = latestDmRelayList.await(),
+                        backupSearchRelayList = latestSearchRelayList.await(),
+                        backupIndexRelayList = latestIndexRelayList.await(),
+                        backupRelayFeedsList = latestRelayFeedsList.await(),
+                        backupBlockedRelayList = latestBlockedRelayList.await(),
+                        backupTrustedRelayList = latestTrustedRelayList.await(),
+                        backupPrivateHomeRelayList = latestPrivateHomeRelayList.await(),
+                        backupMuteList = latestMuteList.await(),
+                        backupAppSpecificData = latestAppSpecificData.await(),
+                        backupChannelList = latestChannelList.await(),
+                        backupCommunityList = latestCommunityList.await(),
+                        backupHashtagList = latestHashtagList.await(),
+                        backupGeohashList = latestGeohashList.await(),
+                        backupEphemeralChatList = latestEphemeralList.await(),
+                        backupTrustProviderList = latestTrustProviderList.await(),
+                        lastReadPerRoute = MutableStateFlow(lastReadPerRoute.await()),
                         hasDonatedInVersion = MutableStateFlow(hasDonatedInVersion),
-                        pendingAttestations = MutableStateFlow(pendingAttestations),
+                        pendingAttestations = MutableStateFlow(pendingAttestations.await()),
+                        backupNipA3PaymentTargets = latestPaymentTargets.await(),
                     )
                 }
             }
-        Log.d("LocalPreferences", "Loaded account from file $npub")
+        Log.d("LocalPreferences") { "Loaded account from file $npub" }
         return result
     }
 
-    private inline fun <reified T : Any> SharedPreferences.parseOrNull(key: String): T? {
-        val value = getString(key, null)
+    private inline fun <reified T : Any> parseOrNull(value: String?): T? {
         if (value.isNullOrEmpty() || value == "null") {
             return null
         }
@@ -553,13 +615,12 @@ object LocalPreferences {
             }
         } catch (e: Throwable) {
             if (e is CancellationException) throw e
-            Log.w("LocalPreferences", "Error Decoding $key from Preferences with value $value", e)
+            Log.w("LocalPreferences", "Error Decoding ${T::class.java} from Preferences with value $value", e)
             null
         }
     }
 
-    private inline fun <reified T> SharedPreferences.parseEventOrNull(key: String): T? {
-        val value = getString(key, null)
+    private inline fun <reified T> parseEventOrNull(value: String?): T? {
         if (value.isNullOrEmpty() || value == "null") {
             return null
         }
@@ -567,7 +628,7 @@ object LocalPreferences {
             Event.fromJson(value) as T?
         } catch (e: Throwable) {
             if (e is CancellationException) throw e
-            Log.w("LocalPreferences", "Error Decoding $key from Preferences with value $value", e)
+            Log.w("LocalPreferences", "Error Decoding ${T::class.java} from Preferences with value $value", e)
             null
         }
     }

amethyst/src/main/java/com/vitorpamplona/amethyst/model/AccountSettings.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -21,11 +21,14 @@
 package com.vitorpamplona.amethyst.model
 
 import androidx.compose.runtime.Stable
+import com.vitorpamplona.amethyst.commons.model.emphChat.EphemeralChatRepository
+import com.vitorpamplona.amethyst.commons.model.nip28PublicChats.PublicChatListRepository
 import com.vitorpamplona.amethyst.ui.actions.mediaServers.DEFAULT_MEDIA_SERVERS
 import com.vitorpamplona.amethyst.ui.actions.mediaServers.ServerName
 import com.vitorpamplona.amethyst.ui.screen.FeedDefinition
 import com.vitorpamplona.quartz.experimental.ephemChat.list.EphemeralChatListEvent
-import com.vitorpamplona.quartz.experimental.trustedAssertions.list.TrustProviderListEvent
+import com.vitorpamplona.quartz.experimental.nipA3.PaymentTargetsEvent
+import com.vitorpamplona.quartz.nip01Core.core.Address
 import com.vitorpamplona.quartz.nip01Core.core.HexKey
 import com.vitorpamplona.quartz.nip01Core.crypto.KeyPair
 import com.vitorpamplona.quartz.nip01Core.metadata.MetadataEvent
@@ -43,6 +46,7 @@ import com.vitorpamplona.quartz.nip51Lists.hashtagList.HashtagListEvent
 import com.vitorpamplona.quartz.nip51Lists.muteList.MuteListEvent
 import com.vitorpamplona.quartz.nip51Lists.relayLists.BlockedRelayListEvent
 import com.vitorpamplona.quartz.nip51Lists.relayLists.IndexerRelayListEvent
+import com.vitorpamplona.quartz.nip51Lists.relayLists.RelayFeedsListEvent
 import com.vitorpamplona.quartz.nip51Lists.relayLists.TrustedRelayListEvent
 import com.vitorpamplona.quartz.nip55AndroidSigner.api.CommandType
 import com.vitorpamplona.quartz.nip55AndroidSigner.api.permission.Permission
@@ -52,12 +56,13 @@ import com.vitorpamplona.quartz.nip65RelayList.tags.AdvertisedRelayInfo
 import com.vitorpamplona.quartz.nip65RelayList.tags.AdvertisedRelayType
 import com.vitorpamplona.quartz.nip72ModCommunities.follow.CommunityListEvent
 import com.vitorpamplona.quartz.nip78AppData.AppSpecificDataEvent
+import com.vitorpamplona.quartz.nip85TrustedAssertions.list.TrustProviderListEvent
 import kotlinx.collections.immutable.toImmutableList
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.update
-import java.util.Locale
+import kotlinx.serialization.Serializable
 
 val DefaultChannels =
     listOf(
@@ -76,11 +81,13 @@ val DefaultNIP65List =
         AdvertisedRelayInfo(Constants.bitcoiner, AdvertisedRelayType.BOTH),
     )
 
+val DefaultGlobalRelays = listOf(Constants.wine, Constants.news)
+
 val DefaultDMRelayList = listOf(Constants.auth, Constants.oxchat, Constants.nos)
 
-val DefaultSearchRelayList = setOf(Constants.band, Constants.wine, Constants.where, Constants.nostoday)
+val DefaultSearchRelayList = setOf(Constants.wine, Constants.where, Constants.nostoday, Constants.antiprimal, Constants.ditto)
 
-val DefaultIndexerRelayList = setOf(Constants.purplepages, Constants.coracle, Constants.userkinds)
+val DefaultIndexerRelayList = setOf(Constants.purplepages, Constants.coracle, Constants.userkinds, Constants.yabu, Constants.nostr1)
 
 val DefaultSignerPermissions =
     listOf(
@@ -93,20 +100,58 @@ val DefaultSignerPermissions =
         Permission(CommandType.DECRYPT_ZAP_EVENT),
     )
 
-// This has spaces to avoid mixing with a potential NIP-51 list with the same name.
-val GLOBAL_FOLLOWS = " Global "
+@Serializable
+sealed class TopFilter(
+    val code: String,
+) {
+    @Serializable
+    object Global : TopFilter(" Global ")
 
-// This has spaces to avoid mixing with a potential NIP-51 list with the same name.
-val ALL_FOLLOWS = " All Follows "
+    @Serializable
+    object AllFollows : TopFilter(" All Follows ")
 
-// This has spaces to avoid mixing with a potential NIP-51 list with the same name.
-val ALL_USER_FOLLOWS = " All User Follows "
+    @Serializable
+    object AllUserFollows : TopFilter(" All User Follows ")
 
-// This has spaces to avoid mixing with a potential NIP-51 list with the same name.
-val KIND3_FOLLOWS = " Main User Follows "
+    @Serializable
+    object DefaultFollows : TopFilter(" Main User Follows ")
 
-// This has spaces to avoid mixing with a potential NIP-51 list with the same name.
-val AROUND_ME = " Around Me "
+    @Serializable
+    object AroundMe : TopFilter(" Around Me ")
+
+    @Serializable
+    object Chess : TopFilter(" Chess ")
+
+    @Serializable
+    class PeopleList(
+        val address: Address,
+    ) : TopFilter(address.toValue())
+
+    @Serializable
+    class MuteList(
+        val address: Address,
+    ) : TopFilter(address.toValue())
+
+    @Serializable
+    class Community(
+        val address: Address,
+    ) : TopFilter("Community/${address.toValue()}")
+
+    @Serializable
+    class Hashtag(
+        val tag: String,
+    ) : TopFilter("Hashtag/$tag")
+
+    @Serializable
+    class Geohash(
+        val tag: String,
+    ) : TopFilter("Geohash/$tag")
+
+    @Serializable
+    class Relay(
+        val url: String,
+    ) : TopFilter("Relay/$url")
+}
 
 @Stable
 class AccountSettings(
@@ -115,11 +160,16 @@ class AccountSettings(
     var externalSignerPackageName: String? = null,
     var localRelayServers: MutableStateFlow<Set<String>> = MutableStateFlow(setOf()),
     var defaultFileServer: ServerName = DEFAULT_MEDIA_SERVERS[0],
-    val defaultHomeFollowList: MutableStateFlow<String> = MutableStateFlow(ALL_FOLLOWS),
-    val defaultStoriesFollowList: MutableStateFlow<String> = MutableStateFlow(GLOBAL_FOLLOWS),
-    val defaultNotificationFollowList: MutableStateFlow<String> = MutableStateFlow(GLOBAL_FOLLOWS),
-    val defaultDiscoveryFollowList: MutableStateFlow<String> = MutableStateFlow(GLOBAL_FOLLOWS),
-    var zapPaymentRequest: MutableStateFlow<Nip47WalletConnect.Nip47URINorm?> = MutableStateFlow(null),
+    var stripLocationOnUpload: Boolean = true,
+    val defaultHomeFollowList: MutableStateFlow<TopFilter> = MutableStateFlow(TopFilter.AllFollows),
+    val defaultStoriesFollowList: MutableStateFlow<TopFilter> = MutableStateFlow(TopFilter.Global),
+    val defaultNotificationFollowList: MutableStateFlow<TopFilter> = MutableStateFlow(TopFilter.Global),
+    val defaultDiscoveryFollowList: MutableStateFlow<TopFilter> = MutableStateFlow(TopFilter.Global),
+    val defaultPollsFollowList: MutableStateFlow<TopFilter> = MutableStateFlow(TopFilter.Global),
+    val defaultPicturesFollowList: MutableStateFlow<TopFilter> = MutableStateFlow(TopFilter.Global),
+    val defaultShortsFollowList: MutableStateFlow<TopFilter> = MutableStateFlow(TopFilter.Global),
+    val defaultLongsFollowList: MutableStateFlow<TopFilter> = MutableStateFlow(TopFilter.Global),
+    val zapPaymentRequest: MutableStateFlow<Nip47WalletConnect.Nip47URINorm?> = MutableStateFlow(null),
     var hideDeleteRequestDialog: Boolean = false,
     var hideBlockAlertDialog: Boolean = false,
     var hideNIP17WarningDialog: Boolean = false,
@@ -129,6 +179,7 @@ class AccountSettings(
     var backupNIP65RelayList: AdvertisedRelayListEvent? = null,
     var backupSearchRelayList: SearchRelayListEvent? = null,
     var backupIndexRelayList: IndexerRelayListEvent? = null,
+    var backupRelayFeedsList: RelayFeedsListEvent? = null,
     var backupBlockedRelayList: BlockedRelayListEvent? = null,
     var backupTrustedRelayList: TrustedRelayListEvent? = null,
     var backupMuteList: MuteListEvent? = null,
@@ -141,9 +192,11 @@ class AccountSettings(
     var backupEphemeralChatList: EphemeralChatListEvent? = null,
     var backupTrustProviderList: TrustProviderListEvent? = null,
     val lastReadPerRoute: MutableStateFlow<Map<String, MutableStateFlow<Long>>> = MutableStateFlow(mapOf()),
-    var hasDonatedInVersion: MutableStateFlow<Set<String>> = MutableStateFlow(setOf<String>()),
-    val pendingAttestations: MutableStateFlow<Map<HexKey, String>> = MutableStateFlow<Map<HexKey, String>>(mapOf()),
-) {
+    val hasDonatedInVersion: MutableStateFlow<Set<String>> = MutableStateFlow(setOf()),
+    val pendingAttestations: MutableStateFlow<Map<HexKey, String>> = MutableStateFlow(mapOf()),
+    var backupNipA3PaymentTargets: PaymentTargetsEvent? = null,
+) : EphemeralChatRepository,
+    PublicChatListRepository {
     val saveable = MutableStateFlow(AccountSettingsUpdater(null))
     val syncedSettings: AccountSyncedSettings = AccountSyncedSettings(AccountSyncedSettingsInternal())
 
@@ -188,6 +241,15 @@ class AccountSettings(
         return false
     }
 
+    fun changeReactionRowItems(newItems: List<ReactionRowItem>): Boolean {
+        if (syncedSettings.reactions.reactionRowItems.value != newItems) {
+            syncedSettings.reactions.reactionRowItems.tryEmit(newItems.toImmutableList())
+            saveAccountSettings()
+            return true
+        }
+        return false
+    }
+
     fun changeZapPaymentRequest(newServer: Nip47WalletConnect.Nip47URINorm?): Boolean {
         if (zapPaymentRequest.value != newServer) {
             zapPaymentRequest.tryEmit(newServer)
@@ -208,6 +270,13 @@ class AccountSettings(
         }
     }
 
+    fun changeStripLocationOnUpload(strip: Boolean) {
+        if (stripLocationOnUpload != strip) {
+            stripLocationOnUpload = strip
+            saveAccountSettings()
+        }
+    }
+
     // ---
     // list names
     // ---
@@ -216,7 +285,7 @@ class AccountSettings(
         changeDefaultHomeFollowList(name.code)
     }
 
-    fun changeDefaultHomeFollowList(name: String) {
+    fun changeDefaultHomeFollowList(name: TopFilter) {
         if (defaultHomeFollowList.value != name) {
             defaultHomeFollowList.tryEmit(name)
             saveAccountSettings()
@@ -227,7 +296,7 @@ class AccountSettings(
         changeDefaultStoriesFollowList(name.code)
     }
 
-    fun changeDefaultStoriesFollowList(name: String) {
+    fun changeDefaultStoriesFollowList(name: TopFilter) {
         if (defaultStoriesFollowList.value != name) {
             defaultStoriesFollowList.tryEmit(name)
             saveAccountSettings()
@@ -238,7 +307,7 @@ class AccountSettings(
         changeDefaultNotificationFollowList(name.code)
     }
 
-    fun changeDefaultNotificationFollowList(name: String) {
+    fun changeDefaultNotificationFollowList(name: TopFilter) {
         if (defaultNotificationFollowList.value != name) {
             defaultNotificationFollowList.tryEmit(name)
             saveAccountSettings()
@@ -249,13 +318,57 @@ class AccountSettings(
         changeDefaultDiscoveryFollowList(name.code)
     }
 
-    fun changeDefaultDiscoveryFollowList(name: String) {
+    fun changeDefaultDiscoveryFollowList(name: TopFilter) {
         if (defaultDiscoveryFollowList.value != name) {
             defaultDiscoveryFollowList.tryEmit(name)
             saveAccountSettings()
         }
     }
 
+    fun changeDefaultPollsFollowList(name: FeedDefinition) {
+        changeDefaultPollsFollowList(name.code)
+    }
+
+    fun changeDefaultPollsFollowList(name: TopFilter) {
+        if (defaultPollsFollowList.value != name) {
+            defaultPollsFollowList.tryEmit(name)
+            saveAccountSettings()
+        }
+    }
+
+    fun changeDefaultPicturesFollowList(name: FeedDefinition) {
+        changeDefaultPicturesFollowList(name.code)
+    }
+
+    fun changeDefaultPicturesFollowList(name: TopFilter) {
+        if (defaultPicturesFollowList.value != name) {
+            defaultPicturesFollowList.tryEmit(name)
+            saveAccountSettings()
+        }
+    }
+
+    fun changeDefaultShortsFollowList(name: FeedDefinition) {
+        changeDefaultShortsFollowList(name.code)
+    }
+
+    fun changeDefaultShortsFollowList(name: TopFilter) {
+        if (defaultShortsFollowList.value != name) {
+            defaultShortsFollowList.tryEmit(name)
+            saveAccountSettings()
+        }
+    }
+
+    fun changeDefaultLongsFollowList(name: FeedDefinition) {
+        changeDefaultLongsFollowList(name.code)
+    }
+
+    fun changeDefaultLongsFollowList(name: TopFilter) {
+        if (defaultLongsFollowList.value != name) {
+            defaultLongsFollowList.tryEmit(name)
+            saveAccountSettings()
+        }
+    }
+
     // ---
     // language services
     // ---
@@ -264,9 +377,21 @@ class AccountSettings(
         saveAccountSettings()
     }
 
-    fun translateToContains(languageCode: Locale) = syncedSettings.languages.translateTo.contains(languageCode.language)
+    fun addDontTranslateFrom(languageCode: String) {
+        syncedSettings.languages.addDontTranslateFrom(languageCode)
+        saveAccountSettings()
+    }
 
-    fun updateTranslateTo(languageCode: Locale): Boolean {
+    fun removeDontTranslateFrom(languageCode: String) {
+        syncedSettings.languages.removeDontTranslateFrom(languageCode)
+        saveAccountSettings()
+    }
+
+    fun translateToContains(languageCode: String) =
+        syncedSettings.languages.translateTo.value
+            .contains(languageCode)
+
+    fun updateTranslateTo(languageCode: String): Boolean {
         if (syncedSettings.languages.updateTranslateTo(languageCode)) {
             saveAccountSettings()
             return true
@@ -339,6 +464,16 @@ class AccountSettings(
         }
     }
 
+    fun updateNIPA3PaymentTargets(newNIPA3PaymentTargets: PaymentTargetsEvent?) {
+        if (newNIPA3PaymentTargets == null || newNIPA3PaymentTargets.tags.isEmpty()) return
+
+        // Events might be different objects, we have to compare their ids.
+        if (backupNipA3PaymentTargets?.id != newNIPA3PaymentTargets.id) {
+            backupNipA3PaymentTargets = newNIPA3PaymentTargets
+            saveAccountSettings()
+        }
+    }
+
     fun updateSearchRelayList(newSearchRelayList: SearchRelayListEvent?) {
         if (newSearchRelayList == null || newSearchRelayList.tags.isEmpty()) return
 
@@ -359,6 +494,16 @@ class AccountSettings(
         }
     }
 
+    fun updateRelayFeedList(newRelayFeedList: RelayFeedsListEvent?) {
+        if (newRelayFeedList == null || newRelayFeedList.tags.isEmpty()) return
+
+        // Events might be different objects, we have to compare their ids.
+        if (backupRelayFeedsList?.id != newRelayFeedList.id) {
+            backupRelayFeedsList = newRelayFeedList
+            saveAccountSettings()
+        }
+    }
+
     fun updateBlockedRelayList(newBlockedRelayList: BlockedRelayListEvent?) {
         if (newBlockedRelayList == null || newBlockedRelayList.tags.isEmpty()) return
 
@@ -389,7 +534,9 @@ class AccountSettings(
         }
     }
 
-    fun updateChannelListTo(newChannelList: ChannelListEvent?) {
+    override fun channelList() = backupChannelList
+
+    override fun updateChannelListTo(newChannelList: ChannelListEvent?) {
         if (newChannelList == null || newChannelList.tags.isEmpty()) return
 
         // Events might be different objects, we have to compare their ids.
@@ -429,7 +576,9 @@ class AccountSettings(
         }
     }
 
-    fun updateEphemeralChatListTo(newEphemeralChatList: EphemeralChatListEvent?) {
+    override fun ephemeralChatList() = backupEphemeralChatList
+
+    override fun updateEphemeralChatListTo(newEphemeralChatList: EphemeralChatListEvent?) {
         if (newEphemeralChatList == null || newEphemeralChatList.tags.isEmpty()) return
 
         // Events might be different objects, we have to compare their ids.
@@ -532,7 +681,7 @@ class AccountSettings(
         route: String,
         timestampInSecs: Long,
     ): MutableStateFlow<Long> =
-        MutableStateFlow<Long>(timestampInSecs).also { newFlow ->
+        MutableStateFlow(timestampInSecs).also { newFlow ->
             lastReadPerRoute.update { it + Pair(route, newFlow) }
             saveAccountSettings()
         }

amethyst/src/main/java/com/vitorpamplona/amethyst/model/AccountSyncedSettings.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -27,13 +27,16 @@ import kotlinx.collections.immutable.ImmutableList
 import kotlinx.collections.immutable.toImmutableList
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.update
-import java.util.Locale
 
 @Stable
 class AccountSyncedSettings(
     internalSettings: AccountSyncedSettingsInternal,
 ) {
-    val reactions = AccountReactionPreferences(MutableStateFlow(internalSettings.reactions.reactionChoices.toImmutableList()))
+    val reactions =
+        AccountReactionPreferences(
+            MutableStateFlow(internalSettings.reactions.reactionChoices.toImmutableList()),
+            MutableStateFlow(internalSettings.reactions.reactionRowItems.toImmutableList()),
+        )
     val zaps =
         AccountZapPreferences(
             MutableStateFlow(internalSettings.zaps.zapAmountChoices.toImmutableList()),
@@ -41,9 +44,9 @@ class AccountSyncedSettings(
         )
     val languages =
         AccountLanguagePreferences(
-            internalSettings.languages.dontTranslateFrom,
-            internalSettings.languages.languagePreferences,
-            internalSettings.languages.translateTo,
+            MutableStateFlow(internalSettings.languages.dontTranslateFrom),
+            MutableStateFlow(internalSettings.languages.languagePreferences),
+            MutableStateFlow(internalSettings.languages.translateTo),
         )
     val security =
         AccountSecurityPreferences(
@@ -54,7 +57,7 @@ class AccountSyncedSettings(
 
     fun toInternal(): AccountSyncedSettingsInternal =
         AccountSyncedSettingsInternal(
-            reactions = AccountReactionPreferencesInternal(reactions.reactionChoices.value),
+            reactions = AccountReactionPreferencesInternal(reactions.reactionChoices.value, reactions.reactionRowItems.value),
             zaps =
                 AccountZapPreferencesInternal(
                     zaps.zapAmountChoices.value,
@@ -62,9 +65,9 @@ class AccountSyncedSettings(
                 ),
             languages =
                 AccountLanguagePreferencesInternal(
-                    languages.dontTranslateFrom,
-                    languages.languagePreferences,
-                    languages.translateTo,
+                    languages.dontTranslateFrom.value,
+                    languages.languagePreferences.value,
+                    languages.translateTo.value,
                 ),
             security =
                 AccountSecurityPreferencesInternal(
@@ -80,6 +83,11 @@ class AccountSyncedSettings(
             reactions.reactionChoices.tryEmit(newReactionChoices)
         }
 
+        val newReactionRowItems = syncedSettingsInternal.reactions.reactionRowItems.toImmutableList()
+        if (!equalImmutableLists(reactions.reactionRowItems.value, newReactionRowItems)) {
+            reactions.reactionRowItems.tryEmit(newReactionRowItems)
+        }
+
         val newZapChoices = syncedSettingsInternal.zaps.zapAmountChoices.toImmutableList()
         if (!equalImmutableLists(zaps.zapAmountChoices.value, newZapChoices)) {
             zaps.zapAmountChoices.tryEmit(newZapChoices)
@@ -89,16 +97,16 @@ class AccountSyncedSettings(
             zaps.defaultZapType.tryEmit(syncedSettingsInternal.zaps.defaultZapType)
         }
 
-        if (languages.dontTranslateFrom != syncedSettingsInternal.languages.dontTranslateFrom) {
-            languages.dontTranslateFrom = syncedSettingsInternal.languages.dontTranslateFrom
+        if (languages.dontTranslateFrom.value != syncedSettingsInternal.languages.dontTranslateFrom) {
+            languages.dontTranslateFrom.value = syncedSettingsInternal.languages.dontTranslateFrom
         }
 
-        if (languages.languagePreferences != syncedSettingsInternal.languages.languagePreferences) {
-            languages.languagePreferences = syncedSettingsInternal.languages.languagePreferences
+        if (languages.languagePreferences.value != syncedSettingsInternal.languages.languagePreferences) {
+            languages.languagePreferences.value = syncedSettingsInternal.languages.languagePreferences
         }
 
-        if (languages.translateTo != syncedSettingsInternal.languages.translateTo) {
-            languages.translateTo = syncedSettingsInternal.languages.translateTo
+        if (languages.translateTo.value != syncedSettingsInternal.languages.translateTo) {
+            languages.translateTo.value = syncedSettingsInternal.languages.translateTo
         }
 
         if (security.showSensitiveContent.value != syncedSettingsInternal.security.showSensitiveContent) {
@@ -114,12 +122,13 @@ class AccountSyncedSettings(
         }
     }
 
-    fun dontTranslateFromFilteredBySpokenLanguages(): Set<String> = languages.dontTranslateFrom - getLanguagesSpokenByUser()
+    fun dontTranslateFromFilteredBySpokenLanguages(): Set<String> = languages.dontTranslateFrom.value - getLanguagesSpokenByUser()
 }
 
 @Stable
 class AccountReactionPreferences(
     var reactionChoices: MutableStateFlow<ImmutableList<String>>,
+    var reactionRowItems: MutableStateFlow<ImmutableList<ReactionRowItem>>,
 )
 
 @Stable
@@ -130,27 +139,36 @@ class AccountZapPreferences(
 
 @Stable
 class AccountLanguagePreferences(
-    var dontTranslateFrom: Set<String>,
-    var languagePreferences: Map<String, String>,
-    var translateTo: String,
+    var dontTranslateFrom: MutableStateFlow<Set<String>>,
+    var languagePreferences: MutableStateFlow<Map<String, String>>,
+    var translateTo: MutableStateFlow<String>,
 ) {
     // ---
     // language services
     // ---
     fun toggleDontTranslateFrom(languageCode: String) {
-        dontTranslateFrom =
-            if (!dontTranslateFrom.contains(languageCode)) {
-                dontTranslateFrom.plus(languageCode)
+        dontTranslateFrom.update {
+            if (it.contains(languageCode)) {
+                it - languageCode
             } else {
-                dontTranslateFrom.minus(languageCode)
+                it + languageCode
             }
+        }
     }
 
-    fun translateToContains(languageCode: Locale) = translateTo.contains(languageCode.language)
+    fun addDontTranslateFrom(languageCode: String) {
+        dontTranslateFrom.update { it + languageCode }
+    }
 
-    fun updateTranslateTo(languageCode: Locale): Boolean {
-        if (translateTo != languageCode.language) {
-            translateTo = languageCode.language
+    fun removeDontTranslateFrom(languageCode: String) {
+        dontTranslateFrom.update { it - languageCode }
+    }
+
+    fun translateToContains(languageCode: String) = translateTo.value.contains(languageCode)
+
+    fun updateTranslateTo(languageCode: String): Boolean {
+        if (translateTo.value != languageCode) {
+            translateTo.tryEmit(languageCode)
             return true
         }
         return false
@@ -162,13 +180,15 @@ class AccountLanguagePreferences(
         preference: String,
     ) {
         val key = "$source,$target"
-        if (key !in languagePreferences) {
-            languagePreferences = languagePreferences + Pair(key, preference)
-        } else {
-            if (languagePreferences.get(key) == preference) {
-                languagePreferences = languagePreferences.minus(key)
+        languagePreferences.update {
+            if (key !in it) {
+                it + Pair(key, preference)
             } else {
-                languagePreferences = languagePreferences + Pair(key, preference)
+                if (it.get(key) == preference) {
+                    it.minus(key)
+                } else {
+                    it + Pair(key, preference)
+                }
             }
         }
     }
@@ -176,7 +196,7 @@ class AccountLanguagePreferences(
     fun preferenceBetween(
         source: String,
         target: String,
-    ): String? = languagePreferences["$source,$target"]
+    ): String? = languagePreferences.value["$source,$target"]
 }
 
 @Stable

amethyst/src/main/java/com/vitorpamplona/amethyst/model/AccountSyncedSettingsInternal.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -39,6 +39,31 @@ val DefaultReactions =
 
 val DefaultZapAmounts = listOf(100L, 500L, 1000L)
 
+@Serializable
+enum class ReactionRowAction {
+    Reply,
+    Boost,
+    Like,
+    Zap,
+    Share,
+}
+
+@Serializable
+data class ReactionRowItem(
+    val action: ReactionRowAction,
+    val enabled: Boolean = true,
+    val showCounter: Boolean = true,
+)
+
+val DefaultReactionRowItems =
+    listOf(
+        ReactionRowItem(ReactionRowAction.Reply),
+        ReactionRowItem(ReactionRowAction.Boost),
+        ReactionRowItem(ReactionRowAction.Like),
+        ReactionRowItem(ReactionRowAction.Zap),
+        ReactionRowItem(ReactionRowAction.Share, showCounter = false),
+    )
+
 fun getLanguagesSpokenByUser(): Set<String> {
     val languageList = ConfigurationCompat.getLocales(Resources.getSystem().getConfiguration())
     val codedList = mutableSetOf<String>()
@@ -59,6 +84,7 @@ class AccountSyncedSettingsInternal(
 @Serializable
 class AccountReactionPreferencesInternal(
     var reactionChoices: List<String> = DefaultReactions,
+    var reactionRowItems: List<ReactionRowItem> = DefaultReactionRowItems,
 )
 
 @Serializable

amethyst/src/main/java/com/vitorpamplona/amethyst/model/AntiSpamFilter.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -87,7 +87,7 @@ class AntiSpamFilter {
                 val link1 = njumpLink(NAddress.create(existingAddress.kind, existingAddress.pubKeyHex, existingAddress.dTag, relay))
                 val link2 = njumpLink(NAddress.create(event.kind, event.pubKey, event.dTag(), relay))
 
-                Log.w("Duplicated/SPAM", "${relay?.url} $link1 $link2")
+                Log.w("Duplicated/SPAM") { "${relay?.url} $link1 $link2" }
 
                 // Log down offenders
                 val spammer = logOffender(hash, event)
@@ -106,16 +106,15 @@ class AntiSpamFilter {
             recentAddressables.put(hash, address)
         } else {
             // normal event
+            val existingEvent = recentEventIds[hash]
             if (
-                (recentEventIds[hash] != null && recentEventIds[hash] != event.id) ||
+                (existingEvent != null && existingEvent != event.id) ||
                 (spamMessages[hash] != null && !spamMessages[hash].duplicatedEventIds.contains(event.id))
             ) {
-                val existingEvent = recentEventIds[hash]
-
                 val link1 = njumpLink(NEvent.create(existingEvent, null, null, relay))
                 val link2 = njumpLink(NEvent.create(event.id, null, null, relay))
 
-                Log.w("Duplicated/SPAM", "${relay?.url} $link1 $link2")
+                Log.w("Duplicated/SPAM") { "${relay?.url} $link1 $link2" }
 
                 // Log down offenders
                 val spammer = logOffender(hash, event)
@@ -171,7 +170,7 @@ class AntiSpamFilter {
         }
     }
 
-    val flowSpam = MutableStateFlow<AntiSpamState>(AntiSpamState(this))
+    val flowSpam = MutableStateFlow(AntiSpamState(this))
 }
 
 class AntiSpamState(

amethyst/src/main/java/com/vitorpamplona/amethyst/model/Constants.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -28,7 +28,6 @@ object Constants {
     val primal = RelayUrlNormalizer.normalize("wss://relay.primal.net")
     val damus = RelayUrlNormalizer.normalize("wss://relay.damus.io")
     val wine = RelayUrlNormalizer.normalize("wss://nostr.wine")
-    val band = RelayUrlNormalizer.normalize("wss://relay.nostr.band")
 
     val where = RelayUrlNormalizer.normalize("wss://relay.noswhere.com")
     val elites = RelayUrlNormalizer.normalize("wss://nostrelites.org")
@@ -37,16 +36,20 @@ object Constants {
     val oxtr = RelayUrlNormalizer.normalize("wss://nostr.oxtr.dev")
 
     val nostoday = RelayUrlNormalizer.normalize("wss://search.nos.today")
+    val antiprimal = RelayUrlNormalizer.normalize("wss://antiprimal.net")
+    val ditto = RelayUrlNormalizer.normalize("wss://relay.ditto.pub")
 
     val auth = RelayUrlNormalizer.normalize("wss://auth.nostr1.com")
     val oxchat = RelayUrlNormalizer.normalize("wss://relay.0xchat.com")
 
+    val news = RelayUrlNormalizer.normalize("wss://news.utxo.one")
+
     val purplepages = RelayUrlNormalizer.normalize("wss://purplepag.es")
     val coracle = RelayUrlNormalizer.normalize("wss://indexer.coracle.social")
     val userkinds = RelayUrlNormalizer.normalize("wss://user.kindpag.es")
+    val yabu = RelayUrlNormalizer.normalize("wss://directory.yabu.me")
+    val nostr1 = RelayUrlNormalizer.normalize("wss://profiles.nostr1.com")
 
-    val bootstrapInbox = setOf(band, damus, primal, mom, nos, bitcoiner, oxtr)
-    val eventFinderRelays = setOf(band, wine, damus, primal, mom, nos, bitcoiner, oxtr)
-
-    val defaultSearchRelaySet = setOf(band, wine, where)
+    val bootstrapInbox = setOf(damus, primal, mom, nos, bitcoiner, oxtr, yabu)
+    val eventFinderRelays = setOf(wine, damus, primal, mom, nos, bitcoiner, oxtr)
 }

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

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -45,6 +45,7 @@ import com.vitorpamplona.amethyst.commons.hashtags.Skull
 import com.vitorpamplona.amethyst.commons.hashtags.Tunestr
 import com.vitorpamplona.amethyst.commons.hashtags.Weed
 import com.vitorpamplona.amethyst.commons.hashtags.Zap
+import com.vitorpamplona.amethyst.commons.model.EmptyTagList
 import com.vitorpamplona.amethyst.commons.richtext.HashTagSegment
 import com.vitorpamplona.amethyst.commons.richtext.RegularTextSegment
 import com.vitorpamplona.amethyst.ui.components.HashTag
@@ -52,7 +53,6 @@ import com.vitorpamplona.amethyst.ui.components.RenderRegular
 import com.vitorpamplona.amethyst.ui.components.RenderTextParagraph
 import com.vitorpamplona.amethyst.ui.navigation.navs.EmptyNav
 import com.vitorpamplona.amethyst.ui.theme.ThemeComparisonColumn
-import com.vitorpamplona.quartz.nip01Core.core.EmptyTagList
 
 @Preview
 @Composable

amethyst/src/main/java/com/vitorpamplona/amethyst/model/LargeSoftCacheAddressExt.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -20,6 +20,7 @@
  */
 package com.vitorpamplona.amethyst.model
 
+import com.vitorpamplona.amethyst.commons.model.cache.LargeSoftCache
 import com.vitorpamplona.quartz.nip01Core.core.Address
 import com.vitorpamplona.quartz.nip01Core.core.HexKey
 import com.vitorpamplona.quartz.utils.cache.CacheCollectors
@@ -67,6 +68,18 @@ fun LargeSoftCache<Address, AddressableNote>.filter(
     consumer: CacheCollectors.BiFilter<Address, AddressableNote> = ACCEPT_ALL_FILTER,
 ): List<AddressableNote> = filter(kindStart(kind, pubKey), kindEnd(kind, pubKey), consumer)
 
+fun LargeSoftCache<Address, AddressableNote>.filter(
+    kinds: List<Int>,
+    pubKey: HexKey,
+    consumer: CacheCollectors.BiFilter<Address, AddressableNote> = ACCEPT_ALL_FILTER,
+): Set<AddressableNote> {
+    val set = mutableSetOf<AddressableNote>()
+    kinds.forEach {
+        set.addAll(filterIntoSet(kindStart(it, pubKey), kindEnd(it, pubKey), consumer))
+    }
+    return set
+}
+
 fun LargeSoftCache<Address, AddressableNote>.filterIntoSet(
     kind: Int,
     consumer: CacheCollectors.BiFilter<Address, AddressableNote> = ACCEPT_ALL_FILTER,

amethyst/src/main/java/com/vitorpamplona/amethyst/model/MediaAspectRatioCache.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -20,7 +20,7 @@
  */
 package com.vitorpamplona.amethyst.model
 
-import android.util.LruCache
+import androidx.collection.LruCache
 
 interface MutableMediaAspectRatioCache {
     fun get(url: String): Float?

amethyst/src/main/java/com/vitorpamplona/amethyst/model/MiniFhir.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -168,6 +168,7 @@ fun parseResourceBundleOrNull(json: String): FhirElementDatabase? {
                 is Bundle -> {
                     resource.entry.associateBy { it.id }.toImmutableMap()
                 }
+
                 else -> {
                     persistentMapOf(resource.id to resource)
                 }

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

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -22,8 +22,5 @@ package com.vitorpamplona.amethyst.model
 
 // Re-export from commons for backwards compatibility
 typealias Note = com.vitorpamplona.amethyst.commons.model.Note
-typealias NotesGatherer = com.vitorpamplona.amethyst.commons.model.NotesGatherer
 typealias AddressableNote = com.vitorpamplona.amethyst.commons.model.AddressableNote
-typealias NoteFlowSet = com.vitorpamplona.amethyst.commons.model.NoteFlowSet
-typealias NoteBundledRefresherFlow = com.vitorpamplona.amethyst.commons.model.NoteBundledRefresherFlow
 typealias NoteState = com.vitorpamplona.amethyst.commons.model.NoteState

amethyst/src/main/java/com/vitorpamplona/amethyst/model/ParticipantListBuilder.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

amethyst/src/main/java/com/vitorpamplona/amethyst/model/UiSettings.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -54,9 +54,7 @@ fun parseThemeType(code: Int?): ThemeType =
         ThemeType.SYSTEM.screenCode -> ThemeType.SYSTEM
         ThemeType.LIGHT.screenCode -> ThemeType.LIGHT
         ThemeType.DARK.screenCode -> ThemeType.DARK
-        else -> {
-            ThemeType.SYSTEM
-        }
+        else -> ThemeType.SYSTEM
     }
 
 enum class ConnectivityType(
@@ -91,9 +89,7 @@ fun parseConnectivityType(code: Boolean?): ConnectivityType =
         ConnectivityType.ALWAYS.prefCode -> ConnectivityType.ALWAYS
         ConnectivityType.WIFI_ONLY.prefCode -> ConnectivityType.WIFI_ONLY
         ConnectivityType.NEVER.prefCode -> ConnectivityType.NEVER
-        else -> {
-            ConnectivityType.ALWAYS
-        }
+        else -> ConnectivityType.ALWAYS
     }
 
 fun parseConnectivityType(screenCode: Int): ConnectivityType =
@@ -101,9 +97,7 @@ fun parseConnectivityType(screenCode: Int): ConnectivityType =
         ConnectivityType.ALWAYS.screenCode -> ConnectivityType.ALWAYS
         ConnectivityType.WIFI_ONLY.screenCode -> ConnectivityType.WIFI_ONLY
         ConnectivityType.NEVER.screenCode -> ConnectivityType.NEVER
-        else -> {
-            ConnectivityType.ALWAYS
-        }
+        else -> ConnectivityType.ALWAYS
     }
 
 fun parseFeatureSetType(screenCode: Int): FeatureSetType =
@@ -111,18 +105,14 @@ fun parseFeatureSetType(screenCode: Int): FeatureSetType =
         FeatureSetType.COMPLETE.screenCode -> FeatureSetType.COMPLETE
         FeatureSetType.SIMPLIFIED.screenCode -> FeatureSetType.SIMPLIFIED
         FeatureSetType.PERFORMANCE.screenCode -> FeatureSetType.PERFORMANCE
-        else -> {
-            FeatureSetType.COMPLETE
-        }
+        else -> FeatureSetType.COMPLETE
     }
 
 fun parseGalleryType(screenCode: Int): ProfileGalleryType =
     when (screenCode) {
         ProfileGalleryType.CLASSIC.screenCode -> ProfileGalleryType.CLASSIC
         ProfileGalleryType.MODERN.screenCode -> ProfileGalleryType.MODERN
-        else -> {
-            ProfileGalleryType.CLASSIC
-        }
+        else -> ProfileGalleryType.CLASSIC
     }
 
 enum class BooleanType(
@@ -138,18 +128,14 @@ fun parseBooleanType(code: Boolean?): BooleanType =
     when (code) {
         BooleanType.ALWAYS.prefCode -> BooleanType.ALWAYS
         BooleanType.NEVER.prefCode -> BooleanType.NEVER
-        else -> {
-            BooleanType.ALWAYS
-        }
+        else -> BooleanType.ALWAYS
     }
 
 fun parseBooleanType(screenCode: Int): BooleanType =
     when (screenCode) {
         BooleanType.ALWAYS.screenCode -> BooleanType.ALWAYS
         BooleanType.NEVER.screenCode -> BooleanType.NEVER
-        else -> {
-            BooleanType.ALWAYS
-        }
+        else -> BooleanType.ALWAYS
     }
 
 enum class WarningType(
@@ -167,9 +153,7 @@ fun parseWarningType(screenCode: Int): WarningType =
         WarningType.WARN.screenCode -> WarningType.WARN
         WarningType.SHOW.screenCode -> WarningType.SHOW
         WarningType.HIDE.screenCode -> WarningType.HIDE
-        else -> {
-            WarningType.WARN
-        }
+        else -> WarningType.WARN
     }
 
 fun parseWarningType(code: Boolean?): WarningType =
@@ -177,7 +161,5 @@ fun parseWarningType(code: Boolean?): WarningType =
         WarningType.WARN.prefCode -> WarningType.WARN
         WarningType.HIDE.prefCode -> WarningType.HIDE
         WarningType.SHOW.prefCode -> WarningType.SHOW
-        else -> {
-            WarningType.WARN
-        }
+        else -> WarningType.WARN
     }

amethyst/src/main/java/com/vitorpamplona/amethyst/model/UiSettingsFlow.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -20,10 +20,12 @@
  */
 package com.vitorpamplona.amethyst.model
 
+import androidx.compose.runtime.Stable
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.combine
 
+@Stable
 class UiSettingsFlow(
     val theme: MutableStateFlow<ThemeType> = MutableStateFlow(ThemeType.SYSTEM),
     val preferredLanguage: MutableStateFlow<String?> = MutableStateFlow(null),
@@ -149,19 +151,19 @@ class UiSettingsFlow(
     }
 
     companion object {
-        fun build(torSettings: UiSettings): UiSettingsFlow =
+        fun build(uiSettings: UiSettings): UiSettingsFlow =
             UiSettingsFlow(
-                MutableStateFlow(torSettings.theme),
-                MutableStateFlow(torSettings.preferredLanguage),
-                MutableStateFlow(torSettings.automaticallyShowImages),
-                MutableStateFlow(torSettings.automaticallyStartPlayback),
-                MutableStateFlow(torSettings.automaticallyShowUrlPreview),
-                MutableStateFlow(torSettings.automaticallyHideNavigationBars),
-                MutableStateFlow(torSettings.automaticallyShowProfilePictures),
-                MutableStateFlow(torSettings.dontShowPushNotificationSelector),
-                MutableStateFlow(torSettings.dontAskForNotificationPermissions),
-                MutableStateFlow(torSettings.featureSet),
-                MutableStateFlow(torSettings.gallerySet),
+                MutableStateFlow(uiSettings.theme),
+                MutableStateFlow(uiSettings.preferredLanguage),
+                MutableStateFlow(uiSettings.automaticallyShowImages),
+                MutableStateFlow(uiSettings.automaticallyStartPlayback),
+                MutableStateFlow(uiSettings.automaticallyShowUrlPreview),
+                MutableStateFlow(uiSettings.automaticallyHideNavigationBars),
+                MutableStateFlow(uiSettings.automaticallyShowProfilePictures),
+                MutableStateFlow(uiSettings.dontShowPushNotificationSelector),
+                MutableStateFlow(uiSettings.dontAskForNotificationPermissions),
+                MutableStateFlow(uiSettings.featureSet),
+                MutableStateFlow(uiSettings.gallerySet),
             )
     }
 }

amethyst/src/main/java/com/vitorpamplona/amethyst/model/UrlCachedPreviewer.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

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

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -21,9 +21,4 @@
 package com.vitorpamplona.amethyst.model
 
 // Re-export from commons for backwards compatibility
-typealias UserDependencies = com.vitorpamplona.amethyst.commons.model.UserDependencies
 typealias User = com.vitorpamplona.amethyst.commons.model.User
-typealias UserFlowSet = com.vitorpamplona.amethyst.commons.model.UserFlowSet
-typealias RelayInfo = com.vitorpamplona.amethyst.commons.model.RelayInfo
-typealias UserBundledRefresherFlow = com.vitorpamplona.amethyst.commons.model.UserBundledRefresherFlow
-typealias UserState = com.vitorpamplona.amethyst.commons.model.UserState

amethyst/src/main/java/com/vitorpamplona/amethyst/model/accountsCache/AccountCacheState.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -31,8 +31,9 @@ import com.vitorpamplona.quartz.nip01Core.core.toHexKey
 import com.vitorpamplona.quartz.nip01Core.relay.client.INostrClient
 import com.vitorpamplona.quartz.nip01Core.signers.NostrSigner
 import com.vitorpamplona.quartz.nip01Core.signers.NostrSignerInternal
-import com.vitorpamplona.quartz.nip03Timestamp.OtsResolverBuilder
+import com.vitorpamplona.quartz.nip03Timestamp.OtsResolver
 import com.vitorpamplona.quartz.nip55AndroidSigner.client.NostrSignerExternal
+import com.vitorpamplona.quartz.nip89AppHandlers.clientTag.NostrSignerWithClientTag
 import com.vitorpamplona.quartz.utils.Log
 import kotlinx.coroutines.CoroutineExceptionHandler
 import kotlinx.coroutines.CoroutineScope
@@ -44,10 +45,10 @@ import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.update
 
 class AccountCacheState(
-    val geolocationFlow: StateFlow<LocationState.LocationResult>,
-    val nwcFilterAssembler: NWCPaymentFilterAssembler,
+    val geolocationFlow: () -> StateFlow<LocationState.LocationResult>,
+    val nwcFilterAssembler: () -> NWCPaymentFilterAssembler,
     val contentResolverFn: () -> ContentResolver,
-    val otsResolverBuilder: OtsResolverBuilder,
+    val otsResolverBuilder: () -> OtsResolver,
     val cache: LocalCache,
     val client: INostrClient,
 ) {
@@ -68,13 +69,17 @@ class AccountCacheState(
                     NostrSignerInternal(accountSettings.keyPair)
                 } else {
                     when (val packageName = accountSettings.externalSignerPackageName) {
-                        null -> NostrSignerInternal(accountSettings.keyPair)
-                        else ->
+                        null -> {
+                            NostrSignerInternal(accountSettings.keyPair)
+                        }
+
+                        else -> {
                             NostrSignerExternal(
                                 pubKey = accountSettings.keyPair.pubKey.toHexKey(),
                                 packageName = packageName,
                                 contentResolver = contentResolverFn(),
                             )
+                        }
                     }
                 },
             accountSettings = accountSettings,
@@ -87,9 +92,11 @@ class AccountCacheState(
         val cached = accounts.value[signer.pubKey]
         if (cached != null) return cached
 
+        val signerWithClientTag = NostrSignerWithClientTag(signer, CLIENT_TAG_NAME)
+
         return Account(
             settings = accountSettings,
-            signer = signer,
+            signer = signerWithClientTag,
             geolocationFlow = geolocationFlow,
             nwcFilterAssembler = nwcFilterAssembler,
             otsResolverBuilder = otsResolverBuilder,
@@ -118,4 +125,8 @@ class AccountCacheState(
             emptyMap()
         }
     }
+
+    companion object {
+        const val CLIENT_TAG_NAME = "Amethyst"
+    }
 }

amethyst/src/main/java/com/vitorpamplona/amethyst/model/edits/PrivateStorageRelayListDecryptionCache.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

amethyst/src/main/java/com/vitorpamplona/amethyst/model/edits/PrivateStorageRelayListState.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -31,7 +31,6 @@ import com.vitorpamplona.quartz.utils.Log
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.DelicateCoroutinesApi
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.flowOn
@@ -92,9 +91,9 @@ class PrivateStorageRelayListState(
 
     init {
         settings.backupPrivateHomeRelayList?.let { event ->
-            Log.d("AccountRegisterObservers", "Loading saved private home relay list ${event.toJson()}")
+            Log.d("AccountRegisterObservers") { "Loading saved private home relay list ${event.toJson()}" }
             @OptIn(DelicateCoroutinesApi::class)
-            GlobalScope.launch(Dispatchers.IO) {
+            scope.launch(Dispatchers.IO) {
                 LocalCache.justConsumeMyOwnEvent(event)
             }
         }
@@ -102,7 +101,7 @@ class PrivateStorageRelayListState(
         scope.launch(Dispatchers.IO) {
             Log.d("AccountRegisterObservers", "Private Home Relay List Collector Start")
             getPrivateOutboxRelayListFlow().collect { noteState ->
-                Log.d("AccountRegisterObservers", "Updating Private Home Relay List for ${signer.pubKey}")
+                Log.d("AccountRegisterObservers") { "Updating Private Home Relay List for ${signer.pubKey}" }
                 (noteState.note.event as? PrivateOutboxRelayListEvent)?.let {
                     settings.updatePrivateHomeRelayList(it)
                 }

amethyst/src/main/java/com/vitorpamplona/amethyst/model/localRelays/LocalRelayListState.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip01UserMetadata/AccountHomeRelayState.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip01UserMetadata/AccountOutboxRelayState.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip01UserMetadata/NotificationInboxRelayState.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip01UserMetadata/UserMetadataState.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -22,15 +22,13 @@ package com.vitorpamplona.amethyst.model.nip01UserMetadata
 
 import com.vitorpamplona.amethyst.model.AccountSettings
 import com.vitorpamplona.amethyst.model.LocalCache
-import com.vitorpamplona.amethyst.model.UserState
 import com.vitorpamplona.quartz.nip01Core.metadata.MetadataEvent
 import com.vitorpamplona.quartz.nip01Core.signers.NostrSigner
+import com.vitorpamplona.quartz.nip39ExtIdentities.ExternalIdentitiesEvent
 import com.vitorpamplona.quartz.utils.Log
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.DelicateCoroutinesApi
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.launch
 
 class UserMetadataState(
@@ -42,11 +40,22 @@ class UserMetadataState(
     // Creates a long-term reference for this note so that the GC doesn't collect the note it self
     val user = cache.getOrCreateUser(signer.pubKey)
 
+    // Creates a long-term reference for this note so that the GC doesn't collect the note it self
+    val note = cache.getOrCreateAddressableNote(getMetadataEventAddress())
+
+    fun getMetadataEventAddress() = MetadataEvent.createAddress(signer.pubKey)
+
     // fun getEphemeralChatListAddress() = cache.getOrCreateUser(signer.pubKey)
 
-    fun getUserMetadataFlow(): StateFlow<UserState> = user.flow().metadata.stateFlow
+    fun getUserMetadataFlow() = note.flow().metadata.stateFlow
 
-    fun getUserMetadataEvent(): MetadataEvent? = user.latestMetadata
+    fun getUserMetadataEvent(): MetadataEvent? = note.event as? MetadataEvent
+
+    fun getIdentitiesEventAddress() = ExternalIdentitiesEvent.createAddress(signer.pubKey)
+
+    val identitiesNote = cache.getOrCreateAddressableNote(getIdentitiesEventAddress())
+
+    fun getExternalIdentitiesEvent(): ExternalIdentitiesEvent? = identitiesNote.event as? ExternalIdentitiesEvent
 
     suspend fun sendNewUserMetadata(
         name: String? = null,
@@ -59,9 +68,6 @@ class UserMetadataState(
         nip05: String? = null,
         lnAddress: String? = null,
         lnURL: String? = null,
-        twitter: String? = null,
-        mastodon: String? = null,
-        github: String? = null,
     ): MetadataEvent {
         val latest = getUserMetadataEvent()
 
@@ -79,9 +85,6 @@ class UserMetadataState(
                     nip05 = nip05,
                     lnAddress = lnAddress,
                     lnURL = lnURL,
-                    twitter = twitter,
-                    mastodon = mastodon,
-                    github = github,
                 )
             } else {
                 MetadataEvent.createNew(
@@ -95,6 +98,29 @@ class UserMetadataState(
                     nip05 = nip05,
                     lnAddress = lnAddress,
                     lnURL = lnURL,
+                )
+            }
+
+        return signer.sign(template)
+    }
+
+    suspend fun sendNewUserIdentities(
+        twitter: String? = null,
+        mastodon: String? = null,
+        github: String? = null,
+    ): ExternalIdentitiesEvent {
+        val latest = getExternalIdentitiesEvent()
+
+        val template =
+            if (latest != null) {
+                ExternalIdentitiesEvent.updateFromPast(
+                    latest = latest,
+                    twitter = twitter,
+                    mastodon = mastodon,
+                    github = github,
+                )
+            } else {
+                ExternalIdentitiesEvent.createNew(
                     twitter = twitter,
                     mastodon = mastodon,
                     github = github,
@@ -106,18 +132,20 @@ class UserMetadataState(
 
     init {
         settings.backupUserMetadata?.let {
-            Log.d("AccountRegisterObservers", "Loading saved user metadata ${it.toJson()}")
+            Log.d("AccountRegisterObservers") { "Loading saved user metadata ${it.toJson()}" }
 
             @OptIn(DelicateCoroutinesApi::class)
-            GlobalScope.launch(Dispatchers.IO) { LocalCache.justConsumeMyOwnEvent(it) }
+            scope.launch(Dispatchers.IO) { LocalCache.justConsumeMyOwnEvent(it) }
         }
 
         // saves contact list for the next time.
         scope.launch(Dispatchers.IO) {
             Log.d("AccountRegisterObservers", "Kind 0 Collector Start")
             getUserMetadataFlow().collect {
-                Log.d("AccountRegisterObservers", "Updating Kind 0 ${it.user.toBestDisplayName()}")
-                settings.updateUserMetadata(it.user.latestMetadata)
+                Log.d("AccountRegisterObservers") { "Updating Kind 0 ${user.toBestDisplayName()}" }
+                (it.note.event as? MetadataEvent)?.let {
+                    settings.updateUserMetadata(it)
+                }
             }
         }
     }

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip02FollowLists/DeclaredFollowsPerOutboxRelay.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip02FollowLists/DeclaredFollowsPerUsingRelay.kt

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2025 Vitor Pamplona
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+ * Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package com.vitorpamplona.amethyst.model.nip02FollowLists
+
+import com.vitorpamplona.amethyst.model.LocalCache
+import com.vitorpamplona.amethyst.model.topNavFeeds.UsingRelayUnwrapper
+import com.vitorpamplona.quartz.nip01Core.core.HexKey
+import com.vitorpamplona.quartz.nip01Core.relay.normalizer.NormalizedRelayUrl
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.emitAll
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.onStart
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.flow.transformLatest
+
+/**
+ * Computes a list of all declared relays for each user in the follow list.
+ */
+class DeclaredFollowsPerUsingRelay(
+    kind3Follows: Kind3FollowListState,
+    val cache: LocalCache,
+    scope: CoroutineScope,
+) {
+    val calculator = UsingRelayUnwrapper()
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    val flow: StateFlow<Map<NormalizedRelayUrl, Set<HexKey>>> =
+        kind3Follows.flow
+            .transformLatest {
+                emitAll(
+                    calculator.toUsersPerRelayFlow(it.authors, cache) { it },
+                )
+            }.onStart {
+                emit(
+                    calculator.usersPerRelaySnapshot(kind3Follows.flow.value.authors, cache) { it },
+                )
+            }.distinctUntilChanged()
+            .flowOn(Dispatchers.IO)
+            .stateIn(
+                scope,
+                SharingStarted.Eagerly,
+                emptyMap(),
+            )
+}

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip02FollowLists/FollowListOutboxOrProxyRelays.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip02FollowLists/FollowListReusedOutboxOrProxyRelays.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip02FollowLists/FollowsPerOutboxRelay.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip02FollowLists/Kind3FollowListState.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -21,10 +21,10 @@
 package com.vitorpamplona.amethyst.model.nip02FollowLists
 
 import androidx.compose.runtime.Immutable
+import com.vitorpamplona.amethyst.commons.model.NoteState
 import com.vitorpamplona.amethyst.model.AccountSettings
 import com.vitorpamplona.amethyst.model.LocalCache
 import com.vitorpamplona.amethyst.model.User
-import com.vitorpamplona.amethyst.model.UserState
 import com.vitorpamplona.quartz.nip01Core.core.HexKey
 import com.vitorpamplona.quartz.nip01Core.signers.NostrSigner
 import com.vitorpamplona.quartz.nip02FollowList.ContactListEvent
@@ -52,14 +52,19 @@ class Kind3FollowListState(
     // Creates a long-term reference for this note so that the GC doesn't collect the note it self
     val user = cache.getOrCreateUser(signer.pubKey)
 
-    fun getFollowListFlow(): StateFlow<UserState> = user.flow().follows.stateFlow
+    // Creates a long-term reference for this note so that the GC doesn't collect the note it self
+    val note = cache.getOrCreateAddressableNote(getFollowListAddress())
 
-    fun getFollowListEvent(): ContactListEvent? = user.latestContactList
+    fun getFollowListAddress() = ContactListEvent.createAddress(signer.pubKey)
+
+    fun getFollowListFlow(): StateFlow<NoteState> = note.flow().metadata.stateFlow
+
+    fun getFollowListEvent(): ContactListEvent? = note.event as? ContactListEvent
 
     @OptIn(ExperimentalCoroutinesApi::class)
     private val innerFlow: Flow<Kind3Follows> =
         getFollowListFlow().transformLatest {
-            emit(buildKind3Follows(it.user.latestContactList ?: settings.backupContactList))
+            emit(buildKind3Follows(it.note.event as? ContactListEvent ?: settings.backupContactList))
         }
 
     val flow =
@@ -108,6 +113,25 @@ class Kind3FollowListState(
         )
     }
 
+    suspend fun follow(users: List<User>): ContactListEvent {
+        val contactList = getFollowListEvent()
+
+        val contacts =
+            users.map {
+                ContactTag(it.pubkeyHex, it.bestRelayHint(), null)
+            }
+
+        return if (contactList != null) {
+            ContactListEvent.followUsers(contactList, contacts, signer)
+        } else {
+            ContactListEvent.createFromScratch(
+                followUsers = contacts,
+                relayUse = emptyMap(),
+                signer = signer,
+            )
+        }
+    }
+
     suspend fun follow(user: User): ContactListEvent {
         val contactList = getFollowListEvent()
 
@@ -138,7 +162,7 @@ class Kind3FollowListState(
 
     init {
         settings.backupContactList?.let {
-            Log.d("AccountRegisterObservers", "Loading saved ${it.tags.size} contacts")
+            Log.d("AccountRegisterObservers") { "Loading saved ${it.tags.size} contacts" }
 
             @OptIn(DelicateCoroutinesApi::class)
             scope.launch(Dispatchers.IO) { LocalCache.justConsumeMyOwnEvent(it) }
@@ -148,8 +172,10 @@ class Kind3FollowListState(
         scope.launch(Dispatchers.IO) {
             Log.d("AccountRegisterObservers", "Kind 3 Collector Start")
             getFollowListFlow().collect {
-                Log.d("AccountRegisterObservers", "Updating Kind 3 ${signer.pubKey}")
-                settings.updateContactListTo(it.user.latestContactList)
+                Log.d("AccountRegisterObservers") { "Updating Kind 3 ${signer.pubKey}" }
+                (it.note.event as? ContactListEvent)?.let {
+                    settings.updateContactListTo(it)
+                }
             }
         }
     }

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip03Timestamp/IncomingOtsEventVerifier.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -32,7 +32,7 @@ import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.stateIn
 
 class IncomingOtsEventVerifier(
-    private val otsVerifCache: VerificationStateCache,
+    private val otsVerifCache: () -> VerificationStateCache,
     private val cache: LocalCache,
     private val scope: CoroutineScope,
 ) {
@@ -52,7 +52,7 @@ class IncomingOtsEventVerifier(
     suspend fun consume(note: Note) {
         note.event?.let { event ->
             if (event is OtsEvent) {
-                otsVerifCache.cacheVerify(event)
+                otsVerifCache().cacheVerify(event)
             }
         }
     }

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip03Timestamp/OtsSettings.kt

@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2025 Vitor Pamplona
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+ * Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package com.vitorpamplona.amethyst.model.nip03Timestamp
+
+import androidx.compose.runtime.Stable
+import com.vitorpamplona.quartz.nip03Timestamp.okhttp.OkHttpBitcoinExplorer
+import kotlinx.serialization.Serializable
+
+/**
+ * Immutable data class representing the current OTS blockchain explorer config.
+ *
+ * When a custom URL is configured, it is used instead of the automatic
+ * Tor-aware selection (Mempool when Tor is active, Blockstream otherwise).
+ * This gives users control over which explorer observes their OTS verifications.
+ */
+@Serializable
+@Stable
+data class OtsSettings(
+    /**
+     * Custom blockchain explorer base API URL.
+     * When null/blank, the default Tor-aware selection is used.
+     * Must be a Mempool-compatible REST API (e.g. https://mempool.space/api/).
+     */
+    val customExplorerUrl: String? = null,
+) {
+    /** True when the user has configured a custom explorer URL. */
+    val hasCustomExplorer: Boolean get() = !customExplorerUrl.isNullOrBlank()
+
+    /**
+     * Returns the normalized custom URL (trailing slash ensured) or null if not set.
+     */
+    fun normalizedUrl(): String? {
+        val url = customExplorerUrl?.trim()?.takeIf { it.isNotBlank() } ?: return null
+        return if (url.endsWith("/")) url else "$url/"
+    }
+
+    companion object {
+        val DEFAULT = OtsSettings()
+
+        val KNOWN_EXPLORERS =
+            listOf(
+                OkHttpBitcoinExplorer.MEMPOOL_API_URL to "mempool.space (Tor-friendly)",
+                OkHttpBitcoinExplorer.BLOCKSTREAM_API_URL to "blockstream.info",
+            )
+
+        fun isValidUrl(url: String): Boolean {
+            val trimmed = url.trim()
+            if (trimmed.isBlank()) return false
+            return trimmed.startsWith("http://") || trimmed.startsWith("https://")
+        }
+    }
+}

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip03Timestamp/OtsState.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -26,7 +26,7 @@ import com.vitorpamplona.amethyst.model.Note
 import com.vitorpamplona.quartz.nip01Core.core.Event
 import com.vitorpamplona.quartz.nip01Core.signers.NostrSigner
 import com.vitorpamplona.quartz.nip03Timestamp.OtsEvent
-import com.vitorpamplona.quartz.nip03Timestamp.OtsResolverBuilder
+import com.vitorpamplona.quartz.nip03Timestamp.OtsResolver
 import com.vitorpamplona.quartz.utils.Log
 import com.vitorpamplona.quartz.utils.TimeUtils
 import kotlinx.coroutines.CoroutineScope
@@ -37,7 +37,7 @@ import java.util.Base64
 class OtsState(
     val signer: NostrSigner,
     val cache: LocalCache,
-    val otsResolver: OtsResolverBuilder,
+    val otsResolver: () -> OtsResolver,
     val scope: CoroutineScope,
     val settings: AccountSettings,
 ) {
@@ -55,10 +55,10 @@ class OtsState(
     }
 
     suspend fun updateAttestations(): List<OtsEvent> {
-        Log.d("Pending Attestations", "Updating ${settings.pendingAttestations.value.size} pending attestations")
+        Log.d("Pending Attestations") { "Updating ${settings.pendingAttestations.value.size} pending attestations" }
 
         return settings.pendingAttestations.value.toList().mapNotNull { (key, value) ->
-            val otsState = OtsEvent.upgrade(Base64.getDecoder().decode(value), key, otsResolver.build())
+            val otsState = OtsEvent.upgrade(Base64.getDecoder().decode(value), key, otsResolver())
 
             if (otsState != null) {
                 val hint = cache.getNoteIfExists(key)?.toEventHint<Event>()
@@ -96,7 +96,7 @@ class OtsState(
                 Base64.getEncoder().encodeToString(
                     OtsEvent.stamp(
                         id,
-                        otsResolver.build(),
+                        otsResolver(),
                     ),
                 ),
         )

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip03Timestamp/TorAwareOkHttpOtsResolverBuilder.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -31,22 +31,24 @@ class TorAwareOkHttpOtsResolverBuilder(
     val okHttpClient: (url: String) -> OkHttpClient,
     val isTorActive: (url: String) -> Boolean,
     val cache: OtsBlockHeightCache,
+    val customExplorerUrl: () -> String? = { null },
 ) : OtsResolverBuilder {
-    fun getAPI(usingTor: Boolean) =
-        if (usingTor) {
-            OkHttpBitcoinExplorer.Companion.MEMPOOL_API_URL
-        } else {
-            OkHttpBitcoinExplorer.Companion.BLOCKSTREAM_API_URL
-        }
+    fun getAPI(usingTor: Boolean): String =
+        customExplorerUrl()
+            ?: if (usingTor) {
+                OkHttpBitcoinExplorer.MEMPOOL_API_URL
+            } else {
+                OkHttpBitcoinExplorer.BLOCKSTREAM_API_URL
+            }
 
     override fun build(): OtsResolver =
         OtsResolver(
             explorer =
                 OkHttpBitcoinExplorer(
                     baseUrl = {
-                        getAPI(usingTor = isTorActive(OkHttpBitcoinExplorer.Companion.MEMPOOL_API_URL))
+                        getAPI(usingTor = isTorActive(OkHttpBitcoinExplorer.MEMPOOL_API_URL))
                     },
-                    client = okHttpClient(OkHttpBitcoinExplorer.Companion.MEMPOOL_API_URL),
+                    client = okHttpClient(OkHttpBitcoinExplorer.MEMPOOL_API_URL),
                     cache = cache,
                 ),
             calendar = OkHttpCalendar(okHttpClient),

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip11RelayInfo/LoadRelayInfo.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -46,7 +46,7 @@ fun loadRelayInfo(
                 value = it
             },
             onError = { url, errorCode, exceptionMessage ->
-                Log.e("RelayInfo", "Error loading relay info for ${relay.url}: $errorCode - $exceptionMessage")
+                Log.e("RelayInfo") { "Error loading relay info for ${relay.url}: $errorCode - $exceptionMessage" }
             },
         )
     }

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip11RelayInfo/Nip11CachedRetriever.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -21,12 +21,14 @@
 package com.vitorpamplona.amethyst.model.nip11RelayInfo
 
 import android.util.LruCache
+import androidx.compose.runtime.Stable
 import com.vitorpamplona.quartz.nip01Core.relay.normalizer.NormalizedRelayUrl
 import com.vitorpamplona.quartz.nip01Core.relay.normalizer.displayUrl
 import com.vitorpamplona.quartz.nip01Core.relay.normalizer.toHttp
 import com.vitorpamplona.quartz.nip11RelayInfo.Nip11RelayInformation
 import okhttp3.OkHttpClient
 
+@Stable
 class Nip11CachedRetriever(
     val okHttpClient: (NormalizedRelayUrl) -> OkHttpClient,
 ) {
@@ -74,7 +76,10 @@ class Nip11CachedRetriever(
         val doc = relayInformationDocumentCache.get(relay)
         if (doc != null) {
             when (doc) {
-                is RetrieveResult.Success -> onInfo(doc.data)
+                is RetrieveResult.Success -> {
+                    onInfo(doc.data)
+                }
+
                 is RetrieveResult.Loading -> {
                     if (doc.isValid()) {
                         // just wait.
@@ -82,6 +87,7 @@ class Nip11CachedRetriever(
                         retrieve(relay, onInfo, onError)
                     }
                 }
+
                 is RetrieveResult.Error -> {
                     if (doc.isValid()) {
                         onError(relay, doc.error, null)
@@ -89,7 +95,10 @@ class Nip11CachedRetriever(
                         retrieve(relay, onInfo, onError)
                     }
                 }
-                is RetrieveResult.Empty -> retrieve(relay, onInfo, onError)
+
+                is RetrieveResult.Empty -> {
+                    retrieve(relay, onInfo, onError)
+                }
             }
         } else {
             retrieve(relay, onInfo, onError)

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip11RelayInfo/Nip11Retriever.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip11RelayInfo/RetrieveResult.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip17Dms/DmInboxRelayState.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip17Dms/DmRelayListState.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -31,7 +31,6 @@ import com.vitorpamplona.quartz.utils.Log
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.DelicateCoroutinesApi
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.flowOn
@@ -89,9 +88,9 @@ class DmRelayListState(
 
     init {
         settings.backupDMRelayList?.let {
-            Log.d("AccountRegisterObservers", "Loading saved DM Relay List ${it.toJson()}")
+            Log.d("AccountRegisterObservers") { "Loading saved DM Relay List ${it.toJson()}" }
             @OptIn(DelicateCoroutinesApi::class)
-            GlobalScope.launch(Dispatchers.IO) {
+            scope.launch(Dispatchers.IO) {
                 LocalCache.justConsumeMyOwnEvent(it)
             }
         }
@@ -99,7 +98,7 @@ class DmRelayListState(
         scope.launch(Dispatchers.IO) {
             Log.d("AccountRegisterObservers", "NIP-17 Relay List Collector Start")
             getDMRelayListFlow().collect {
-                Log.d("AccountRegisterObservers", "Updating DM Relay List for ${signer.pubKey}")
+                Log.d("AccountRegisterObservers") { "Updating DM Relay List for ${signer.pubKey}" }
                 (it.note.event as? ChatMessageRelayListEvent)?.let {
                     settings.updateDMRelayList(it)
                 }

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip47WalletConnect/NwcSignerState.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -21,26 +21,27 @@
 package com.vitorpamplona.amethyst.model.nip47WalletConnect
 
 import com.vitorpamplona.amethyst.commons.model.INwcSignerState
-import com.vitorpamplona.amethyst.model.AccountSettings
 import com.vitorpamplona.amethyst.model.LocalCache
 import com.vitorpamplona.amethyst.model.Note
 import com.vitorpamplona.amethyst.service.relayClient.reqCommand.nwc.NWCPaymentFilterAssembler
 import com.vitorpamplona.amethyst.service.relayClient.reqCommand.nwc.NWCPaymentQueryState
+import com.vitorpamplona.quartz.nip01Core.core.HexKey
 import com.vitorpamplona.quartz.nip01Core.core.hexToByteArray
 import com.vitorpamplona.quartz.nip01Core.crypto.KeyPair
 import com.vitorpamplona.quartz.nip01Core.relay.normalizer.NormalizedRelayUrl
 import com.vitorpamplona.quartz.nip01Core.signers.NostrSigner
 import com.vitorpamplona.quartz.nip01Core.signers.NostrSignerInternal
-import com.vitorpamplona.quartz.nip47WalletConnect.LnZapPaymentRequestEvent
-import com.vitorpamplona.quartz.nip47WalletConnect.LnZapPaymentResponseEvent
 import com.vitorpamplona.quartz.nip47WalletConnect.Nip47WalletConnect
-import com.vitorpamplona.quartz.nip47WalletConnect.NostrWalletConnectRequestCache
-import com.vitorpamplona.quartz.nip47WalletConnect.NostrWalletConnectResponseCache
-import com.vitorpamplona.quartz.nip47WalletConnect.Request
-import com.vitorpamplona.quartz.nip47WalletConnect.Response
+import com.vitorpamplona.quartz.nip47WalletConnect.cache.NostrWalletConnectRequestCache
+import com.vitorpamplona.quartz.nip47WalletConnect.cache.NostrWalletConnectResponseCache
+import com.vitorpamplona.quartz.nip47WalletConnect.events.LnZapPaymentRequestEvent
+import com.vitorpamplona.quartz.nip47WalletConnect.events.LnZapPaymentResponseEvent
+import com.vitorpamplona.quartz.nip47WalletConnect.rpc.Request
+import com.vitorpamplona.quartz.nip47WalletConnect.rpc.Response
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.map
@@ -59,14 +60,14 @@ import kotlinx.coroutines.launch
  * @property signer the main Nostr signer used for general Nostr operations
  * @property cache the local cache for handling notes and events
  * @property scope the coroutine scope used for async operations
- * @property settings the account settings containing NIP-47 configuration
+ * @property nip47Setup the NIP-47 configuration
  */
 class NwcSignerState(
     val signer: NostrSigner,
-    val nwcFilterAssembler: NWCPaymentFilterAssembler,
+    val nwcFilterAssembler: () -> NWCPaymentFilterAssembler,
     val cache: LocalCache,
     val scope: CoroutineScope,
-    val settings: AccountSettings,
+    val nip47Setup: MutableStateFlow<Nip47WalletConnect.Nip47URINorm?>,
 ) : INwcSignerState {
     /**
      * Derives a NIP-47 signer from the zap payment request in settings.
@@ -74,14 +75,14 @@ class NwcSignerState(
      * Flows updates whenever settings change.
      */
     val nip47Signer =
-        settings.zapPaymentRequest
+        nip47Setup
             .map {
                 buildSigner(it) ?: signer
             }.flowOn(Dispatchers.IO)
             .stateIn(
                 scope,
                 SharingStarted.Eagerly,
-                buildSigner(settings.zapPaymentRequest.value) ?: signer,
+                buildSigner(nip47Setup.value) ?: signer,
             )
 
     /**
@@ -111,30 +112,71 @@ class NwcSignerState(
             NostrSignerInternal(KeyPair(it))
         }
 
-    fun hasWalletConnectSetup(): Boolean = settings.zapPaymentRequest.value != null
+    fun hasWalletConnectSetup(): Boolean = nip47Setup.value != null
 
-    override fun isNIP47Author(pubkeyHex: String?): Boolean = nip47Signer.value.pubKey == pubkeyHex
+    override fun isNIP47Author(pubKey: HexKey?): Boolean = nip47Signer.value.pubKey == pubKey
 
     /**
      * Decrypts a NIP-47 payment request using the current signer.
      *
-     * @param nwcRequest the NIP-47 payment request event to decrypt
+     * @param event the NIP-47 payment request event to decrypt
      * @return the decrypted request or null if not set up or decryption fails
      */
-    override suspend fun decryptRequest(nwcRequest: LnZapPaymentRequestEvent): Request? {
+    override suspend fun decryptRequest(event: LnZapPaymentRequestEvent): Request? {
         if (!hasWalletConnectSetup()) return null
-        return zapPaymentRequestDecryptionCache.value.decryptRequest(nwcRequest)
+        return zapPaymentRequestDecryptionCache.value.decryptRequest(event)
     }
 
     /**
      * Decrypts a NIP-47 payment response using the current signer.
      *
-     * @param nwsResponse the NIP-47 payment response event to decrypt
+     * @param event the NIP-47 payment response event to decrypt
      * @return the decrypted response or null if not set up or decryption fails
      */
-    override suspend fun decryptResponse(nwsResponse: LnZapPaymentResponseEvent): Response? {
+    override suspend fun decryptResponse(event: LnZapPaymentResponseEvent): Response? {
         if (!hasWalletConnectSetup()) return null
-        return zapPaymentResponseDecryptionCache.value.decryptResponse(nwsResponse)
+        return zapPaymentResponseDecryptionCache.value.decryptResponse(event)
+    }
+
+    /**
+     * Sends a generic NIP-47 request to the connected wallet.
+     * Subscribes to responses and waits up to 60s for a reply.
+     *
+     * @param request the NIP-47 request to send
+     * @param onResponse callback to handle the response from the wallet
+     * @return a pair containing the request event and target relay URL
+     * @throws IllegalArgumentException if no NIP-47 wallet is set up
+     */
+    suspend fun sendNwcRequest(
+        request: Request,
+        onResponse: (Response?) -> Unit,
+    ): Pair<LnZapPaymentRequestEvent, NormalizedRelayUrl> {
+        val walletService = nip47Setup.value ?: throw IllegalArgumentException("No NIP47 setup")
+
+        val event = LnZapPaymentRequestEvent.createRequest(request, walletService.pubKeyHex, nip47Signer.value)
+
+        val filter =
+            NWCPaymentQueryState(
+                fromServiceHex = walletService.pubKeyHex,
+                toUserHex = event.pubKey,
+                replyingToHex = event.id,
+                relay = walletService.relayUri,
+            )
+
+        val assembler = nwcFilterAssembler()
+
+        assembler.subscribe(filter)
+
+        scope.launch(Dispatchers.IO) {
+            delay(60000)
+            assembler.unsubscribe(filter)
+        }
+
+        cache.consume(event, null, true, walletService.relayUri) {
+            onResponse(decryptResponse(it))
+        }
+
+        return Pair(event, walletService.relayUri)
     }
 
     /**
@@ -152,8 +194,7 @@ class NwcSignerState(
         zappedNote: Note?,
         onResponse: (Response?) -> Unit,
     ): Pair<LnZapPaymentRequestEvent, NormalizedRelayUrl> {
-        val walletService = settings.zapPaymentRequest.value
-        if (walletService == null) throw IllegalArgumentException("No NIP47 setup")
+        val walletService = nip47Setup.value ?: throw IllegalArgumentException("No NIP47 setup")
 
         val event = LnZapPaymentRequestEvent.create(bolt11, walletService.pubKeyHex, nip47Signer.value)
 
@@ -165,11 +206,13 @@ class NwcSignerState(
                 relay = walletService.relayUri,
             )
 
-        nwcFilterAssembler.subscribe(filter)
+        val assembler = nwcFilterAssembler()
+
+        assembler.subscribe(filter)
 
         scope.launch(Dispatchers.IO) {
             delay(60000) // waits 1 minute to complete payment.
-            nwcFilterAssembler.unsubscribe(filter)
+            assembler.unsubscribe(filter)
         }
 
         cache.consume(event, zappedNote, true, walletService.relayUri) {

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip51Lists/BookmarkListState.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -20,282 +20,6 @@
  */
 package com.vitorpamplona.amethyst.model.nip51Lists
 
-import androidx.compose.runtime.Stable
-import com.vitorpamplona.amethyst.model.AddressableNote
-import com.vitorpamplona.amethyst.model.LocalCache
-import com.vitorpamplona.amethyst.model.Note
-import com.vitorpamplona.amethyst.model.NoteState
-import com.vitorpamplona.quartz.nip01Core.signers.NostrSigner
-import com.vitorpamplona.quartz.nip51Lists.bookmarkList.BookmarkListEvent
-import com.vitorpamplona.quartz.nip51Lists.bookmarkList.tags.AddressBookmark
-import com.vitorpamplona.quartz.nip51Lists.bookmarkList.tags.BookmarkIdTag
-import com.vitorpamplona.quartz.nip51Lists.bookmarkList.tags.EventBookmark
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.FlowPreview
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.combineTransform
-import kotlinx.coroutines.flow.debounce
-import kotlinx.coroutines.flow.flowOn
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.onStart
-import kotlinx.coroutines.flow.stateIn
+typealias BookmarkListState = com.vitorpamplona.amethyst.commons.model.nip51Lists.BookmarkListState
 
-@Stable
-class BookmarkListState(
-    val signer: NostrSigner,
-    val cache: LocalCache,
-    val scope: CoroutineScope,
-) {
-    class BookmarkList(
-        val public: List<Note> = emptyList(),
-        val private: List<Note> = emptyList(),
-    )
-
-    // Creates a long-term reference for this note so that the GC doesn't collect the note it self
-    val bookmarkList = cache.getOrCreateAddressableNote(getBookmarkListAddress())
-
-    fun getBookmarkListAddress() = BookmarkListEvent.createBookmarkAddress(signer.pubKey)
-
-    fun getBookmarkListFlow(): StateFlow<NoteState> = bookmarkList.flow().metadata.stateFlow
-
-    fun getBookmarkList(): BookmarkListEvent? = bookmarkList.event as? BookmarkListEvent
-
-    suspend fun publicBookmarks(note: Note): List<BookmarkIdTag> {
-        val noteEvent = note.event as? BookmarkListEvent
-        return noteEvent?.publicBookmarks() ?: emptyList()
-    }
-
-    suspend fun privateBookmarks(note: Note): List<BookmarkIdTag> {
-        val noteEvent = note.event as? BookmarkListEvent
-        return noteEvent?.privateBookmarks(signer) ?: emptyList()
-    }
-
-    @OptIn(FlowPreview::class)
-    val publicBookmarks: StateFlow<List<BookmarkIdTag>> =
-        getBookmarkListFlow()
-            .map { noteState ->
-                publicBookmarks(noteState.note)
-            }.onStart {
-                emit(publicBookmarks(bookmarkList))
-            }.debounce(100)
-            .flowOn(Dispatchers.IO)
-            .stateIn(
-                scope,
-                SharingStarted.Eagerly,
-                emptyList(),
-            )
-
-    @OptIn(FlowPreview::class)
-    val privateBookmarks: StateFlow<List<BookmarkIdTag>> =
-        getBookmarkListFlow()
-            .map { noteState ->
-                privateBookmarks(noteState.note)
-            }.onStart {
-                emit(privateBookmarks(bookmarkList))
-            }.debounce(100)
-            .flowOn(Dispatchers.IO)
-            .stateIn(
-                scope,
-                SharingStarted.Eagerly,
-                emptyList(),
-            )
-
-    val publicBookmarkEventIdSet =
-        publicBookmarks
-            .map { bookmark ->
-                bookmark
-                    .mapNotNull {
-                        if (it is EventBookmark) it.eventId else null
-                    }.toSet()
-            }.flowOn(Dispatchers.IO)
-            .stateIn(
-                scope,
-                SharingStarted.Eagerly,
-                emptyList(),
-            )
-
-    val publicBookmarkAddressIdSet =
-        publicBookmarks
-            .map { bookmark ->
-                bookmark
-                    .mapNotNull {
-                        if (it is AddressBookmark) it.address else null
-                    }.toSet()
-            }.flowOn(Dispatchers.IO)
-            .stateIn(
-                scope,
-                SharingStarted.Eagerly,
-                emptyList(),
-            )
-
-    val privateBookmarkEventIdSet =
-        privateBookmarks
-            .map { bookmark ->
-                bookmark
-                    .mapNotNull {
-                        if (it is EventBookmark) it.eventId else null
-                    }.toSet()
-            }.flowOn(Dispatchers.IO)
-            .stateIn(
-                scope,
-                SharingStarted.Eagerly,
-                emptyList(),
-            )
-
-    val privateBookmarkAddressIdSet =
-        privateBookmarks
-            .map { bookmark ->
-                bookmark
-                    .mapNotNull {
-                        if (it is AddressBookmark) it.address else null
-                    }.toSet()
-            }.flowOn(Dispatchers.IO)
-            .stateIn(
-                scope,
-                SharingStarted.Eagerly,
-                emptyList(),
-            )
-
-    fun bookmarkList(
-        privateBookmarks: List<BookmarkIdTag>,
-        publicBookmarks: List<BookmarkIdTag>,
-    ): BookmarkList =
-        BookmarkList(
-            public =
-                publicBookmarks
-                    .mapNotNull {
-                        when (it) {
-                            is EventBookmark -> cache.checkGetOrCreateNote(it.eventId)
-                            is AddressBookmark -> cache.getOrCreateAddressableNote(it.address)
-                        }
-                    }.reversed(),
-            private =
-                privateBookmarks
-                    .mapNotNull {
-                        when (it) {
-                            is EventBookmark -> cache.checkGetOrCreateNote(it.eventId)
-                            is AddressBookmark -> cache.getOrCreateAddressableNote(it.address)
-                        }
-                    }.reversed(),
-        )
-
-    @OptIn(FlowPreview::class)
-    val bookmarks: StateFlow<BookmarkList> =
-        combineTransform(privateBookmarks, publicBookmarks) { private, public ->
-            emit(bookmarkList(private, public))
-        }.onStart {
-            emit(bookmarkList(privateBookmarks.value, publicBookmarks.value))
-        }.flowOn(Dispatchers.IO)
-            .stateIn(
-                scope,
-                SharingStarted.Eagerly,
-                BookmarkList(),
-            )
-
-    fun isInPrivateBookmarks(note: Note): Boolean {
-        if (!signer.isWriteable()) return false
-
-        return if (note is AddressableNote) {
-            privateBookmarkAddressIdSet.value.contains(note.address)
-        } else {
-            privateBookmarkEventIdSet.value.contains(note.idHex)
-        }
-    }
-
-    fun isInPublicBookmarks(note: Note): Boolean =
-        if (note is AddressableNote) {
-            publicBookmarkAddressIdSet.value.contains(note.address)
-        } else {
-            publicBookmarkEventIdSet.value.contains(note.idHex)
-        }
-
-    suspend fun addBookmark(
-        note: Note,
-        isPrivate: Boolean,
-    ): BookmarkListEvent {
-        val bookmarkList = getBookmarkList()
-
-        return if (bookmarkList == null) {
-            if (note is AddressableNote) {
-                BookmarkListEvent.create(
-                    bookmarkIdTag = AddressBookmark(note.address, note.relayHintUrl()),
-                    isPrivate = isPrivate,
-                    signer = signer,
-                )
-            } else {
-                BookmarkListEvent.create(
-                    bookmarkIdTag = EventBookmark(note.idHex, note.relayHintUrl()),
-                    isPrivate = isPrivate,
-                    signer = signer,
-                )
-            }
-        } else {
-            if (note is AddressableNote) {
-                BookmarkListEvent.add(
-                    earlierVersion = bookmarkList,
-                    bookmarkIdTag = AddressBookmark(note.address, note.relayHintUrl()),
-                    isPrivate = isPrivate,
-                    signer = signer,
-                )
-            } else {
-                BookmarkListEvent.add(
-                    earlierVersion = bookmarkList,
-                    bookmarkIdTag = EventBookmark(note.idHex, note.relayHintUrl()),
-                    isPrivate = isPrivate,
-                    signer = signer,
-                )
-            }
-        }
-    }
-
-    suspend fun removeBookmark(
-        note: Note,
-        isPrivate: Boolean,
-    ): BookmarkListEvent? {
-        val bookmarkList = getBookmarkList()
-
-        return if (bookmarkList != null) {
-            if (note is AddressableNote) {
-                BookmarkListEvent.remove(
-                    earlierVersion = bookmarkList,
-                    bookmarkIdTag = AddressBookmark(note.address, note.relayHintUrl()),
-                    isPrivate = isPrivate,
-                    signer = signer,
-                )
-            } else {
-                BookmarkListEvent.remove(
-                    earlierVersion = bookmarkList,
-                    bookmarkIdTag = EventBookmark(note.idHex, note.relayHintUrl()),
-                    isPrivate = isPrivate,
-                    signer = signer,
-                )
-            }
-        } else {
-            null
-        }
-    }
-
-    suspend fun removeBookmark(note: Note): BookmarkListEvent? {
-        val bookmarkList = getBookmarkList()
-
-        return if (bookmarkList != null) {
-            if (note is AddressableNote) {
-                BookmarkListEvent.remove(
-                    earlierVersion = bookmarkList,
-                    bookmarkIdTag = AddressBookmark(note.address, note.relayHintUrl()),
-                    signer = signer,
-                )
-            } else {
-                BookmarkListEvent.remove(
-                    earlierVersion = bookmarkList,
-                    bookmarkIdTag = EventBookmark(note.idHex, note.relayHintUrl()),
-                    signer = signer,
-                )
-            }
-        } else {
-            null
-        }
-    }
-}
+typealias OldBookmarkListState = com.vitorpamplona.amethyst.commons.model.nip51Lists.OldBookmarkListState

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip51Lists/HiddenUsersState.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -47,7 +47,7 @@ class HiddenUsersState(
 ) {
     var transientHiddenUsers: MutableStateFlow<Set<String>> = MutableStateFlow(setOf())
 
-    suspend fun assembleLiveHiddenUsers(
+    fun assembleLiveHiddenUsers(
         blockList: List<MuteTag>,
         muteList: List<MuteTag>,
         transientHiddenUsers: Set<String>,

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip51Lists/PinListState.kt

@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2025 Vitor Pamplona
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+ * Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package com.vitorpamplona.amethyst.model.nip51Lists
+
+import androidx.compose.runtime.Stable
+import com.vitorpamplona.amethyst.model.LocalCache
+import com.vitorpamplona.amethyst.model.Note
+import com.vitorpamplona.amethyst.model.NoteState
+import com.vitorpamplona.quartz.nip01Core.signers.NostrSigner
+import com.vitorpamplona.quartz.nip51Lists.PinListEvent
+import com.vitorpamplona.quartz.nip51Lists.bookmarkList.tags.EventBookmark
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.FlowPreview
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.debounce
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.onStart
+import kotlinx.coroutines.flow.stateIn
+
+@Stable
+class PinListState(
+    val signer: NostrSigner,
+    val cache: LocalCache,
+    val scope: CoroutineScope,
+) {
+    val pinList = cache.getOrCreateAddressableNote(PinListEvent.createPinAddress(signer.pubKey))
+
+    fun getPinListFlow(): StateFlow<NoteState> = pinList.flow().metadata.stateFlow
+
+    fun getPinList(): PinListEvent? = pinList.event as? PinListEvent
+
+    fun pinnedEvents(note: Note): List<EventBookmark> {
+        val noteEvent = note.event as? PinListEvent
+        return noteEvent?.pinnedEvents() ?: emptyList()
+    }
+
+    @OptIn(FlowPreview::class)
+    val pinnedNotes: StateFlow<List<EventBookmark>> =
+        getPinListFlow()
+            .map { noteState ->
+                pinnedEvents(noteState.note)
+            }.onStart {
+                emit(pinnedEvents(pinList))
+            }.debounce(100)
+            .flowOn(Dispatchers.IO)
+            .stateIn(
+                scope,
+                SharingStarted.Eagerly,
+                emptyList(),
+            )
+
+    val pinnedEventIdSet: StateFlow<Set<String>> =
+        pinnedNotes
+            .map { pins ->
+                pins.map { it.eventId }.toSet()
+            }.flowOn(Dispatchers.IO)
+            .stateIn(
+                scope,
+                SharingStarted.Eagerly,
+                emptySet(),
+            )
+
+    @OptIn(FlowPreview::class)
+    val pinnedNotesList: StateFlow<List<Note>> =
+        pinnedNotes
+            .map { pins ->
+                pins.mapNotNull { cache.checkGetOrCreateNote(it.eventId) }.reversed()
+            }.onStart {
+                emit(
+                    pinnedNotes.value.mapNotNull { cache.checkGetOrCreateNote(it.eventId) }.reversed(),
+                )
+            }.flowOn(Dispatchers.IO)
+            .stateIn(
+                scope,
+                SharingStarted.Eagerly,
+                emptyList(),
+            )
+
+    fun isPinned(note: Note): Boolean = pinnedEventIdSet.value.contains(note.idHex)
+
+    suspend fun addPin(note: Note): PinListEvent {
+        val currentList = getPinList()
+        val pin = EventBookmark(note.idHex, note.relayHintUrl())
+
+        return if (currentList == null) {
+            PinListEvent.create(
+                pin = pin,
+                signer = signer,
+            )
+        } else {
+            PinListEvent.add(
+                earlierVersion = currentList,
+                pin = pin,
+                signer = signer,
+            )
+        }
+    }
+
+    suspend fun removePin(note: Note): PinListEvent? {
+        val currentList = getPinList() ?: return null
+        val pin = EventBookmark(note.idHex, note.relayHintUrl())
+
+        return PinListEvent.remove(
+            earlierVersion = currentList,
+            pin = pin,
+            signer = signer,
+        )
+    }
+}

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip51Lists/blockPeopleList/BlockPeopleListState.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -81,7 +81,7 @@ class BlockPeopleListState(
             )
         } else {
             PeopleListEvent.create(
-                name = PeopleListEvent.BLOCK_LIST_D_TAG,
+                title = PeopleListEvent.BLOCK_LIST_D_TAG,
                 person = UserTag(pubkeyHex),
                 isPrivate = true,
                 signer = signer,

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip51Lists/blockedRelays/BlockedRelayListDecryptionCache.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip51Lists/blockedRelays/BlockedRelayListState.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -32,7 +32,6 @@ import com.vitorpamplona.quartz.utils.Log
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.DelicateCoroutinesApi
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.flowOn
@@ -94,15 +93,15 @@ class BlockedRelayListState(
 
     init {
         settings.backupBlockedRelayList?.let {
-            Log.d("AccountRegisterObservers", "Loading saved Blocked relay list ${it.toJson()}")
+            Log.d("AccountRegisterObservers") { "Loading saved Blocked relay list ${it.toJson()}" }
             @OptIn(DelicateCoroutinesApi::class)
-            GlobalScope.launch(Dispatchers.IO) { LocalCache.justConsumeMyOwnEvent(it) }
+            scope.launch(Dispatchers.IO) { LocalCache.justConsumeMyOwnEvent(it) }
         }
 
         scope.launch(Dispatchers.IO) {
             Log.d("AccountRegisterObservers", "Blocked Relay List Collector Start")
             getBlockedRelayListFlow().collect {
-                Log.d("AccountRegisterObservers", "Updating Blocked Relay List for ${signer.pubKey}")
+                Log.d("AccountRegisterObservers") { "Updating Blocked Relay List for ${signer.pubKey}" }
                 (it.note.event as? BlockedRelayListEvent)?.let {
                     settings.updateBlockedRelayList(it)
                 }

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip51Lists/broadcastRelays/BroadcastRelayListDecryptionCache.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip51Lists/broadcastRelays/BroadcastRelayListState.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip51Lists/geohashLists/GeohashListCard.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip51Lists/geohashLists/GeohashListDecryptionCache.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of

amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip51Lists/geohashLists/GeohashListState.kt

@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2025 Vitor Pamplona
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -31,7 +31,6 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.DelicateCoroutinesApi
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.flowOn
@@ -107,9 +106,9 @@ class GeohashListState(
 
     init {
         settings.backupGeohashList?.let { event ->
-            Log.d("AccountRegisterObservers", "Loading saved Geohash list ${event.toJson()}")
+            Log.d("AccountRegisterObservers") { "Loading saved Geohash list ${event.toJson()}" }
             @OptIn(DelicateCoroutinesApi::class)
-            GlobalScope.launch(Dispatchers.IO) {
+            scope.launch(Dispatchers.IO) {
                 LocalCache.justConsumeMyOwnEvent(event)
             }
         }
@@ -117,7 +116,7 @@ class GeohashListState(
         scope.launch(Dispatchers.IO) {
             Log.d("AccountRegisterObservers", "Geohash List Collector Start")
             getGeohashListFlow().collect { noteState ->
-                Log.d("AccountRegisterObservers", "Geohash List for ${signer.pubKey}")
+                Log.d("AccountRegisterObservers") { "Geohash List for ${signer.pubKey}" }
                 (noteState.note.event as? GeohashListEvent)?.let {
                     settings.updateGeohashListTo(it)
                 }