Version 0.37.3

Reverting compose to 1.4.2
Add logs for fail to decrypt zap
2026-07-22 15:52:22 +00:00 · 2023-04-27 17:37:23 -04:00 · 2023-04-27 17:35:53 -04:00 · 2023-04-27 17:35:36 -04:00 · 2023-04-27 17:13:56 -04:00 · 2023-04-27 17:13:45 -04:00
398 changed files with 42682 additions and 8095 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,32 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: "[BUG]"
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Video and Screenshots**
+If applicable, add a video and/or screenshots to help explain your problem.
+
+**Device (please complete the following information):**
+ - Phone Brand/Model [e.g. Pixel 7 Pro]: 
+ - Android Version [e.g. 33]: 
+ - App Version [e.g. v0.20.3]: 
+
+**Bounty (in Bitcoin sats) offered for a solution**
+Incentivize developers to work on your issue. Describe clear milestones to claim payment.
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: "[FEATURE]"
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Bounty (in Bitcoin sats) offered for the implementation**
+Incentivize developers to work on your feature. Describe clear milestones to claim payment. 
+
+**Additional context**
+Add any other context, video, or screenshots about the feature request here.
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -14,10 +14,10 @@ jobs:
    steps:
      - uses: actions/checkout@v2

-      - name: Set up JDK 11
+      - name: Set up JDK 17
        uses: actions/setup-java@v1
        with:
-          java-version: 11
+          java-version: 17

      - name: Cache gradle
        uses: actions/cache@v1
@@ -27,6 +27,9 @@ jobs:
          restore-keys: |
            ${{ runner.os }}-gradle-

+      - name: Linter (gradle)
+        run: ./gradlew ktlintCheck
+
      - name: Test (gradle)
        run: ./gradlew test --no-daemon

--- a/.github/workflows/create-release.yml
+++ b/.github/workflows/create-release.yml
@@ -12,10 +12,10 @@ jobs:
      - name: Checkout code
        uses: actions/checkout@v2

-      - name: Set up JDK 11
+      - name: Set up JDK 17
        uses: actions/setup-java@v1
        with:
-          java-version: 11
+          java-version: 17

      - name: Cache gradle
        uses: actions/cache@v1
@@ -28,10 +28,19 @@ jobs:
      - name: Build AAB
        run: ./gradlew clean bundleRelease --stacktrace

-      - name: Sign AAB
+      - name: Sign AAB (Google Play)
        uses: r0adkll/sign-android-release@v1
        with:
-          releaseDirectory: app/build/outputs/bundle/release
+          releaseDirectory: app/build/outputs/bundle/playRelease
+          signingKeyBase64: ${{ secrets.SIGNING_KEY }}
+          alias: ${{ secrets.KEY_ALIAS }}
+          keyStorePassword: ${{ secrets.KEY_STORE_PASSWORD }}
+          keyPassword: ${{ secrets.KEY_PASSWORD }}
+
+      - name: Sign AAB (F-Droid)
+        uses: r0adkll/sign-android-release@v1
+        with:
+          releaseDirectory: app/build/outputs/bundle/fdroidRelease
          signingKeyBase64: ${{ secrets.SIGNING_KEY }}
          alias: ${{ secrets.KEY_ALIAS }}
          keyStorePassword: ${{ secrets.KEY_STORE_PASSWORD }}
@@ -40,10 +49,19 @@ jobs:
      - name: Build APK
        run: ./gradlew assembleRelease --stacktrace --no-daemon

-      - name: Sign APK
+      - name: Sign APK (Google Play)
        uses: r0adkll/sign-android-release@v1
        with:
-          releaseDirectory: app/build/outputs/apk/release
+          releaseDirectory: app/build/outputs/apk/play/release
+          signingKeyBase64: ${{ secrets.SIGNING_KEY }}
+          alias: ${{ secrets.KEY_ALIAS }}
+          keyStorePassword: ${{ secrets.KEY_STORE_PASSWORD }}
+          keyPassword: ${{ secrets.KEY_PASSWORD }}
+
+      - name: Sign APK (F-Droid)
+        uses: r0adkll/sign-android-release@v1
+        with:
+          releaseDirectory: app/build/outputs/apk/fdroid/release
          signingKeyBase64: ${{ secrets.SIGNING_KEY }}
          alias: ${{ secrets.KEY_ALIAS }}
          keyStorePassword: ${{ secrets.KEY_STORE_PASSWORD }}
@@ -60,24 +78,96 @@ jobs:
          draft: false
          prerelease: false

-      - name: Upload APK Asset
-        id: upload-release-asset-apk
+      # Google Play APK
+      - name: Upload Play APK Universal Asset
+        id: upload-release-asset-play-universal-apk
        uses: actions/upload-release-asset@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          upload_url: ${{ steps.create_release.outputs.upload_url }} 
-          asset_path: app/build/outputs/apk/release/app-release-unsigned-signed.apk
-          asset_name: app-release-${{ github.ref_name }}.apk
+          asset_path: app/build/outputs/apk/play/release/app-play-universal-release-unsigned-signed.apk
+          asset_name: amethyst-googleplay-universal-${{ github.ref_name }}.apk
          asset_content_type: application/zip

-      - name: Upload AAB Asset
-        id: upload-release-asset-aab
+      - name: Upload Play APK x86 Asset
+        id: upload-release-asset-play-x86-apk
        uses: actions/upload-release-asset@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: app/build/outputs/bundle/release/app-release.aab
-          asset_name: app-release-${{ github.ref_name }}.aab
+          asset_path: app/build/outputs/apk/play/release/app-play-x86-release-unsigned-signed.apk
+          asset_name: amethyst-googleplay-x86-${{ github.ref_name }}.apk
          asset_content_type: application/zip
+
+      - name: Upload Play APK x86_64 Asset
+        id: upload-release-asset-play-x86-64-apk
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: app/build/outputs/apk/play/release/app-play-x86_64-release-unsigned-signed.apk
+          asset_name: amethyst-googleplay-x86_64-${{ github.ref_name }}.apk
+          asset_content_type: application/zip
+
+      # F-Droid APK
+      - name: Upload F-Droid APK Universal Asset
+        id: upload-release-asset-fdroid-universal-apk
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: app/build/outputs/apk/fdroid/release/app-fdroid-universal-release-unsigned-signed.apk
+          asset_name: amethyst-fdroid-universal-${{ github.ref_name }}.apk
+          asset_content_type: application/zip
+
+      - name: Upload F-Droid APK x86 Asset
+        id: upload-release-asset-fdroid-x86-apk
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: app/build/outputs/apk/fdroid/release/app-fdroid-x86-release-unsigned-signed.apk
+          asset_name: amethyst-fdroid-x86-${{ github.ref_name }}.apk
+          asset_content_type: application/zip
+
+      - name: Upload F-Droid APK x86_64 Asset
+        id: upload-release-asset-fdroid-x86-64-apk
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: app/build/outputs/apk/fdroid/release/app-fdroid-x86_64-release-unsigned-signed.apk
+          asset_name: amethyst-fdroid-x86_64-${{ github.ref_name }}.apk
+          asset_content_type: application/zip
+
+
+
+      # Google Play AAB
+      - name: Upload Google Play AAB Asset
+        id: upload-release-asset-play-aab
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: app/build/outputs/bundle/playRelease/app-play-release.aab
+          asset_name: amethyst-googleplay-${{ github.ref_name }}.aab
+          asset_content_type: application/zip
+
+      # FDroid AAB
+      - name: Upload F-Droid AAB Asset
+        id: upload-release-asset-fdroid-aab
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: app/build/outputs/bundle/fdroidRelease/app-fdroid-release.aab
+          asset_name: amethyst-fdroid-${{ github.ref_name }}.aab
+          asset_content_type: application/zip
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,3 @@
-*.iml
-.gradle
 /local.properties
 /.idea/caches
 /.idea/libraries
@@ -7,12 +5,12 @@
 /.idea/workspace.xml
 /.idea/navEditor.xml
 /.idea/assetWizardSettings.xml
+/.idea/androidTestResultsUserPreferences.xml
+/.idea/deploymentTargetDropDown.xml
 .DS_Store
 /build
 /captures
-.externalNativeBuild
 .cxx
-local.properties


 # Built application files
@@ -35,6 +33,7 @@ out/
 # release/

 # Gradle files
+.gradle
 .gradle/
 build/

@@ -47,25 +46,51 @@ proguard/
 # Log Files
 *.log

-# Android Studio Navigation editor temp files
-.navigation/
-
-# Android Studio captures folder
+# Android Studio
+/*/build/
+/*/local.properties
+/*/out
+/*/*/build
+/*/*/production
 captures/
+.navigation/
+*.ipr
+*~
+*.swp

 # IntelliJ
 *.iml
-.idea/workspace.xml
-.idea/tasks.xml
-.idea/gradle.xml
-.idea/assetWizardSettings.xml
-.idea/dictionaries
-.idea/libraries
-# Android Studio 3 in .gitignore file.
-.idea/caches
-.idea/modules.xml
-# Comment next line if keeping position of elements in Navigation Editor is relevant for you
-.idea/navEditor.xml
+*.iws
+/out/
+deploymentTargetDropdown.xml
+render.experimental.xml
+
+# User-specific configurations
+.idea/**/caches/
+.idea/**/libraries/
+.idea/**/shelf/
+.idea/**/codeStyles
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/.name
+.idea/**/compiler.xml
+.idea/**/copyright/profiles_settings.xml
+.idea/**/encodings.xml
+.idea/**/misc.xml
+.idea/**/modules.xml
+.idea/**/scopes/scope_settings.xml
+.idea/**/dictionaries
+.idea/**/vcs.xml
+.idea/**/jsLibraryMappings.xml
+.idea/**/datasources.xml
+.idea/**/dataSources.ids
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/assetWizardSettings.xml
+.idea/**/gradle.xml
+.idea/**/jarRepositories.xml
+.idea/**/navEditor.xml

 # Keystore files
 # Uncomment the following lines if you do not want to check your keystore files in.
--- a/.idea/.name
+++ b/.idea/.name
@@ -0,0 +1 @@
+Amethyst
--- a/.idea/compiler.xml
+++ b/.idea/compiler.xml
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="CompilerConfiguration">
-    <bytecodeTargetLevel target="11" />
-  </component>
-</project>
--- a/.idea/inspectionProfiles/Project_Default.xml
+++ b/.idea/inspectionProfiles/Project_Default.xml
@@ -5,6 +5,9 @@
      <option name="composableFile" value="true" />
      <option name="previewFile" value="true" />
    </inspection_tool>
+    <inspection_tool class="PreviewApiLevelMustBeValid" enabled="true" level="ERROR" enabled_by_default="true">
+      <option name="composableFile" value="true" />
+    </inspection_tool>
    <inspection_tool class="PreviewDimensionRespectsLimit" enabled="true" level="WARNING" enabled_by_default="true">
      <option name="composableFile" value="true" />
      <option name="previewFile" value="true" />
--- a/.idea/kotlinc.xml
+++ b/.idea/kotlinc.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="KotlinJpsPluginSettings">
+    <option name="version" value="1.8.10" />
+  </component>
+</project>
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ExternalStorageConfigurationManager" enabled="true" />
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_11" project-jdk-name="1.8" project-jdk-type="JavaSDK">
-    <output url="file://$PROJECT_DIR$/build/classes" />
-  </component>
-  <component name="ProjectType">
-    <option name="id" value="Android" />
-  </component>
-</project>
--- a/PRIVACY.md
+++ b/PRIVACY.md
@@ -0,0 +1,13 @@
+# Amethyst Privacy Policy & Terms of Use
+
+Effective as of Jan 20, 2023.
+
+The Amethyst app for Android does not collect or process any personal information from its users. The app is used to connect to third-party Nostr servers (also called Relays) that may or may not collect personal information and are not covered by this privacy policy. Each third-party relay server comes equipped with its own privacy policy and terms of use that can be viewed through the app or through that server's website. The developers of this open source project or maintainers of the distribution channels (app stores) do not have access to the data located in the user's phone. Accounts are fully maintained by the user. We do not have control over them. 
+
+Data from connected accounts is only stored locally on the device when it is required for functionality and performance of Amethyst. This data is strictly confidental and cannot be accessed by other apps (on non-rooted devices). Phone data can be deleted by clearing Amethyst's local storage or uninstalling the app.
+
+You cannot use Amethyst to submit Objectionable Content to relays. Objectionable Content includes, but is not limited to: (i) sexually explicit materials; (ii) obscene, defamatory, libelous, slanderous, violent and/or unlawful content or profanity; (iii) content that infringes upon the rights of any third party, including copyright, trademark, privacy, publicity or other personal or proprietary right, or that is deceptive or fraudulent; (iv) content that promotes the use or sale of illegal or regulated substances, tobacco products, ammunition and/or firearms; and (v) illegal content related to gambling.
+
+We reserve the right to modify this Privacy Policy at any time. Any modifications to this Privacy Policy will be effective upon our posting the new terms and/or upon implementation of the new changes on the Service (or as otherwise indicated at the time of posting). In all cases, your continued use of the app after the posting of any modified Privacy Policy indicates your acceptance of the terms of the modified Privacy Policy.
+
+If you have any questions about Amethyst or this privacy policy, you can send a message to amethyst@vitorpamplona.com
--- a/README.md
+++ b/README.md
@@ -4,20 +4,73 @@

 Amethyst brings the best social network to your Android phone. Just insert your Nostr private key and start posting. 

+[<img src="https://fdroid.gitlab.io/artwork/badge/get-it-on.png"
+     alt="Get it on F-Droid"
+     height="80">](https://f-droid.org/packages/com.vitorpamplona.amethyst/)
+[<img src="https://play.google.com/intl/en_us/badges/images/generic/en-play-badge.png"
+     alt="Get it on Google Play"
+     height="80">](https://play.google.com/store/apps/details?id=com.vitorpamplona.amethyst)
+
+Or get the latest APK from the [Releases Section](https://github.com/vitorpamplona/amethyst/releases/latest).
+
 # Current Features

- [x] Account Management
+- [x] Event Builders / WebSocket Subscriptions (NIP-01, NIP-15)
 - [x] Home Feed
 - [x] Notifications Feed
 - [x] Global Feed
- [x] Reactions (like, boost, reply)
- [x] Image Preview
- [x] Url Preview
+- [x] Reactions (likes NIP-25, boost, reply)
+- [x] Image/Video/Url/LnInvoice Previews
 - [x] View Threads
- [ ] Private Messages
- [ ] Communities
- [ ] Profile Edit
- [ ] Relay Edit
+- [x] Private Messages (NIP-04)
+- [x] User Profiles (edit/follow/unfollow - NIP-02)
+- [x] Public Chats (NIP-28)
+- [x] Bech Encoding support (NIP-19)
+- [x] Notification Dots
+- [x] Reporting and Hide User capability (NIP-56)
+- [x] Automatic Translations
+- [x] Relay Sets (home, dms, public chats, global)
+- [x] User/Note Tagging (NIP-08, NIP-10)
+- [x] Lightning Tips
+- [x] Zaps (private, public, anon, non-zap) (NIP-57)
+- [x] URI Support (NIP-21)
+- [x] Event Deletion (NIP-09: like, boost, text notes and reports)
+- [x] Identity Verification (NIP-05)
+- [x] Long-form Content (NIP-23)
+- [x] Parameterized Replaceable Events (NIP-33)
+- [x] Online Relay Search (NIP-50)
+- [x] Internationalization
+- [x] Badges (NIP-58)
+- [x] Hashtag Following and Custom Hashtags
+- [x] Polls (NIP-69)
+- [x] Verifiable static content in URLs (NIP-94)
+- [x] Login with QR
+- [x] Wallet Connect API (NIP-47)
+- [x] Accessible uploads
+- [x] Bounty support (nostrbounties.com)
+- [x] De-googled F-Droid flavor
+- [x] External Identity Support (NIP-39)
+- [x] Multiple Accounts
+- [x] Markdown Support
+- [x] Relay Authentication (NIP-42)
+- [x] Content stored in relays themselves (NIP-95)
+- [ ] Local Database 
+- [ ] View Individual Reactions (Like, Boost, Zaps, Reports) per Post
+- [ ] Bookmarks, Pinned Posts, Muted Events (NIP-51)
+- [ ] Sensitive Content (NIP-36) 
+- [ ] Relay Pages (NIP-11)
+- [ ] Generic Tags (NIP-12)
+- [ ] Proof of Work in the Phone (NIP-13, NIP-20)
+- [ ] Events with a Subject (NIP-14)
+- [ ] Workspaces
+- [ ] Expiration Support (NIP-40)
+- [ ] Infinity Scroll
+- [ ] Relay List Metadata (NIP-65)
+- [ ] Signing Requests (NIP-46)
+- [ ] Delegated Event Signing (NIP-26)
+- [ ] Account Creation / Backup Guidance (NIP-06)
+- [ ] Message Sent feedback (NIP-20)
+

 # Development Overview

@@ -43,7 +96,7 @@ Lastly, the user's account information (priv key/pub key) is stored in the Andro
 ## Setup

 Make sure to have the following pre-requisites installed:
-1. Java 11
+1. Java 17
 2. Android Studio
 3. Android 8.0+ Phone or Emulation setup

@@ -66,9 +119,22 @@ Build the app:
 ./gradlew connectedAndroidTest
 ```

-## Installing on device
+## Linting
 ```bash
-./gradlew installDebug
+./gradlew ktlintCheck
+./gradlew ktlintFormat
+```
+
+## Installing on device
+
+For the F-Droid build:
+```bash
+./gradlew installFdroidDebug
+```
+
+For the Play build:
+```bash
+./gradlew installPlayDebug
 ```

 ## How to Deploy
@@ -90,10 +156,34 @@ openssl base64 < <my-release-key.keystore> | tr -d '\n' | tee some_signing_key.j
 7. Add your CHANGE LOG to the description of the new release
 8. Download the `aab` file and upload it to the` PlayStore.

+# Privacy on Relays & nostr
+Your internet protocol (IP) address is exposed to the relays you connect to. If you want to improve your privacy, consider utilizing a service that masks your IP address (e.g. a VPN) from trackers online. 
+
+The relay also learns which public keys you are requesting, meaning your public key will be tied to your IP address.
+
+Relays have all your data in raw text. They know your IP, your name, your location (guessed from IP), your pub key, all your contacts, and other relays, and can read every action you do (post, like, boost, quote, report, etc) with the exception of Private Zaps and Private DMs.
+
+# DM Privacy #
+While the content of direct messages (DMs) is only visible to you, and your DM nostr counterparty, everyone can see that and when you and your counterparty are DM-ing each other.
+
+# Visibility & Permanence of Your Content on nostr
+## Information Visibility ##
+Content that you share can be shared to other relays. 
+Information that you share is publicly visible to anyone reading from relays that have your information. Your information may also be visible to nostr users who do not share relays with you.
+
+## Information Permanence ##
+Information shared on nostr should be assumed permanent for privacy purposes. There is no way to guarantee deleting or editing any content once posted. 
+
 # Contributing

 [Issues](https://github.com/vitorpamplona/amethyst/issues) and [pull requests](https://github.com/vitorpamplona/amethyst/pulls) are very welcome.

+## Contributors
+
+<a align="center" href="https://github.com/vitorpamplona/amethyst/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=vitorpamplona/amethyst" />
+</a>
+
 # MIT License

 Copyright (c) 2023 Vitor Pamplona
@@ -114,4 +204,4 @@ 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.
+SOFTWARE.
--- a/amethyst.png
+++ b/amethyst.png
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -1,6 +1,7 @@
 plugins {
    id 'com.android.application'
    id 'org.jetbrains.kotlin.android'
+    id 'org.jlleitschuh.gradle.ktlint' version "11.3.1"
 }

 android {
@@ -11,8 +12,8 @@ android {
        applicationId "com.vitorpamplona.amethyst"
        minSdk 26
        targetSdk 33
-        versionCode 4
-        versionName "0.4"
+        versionCode 130
+        versionName "0.37.3"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
        vectorDrawables {
@@ -22,54 +23,98 @@ android {

    buildTypes {
        release {
-            minifyEnabled false
-            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+            //minifyEnabled true
+            //proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+            resValue "string", "app_name", "@string/app_name_release"
+        }
+        debug {
+            applicationIdSuffix '.debug'
+            versionNameSuffix '-DEBUG'
+            resValue "string", "app_name", "@string/app_name_debug"
        }
    }
+
+    flavorDimensions "channel"
+
+    productFlavors {
+        play {
+            getIsDefault().set(true)
+            dimension "channel"
+        }
+
+        fdroid {
+            dimension "channel"
+        }
+    }
+
+    splits {
+        abi {
+            enable true
+            reset()
+            include "x86", "x86_64"
+            universalApk true
+        }
+    }
+
    compileOptions {
-        sourceCompatibility JavaVersion.VERSION_11
-        targetCompatibility JavaVersion.VERSION_11
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
    }
+
    kotlinOptions {
-        jvmTarget = '11'
+        jvmTarget = '17'
    }
+
    buildFeatures {
        compose true
    }
+
    composeOptions {
-        kotlinCompilerExtensionVersion '1.3.2'
+        kotlinCompilerExtensionVersion "1.4.3"
    }
+
    packagingOptions {
        resources {
            excludes += '/META-INF/{AL2.0,LGPL2.1}'
        }
    }
+    lint {
+        disable 'MissingTranslation'
+    }
+
 }

 dependencies {
-    implementation 'androidx.core:core-ktx:1.9.0'
-    implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.5.1'
-    implementation 'androidx.activity:activity-compose:1.6.1'
+    implementation 'androidx.core:core-ktx:1.10.0'
+    implementation 'androidx.activity:activity-compose:1.7.0'
    implementation "androidx.compose.ui:ui:$compose_ui_version"
    implementation "androidx.compose.ui:ui-tooling-preview:$compose_ui_version"
-    implementation 'androidx.compose.material:material:1.3.1'
+
+    // Needs this to open gallery / image upload
+    implementation "androidx.fragment:fragment-ktx:$fragment_version"

    // Navigation
    implementation("androidx.navigation:navigation-compose:$nav_version")
-    implementation 'androidx.lifecycle:lifecycle-runtime-compose:2.6.0-alpha03'
-    implementation 'androidx.compose.runtime:runtime-livedata:1.4.0-alpha03'

-    // Input
-    implementation 'androidx.lifecycle:lifecycle-viewmodel-compose:2.5.1'
+    // Observe Live data as State
+    implementation "androidx.compose.runtime:runtime-livedata:$compose_ui_version"

-    // Swipe Refresh
-    implementation 'com.google.accompanist:accompanist-swiperefresh:0.24.13-rc'
+    implementation "androidx.compose.material:material:$compose_ui_version"
+    implementation "androidx.compose.material:material-icons-extended:$compose_ui_version"

-    // Load images from the web.
-    implementation "io.coil-kt:coil-compose:2.2.2"
+    // Lifecycle
+    implementation "androidx.lifecycle:lifecycle-runtime-compose:$lifecycle_version"
+    implementation "androidx.lifecycle:lifecycle-viewmodel-compose:$lifecycle_version"
+    implementation "androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version"
+    implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"
+
+    implementation 'net.engawapg.lib:zoomable:1.4.2'
+
+    // Biometrics
+    implementation "androidx.biometric:biometric-ktx:1.2.0-alpha05"

    // Bitcoin secp256k1 bindings to Android
-    implementation 'fr.acinq.secp256k1:secp256k1-kmp-jni-android:0.7.0'
+    implementation 'fr.acinq.secp256k1:secp256k1-kmp-jni-android:0.9.0'

    // Nostr Base Protocol
    implementation('com.github.vitorpamplona.NostrPostr:nostrpostrlib:master-SNAPSHOT') {
@@ -78,30 +123,99 @@ dependencies {
        exclude module: 'guava-testlib'
    }

-    implementation 'com.squareup.retrofit2:converter-gson:2.8.1'
    // Websockets API
-    implementation 'com.squareup.okhttp3:okhttp:4.10.0'
+    implementation 'com.squareup.okhttp3:okhttp:5.0.0-alpha.11'

-    // Json Serialization
-    implementation 'com.fasterxml.jackson.module:jackson-module-kotlin:2.14.1'
-
-    // Rendering clickable text
-    implementation "com.google.accompanist:accompanist-flowlayout:0.28.0"
+    // Json Serialization TODO: We might need to converge between gson and Jackson (we are usin both)
+    implementation 'com.fasterxml.jackson.module:jackson-module-kotlin:2.15.0'
+    implementation 'com.squareup.retrofit2:converter-gson:2.9.0'

    // link preview
    implementation 'tw.com.oneup.www:Baha-UrlPreview:1.0.1'
-    implementation 'androidx.security:security-crypto-ktx:1.1.0-alpha04'

-    // upload pictures:
-    implementation "com.google.accompanist:accompanist-permissions:0.28.0"
+    // Encrypted Key Storage
+    implementation 'androidx.security:security-crypto-ktx:1.1.0-alpha06'

    // view videos
-    implementation 'com.google.android.exoplayer:exoplayer:2.18.2'
+    implementation 'com.google.android.exoplayer:exoplayer:2.18.6'
+
+    // Load images from the web.
+    implementation "io.coil-kt:coil-compose:$coil_version"
+    // view gifs
+    implementation "io.coil-kt:coil-gif:$coil_version"
+    // view svgs
+    implementation "io.coil-kt:coil-svg:$coil_version"
+
+    // create blurhash
+    implementation group: 'io.trbl', name: 'blurhash', version: '1.0.0'
+
+    // Rendering clickable text
+    implementation "com.google.accompanist:accompanist-flowlayout:$accompanist_version"
+    // Permission to upload pictures:
+    implementation "com.google.accompanist:accompanist-permissions:$accompanist_version"
+
+    // Parses URLs from Text:
+    implementation "io.github.url-detector:url-detector:0.1.23"
+
+    // For QR generation
+    implementation 'com.google.zxing:core:3.5.1'
+    implementation 'com.journeyapps:zxing-android-embedded:4.3.0'
+
+    // Markdown
+    implementation "com.halilibo.compose-richtext:richtext-ui:0.16.0"
+    implementation "com.halilibo.compose-richtext:richtext-ui-material:0.16.0"
+    implementation "com.halilibo.compose-richtext:richtext-commonmark:0.16.0"
+
+    // Local model for language identification
+    playImplementation 'com.google.mlkit:language-id:17.0.4'
+
+    // Google services model the translate text
+    playImplementation 'com.google.mlkit:translate:17.0.1'
+
+    // Automatic memory leak detection
+    debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.10'

    testImplementation 'junit:junit:4.13.2'
-    androidTestImplementation 'androidx.test.ext:junit:1.1.5'
+    testImplementation 'io.mockk:mockk:1.13.5'
+    androidTestImplementation 'androidx.test.ext:junit:1.2.0-alpha01'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'
    androidTestImplementation "androidx.compose.ui:ui-test-junit4:$compose_ui_version"
    debugImplementation "androidx.compose.ui:ui-tooling:$compose_ui_version"
    debugImplementation "androidx.compose.ui:ui-test-manifest:$compose_ui_version"
-}
+}
+
+ktlint {
+    disabledRules.set(["no-wildcard-imports"])
+}
+
+// https://gitlab.com/fdroid/wiki/-/wikis/HOWTO:-diff-&-fix-APKs-for-Reproducible-Builds#differing-assetsdexoptbaselineprofm-easy-to-fix
+// NB: Android Studio can't find the imports; this does not affect the
+// actual build since Gradle can find them just fine.
+import com.android.tools.profgen.ArtProfileKt
+import com.android.tools.profgen.ArtProfileSerializer
+import com.android.tools.profgen.DexFile
+
+project.afterEvaluate {
+    tasks.each { task ->
+        if (task.name.startsWith("compile") && task.name.endsWith("ReleaseArtProfile")) {
+            task.doLast {
+                outputs.files.each { file ->
+                    if (file.name.endsWith(".profm")) {
+                        println("Sorting ${file} ...")
+                        def version = ArtProfileSerializer.valueOf("METADATA_0_0_2")
+                        def profile = ArtProfileKt.ArtProfile(file)
+                        def keys = new ArrayList(profile.profileData.keySet())
+                        def sortedData = new LinkedHashMap()
+                        Collections.sort keys, new DexFile.Companion()
+                        keys.each { key -> sortedData[key] = profile.profileData[key] }
+                        new FileOutputStream(file).with {
+                            write(version.magicBytes$profgen)
+                            write(version.versionBytes$profgen)
+                            version.write$profgen(it, sortedData, "")
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
--- a/app/proguard-rules.pro
+++ b/app/proguard-rules.pro
@@ -18,4 +18,20 @@

 # If you keep the line number information, uncomment this to
 # hide the original source file name.
-#-renamesourcefileattribute SourceFile
+#-renamesourcefileattribute SourceFile
+# For the Secp256k1 library
+-keepattributes InnerClasses
+
+-keep class fr.acinq.secp256k1.jni.** { *; }
+# For the NostrPostr library
+-keep class nostr.postr.** { *; }
+-keep class com.vitorpamplona.amethyst.service.model.** { *; }
+# Json parsing
+-keep class com.google.gson.reflect.** { *; }
+-keep class * extends com.google.gson.reflect.TypeToken
+-keep public class * implements java.lang.reflect.Type
+
+-keep class com.vitorpamplona.amethyst.lnurl.** { *; }
+-keep class com.vitorpamplona.amethyst.model.** { *; }
+-keep class com.vitorpamplona.amethyst.service.** { *; }
+-keep class com.vitorpamplona.amethyst.ui.** { *; }
--- a/app/src/androidTest/java/com/vitorpamplona/amethyst/EventSigCheck.kt
+++ b/app/src/androidTest/java/com/vitorpamplona/amethyst/EventSigCheck.kt
@@ -0,0 +1,23 @@
+package com.vitorpamplona.amethyst
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.google.gson.JsonElement
+import com.vitorpamplona.amethyst.service.model.Event
+import com.vitorpamplona.amethyst.service.relays.Client
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class EventSigCheck {
+
+    val payload1 = "[\"EVENT\",\"40b9\",{\"id\":\"48a72b485d38338627ec9d427583551f9af4f016c739b8ec0d6313540a8b12cf\",\"kind\":1,\"pubkey\":\"3d842afecd5e293f28b6627933704a3fb8ce153aa91d790ab11f6a752d44a42d\",\"created_at\":1677940007,\"content\":\"I got asked about follower count again today. Why does my follower count go down when I delete public relays (in our list) and replace them with filter.nostr.wine? \\n\\nI’ll give you one final explanation to rule them all. First, let’s go over how clients calculate your follower count.\\n\\n1. Your client sends a request to all your connected relays asking for accounts who follow you\\n2. Relays answer back with the events requested\\n3. The client aggregates the event total and displays it\\n\\nEach relay has a set limit on how many stored events it will return per request. For some relays it’s 500, others 1000, some as high as 5000. Let’s say for simplicity that all your public relays use 500 as their limit. If you ask 10 relays for your followers the max possible answer you can get is 5000. That won’t change if you have 20,000 followers or 100,000. You may get back a “different” 5000 each time, but you’ll still cap out at 5000 because that is the most events your client will receive.\u2028\u2028Our limit on filter.nostr.wine is 2000 events. If you replace 10 public relays with only filter.nostr.wine, the MOST followers you will ever get back from our filter relay is 2000. That doesn’t mean you only have 2000 followers or that your reach is reduced in any way.\\n\\nAs long as you are writing to and reading from the same public relays, neither your reach nor any content was lost. That concludes my TED talk. I hope you all have a fantastic day and weekend.\",\"tags\":[],\"sig\":\"dcaf8ab98bb9179017b35bd814092850d1062b26c263dff89fb1ae8c019a324139d1729012d9d05ff0a517f76b1117d869b2cc7d36bea8aa5f4b94c5e2548aa8\"}]"
+
+    @Test
+    fun testUnicode2028and2029ShouldNotBeEscaped() {
+        val msg = Event.gson.fromJson(payload1, JsonElement::class.java).asJsonArray
+        val event = Event.fromJson(msg[2], Client.lenient)
+
+        // Should pass
+        event.checkSignature()
+    }
+}
--- a/app/src/androidTest/java/com/vitorpamplona/amethyst/ExampleInstrumentedTest.kt
+++ b/app/src/androidTest/java/com/vitorpamplona/amethyst/ExampleInstrumentedTest.kt
@@ -1,24 +0,0 @@
-package com.vitorpamplona.amethyst
-
-import androidx.test.platform.app.InstrumentationRegistry
-import androidx.test.ext.junit.runners.AndroidJUnit4
-
-import org.junit.Test
-import org.junit.runner.RunWith
-
-import org.junit.Assert.*
-
-/**
- * Instrumented test, which will execute on an Android device.
- *
- * See [testing documentation](http://d.android.com/tools/testing).
- */
-@RunWith(AndroidJUnit4::class)
-class ExampleInstrumentedTest {
-  @Test
-  fun useAppContext() {
-    // Context of the app under test.
-    val appContext = InstrumentationRegistry.getInstrumentation().targetContext
-    assertEquals("com.vitorpamplona.amethyst", appContext.packageName)
-  }
-}
--- a/app/src/androidTest/java/com/vitorpamplona/amethyst/ImageUploadTesting.kt
+++ b/app/src/androidTest/java/com/vitorpamplona/amethyst/ImageUploadTesting.kt
@@ -0,0 +1,91 @@
+package com.vitorpamplona.amethyst
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.vitorpamplona.amethyst.ui.actions.ImageUploader
+import com.vitorpamplona.amethyst.ui.actions.ImgurServer
+import com.vitorpamplona.amethyst.ui.actions.NostrBuildServer
+import com.vitorpamplona.amethyst.ui.actions.NostrImgServer
+import junit.framework.TestCase.assertNotNull
+import junit.framework.TestCase.fail
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import org.junit.Ignore
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.util.Base64
+
+@RunWith(AndroidJUnit4::class)
+class ImageUploadTesting {
+
+    val image = "R0lGODlhPQBEAPeoAJosM//AwO/AwHVYZ/z595kzAP/s7P+goOXMv8+fhw/v739/f+8PD98fH/8mJl+fn/9ZWb8/PzWlwv///6wWGbImAPgTEMImIN9gUFCEm/gDALULDN8PAD6atYdCTX9gUNKlj8wZAKUsAOzZz+UMAOsJAP/Z2ccMDA8PD/95eX5NWvsJCOVNQPtfX/8zM8+QePLl38MGBr8JCP+zs9myn/8GBqwpAP/GxgwJCPny78lzYLgjAJ8vAP9fX/+MjMUcAN8zM/9wcM8ZGcATEL+QePdZWf/29uc/P9cmJu9MTDImIN+/r7+/vz8/P8VNQGNugV8AAF9fX8swMNgTAFlDOICAgPNSUnNWSMQ5MBAQEJE3QPIGAM9AQMqGcG9vb6MhJsEdGM8vLx8fH98AANIWAMuQeL8fABkTEPPQ0OM5OSYdGFl5jo+Pj/+pqcsTE78wMFNGQLYmID4dGPvd3UBAQJmTkP+8vH9QUK+vr8ZWSHpzcJMmILdwcLOGcHRQUHxwcK9PT9DQ0O/v70w5MLypoG8wKOuwsP/g4P/Q0IcwKEswKMl8aJ9fX2xjdOtGRs/Pz+Dg4GImIP8gIH0sKEAwKKmTiKZ8aB/f39Wsl+LFt8dgUE9PT5x5aHBwcP+AgP+WltdgYMyZfyywz78AAAAAAAD///8AAP9mZv///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEAAKgALAAAAAA9AEQAAAj/AFEJHEiwoMGDCBMqXMiwocAbBww4nEhxoYkUpzJGrMixogkfGUNqlNixJEIDB0SqHGmyJSojM1bKZOmyop0gM3Oe2liTISKMOoPy7GnwY9CjIYcSRYm0aVKSLmE6nfq05QycVLPuhDrxBlCtYJUqNAq2bNWEBj6ZXRuyxZyDRtqwnXvkhACDV+euTeJm1Ki7A73qNWtFiF+/gA95Gly2CJLDhwEHMOUAAuOpLYDEgBxZ4GRTlC1fDnpkM+fOqD6DDj1aZpITp0dtGCDhr+fVuCu3zlg49ijaokTZTo27uG7Gjn2P+hI8+PDPERoUB318bWbfAJ5sUNFcuGRTYUqV/3ogfXp1rWlMc6awJjiAAd2fm4ogXjz56aypOoIde4OE5u/F9x199dlXnnGiHZWEYbGpsAEA3QXYnHwEFliKAgswgJ8LPeiUXGwedCAKABACCN+EA1pYIIYaFlcDhytd51sGAJbo3onOpajiihlO92KHGaUXGwWjUBChjSPiWJuOO/LYIm4v1tXfE6J4gCSJEZ7YgRYUNrkji9P55sF/ogxw5ZkSqIDaZBV6aSGYq/lGZplndkckZ98xoICbTcIJGQAZcNmdmUc210hs35nCyJ58fgmIKX5RQGOZowxaZwYA+JaoKQwswGijBV4C6SiTUmpphMspJx9unX4KaimjDv9aaXOEBteBqmuuxgEHoLX6Kqx+yXqqBANsgCtit4FWQAEkrNbpq7HSOmtwag5w57GrmlJBASEU18ADjUYb3ADTinIttsgSB1oJFfA63bduimuqKB1keqwUhoCSK374wbujvOSu4QG6UvxBRydcpKsav++Ca6G8A6Pr1x2kVMyHwsVxUALDq/krnrhPSOzXG1lUTIoffqGR7Goi2MAxbv6O2kEG56I7CSlRsEFKFVyovDJoIRTg7sugNRDGqCJzJgcKE0ywc0ELm6KBCCJo8DIPFeCWNGcyqNFE06ToAfV0HBRgxsvLThHn1oddQMrXj5DyAQgjEHSAJMWZwS3HPxT/QMbabI/iBCliMLEJKX2EEkomBAUCxRi42VDADxyTYDVogV+wSChqmKxEKCDAYFDFj4OmwbY7bDGdBhtrnTQYOigeChUmc1K3QTnAUfEgGFgAWt88hKA6aCRIXhxnQ1yg3BCayK44EWdkUQcBByEQChFXfCB776aQsG0BIlQgQgE8qO26X1h8cEUep8ngRBnOy74E9QgRgEAC8SvOfQkh7FDBDmS43PmGoIiKUUEGkMEC/PJHgxw0xH74yx/3XnaYRJgMB8obxQW6kL9QYEJ0FIFgByfIL7/IQAlvQwEpnAC7DtLNJCKUoO/w45c44GwCXiAFB/OXAATQryUxdN4LfFiwgjCNYg+kYMIEFkCKDs6PKAIJouyGWMS1FSKJOMRB/BoIxYJIUXFUxNwoIkEKPAgCBZSQHQ1A2EWDfDEUVLyADj5AChSIQW6gu10bE/JG2VnCZGfo4R4d0sdQoBAHhPjhIB94v/wRoRKQWGRHgrhGSQJxCS+0pCZbEhAAOw=="
+
+    @Test()
+    fun testImgurUpload() = runBlocking {
+        val inputStream = Base64.getDecoder().decode(image).inputStream()
+
+        println("Uploading")
+
+        ImageUploader.uploadImage(
+            inputStream,
+            "image/gif",
+            ImgurServer(),
+            onSuccess = { url, contentType ->
+                println("Uploaded to $url")
+                assertNotNull(url)
+            },
+            onError = {
+                println("Failed to Upload")
+                fail("${it.message}")
+            }
+        )
+
+        delay(1000)
+    }
+
+    @Test()
+    @Ignore
+    fun testNostrBuildUpload() = runBlocking {
+        val inputStream = Base64.getDecoder().decode(image).inputStream()
+
+        println("Uploading")
+
+        ImageUploader.uploadImage(
+            inputStream,
+            "image/gif",
+            NostrBuildServer(),
+            onSuccess = { url, contentType ->
+                println("Uploaded to $url")
+                assertNotNull(url)
+            },
+            onError = {
+                println("Failed to Upload")
+                fail("${it.message}")
+            }
+        )
+
+        delay(1000)
+    }
+
+    @Test()
+    fun testNostrImgUpload() = runBlocking {
+        val inputStream = Base64.getDecoder().decode(image).inputStream()
+
+        println("Uploading")
+
+        ImageUploader.uploadImage(
+            inputStream,
+            "image/gif",
+            NostrImgServer(),
+            onSuccess = { url, contentType ->
+                println("Uploaded to $url")
+                assertNotNull(url)
+            },
+            onError = {
+                println("Failed to Upload")
+                fail("${it.message}")
+            }
+        )
+
+        delay(1000)
+    }
+}
--- a/app/src/androidTest/java/com/vitorpamplona/amethyst/PrivateZapTests.kt
+++ b/app/src/androidTest/java/com/vitorpamplona/amethyst/PrivateZapTests.kt
@@ -0,0 +1,139 @@
+package com.vitorpamplona.amethyst
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.vitorpamplona.amethyst.model.toHexKey
+import com.vitorpamplona.amethyst.service.model.Event
+import com.vitorpamplona.amethyst.service.model.LnZapEvent
+import com.vitorpamplona.amethyst.service.model.LnZapRequestEvent
+import com.vitorpamplona.amethyst.service.model.LnZapRequestEvent.Companion.createEncryptionPrivateKey
+import fr.acinq.secp256k1.Hex
+import junit.framework.TestCase.assertNotNull
+import junit.framework.TestCase.fail
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class PrivateZapTests {
+
+    @Test
+    fun testPollZap() {
+        val poll = Event.Companion.fromJson(
+            """{
+  "content": "New poll \n\n #zappoll",
+  "created_at": 1682440713,
+  "id": "16291ba452bb0786a4bf5c278d38de73c96b58c056ed75c5ea466b0795197288",
+  "kind": 6969,
+  "pubkey": "f8ff11c7a7d3478355d3b4d174e5a473797a906ea4aa61aa9b6bc0652c1ea17a",
+  "sig": "ac05fa4004c3f7c42913c87b11bf9714bb61a3f0940863a6b9ff0f8105b399add72dbc09bf944c79b9a72ef009ec6905adedbd2c4c8fb3d2f57007bad8fcb279",
+  "tags": [
+    [
+      "poll_option",
+      "0",
+      "Test 1"
+    ],
+    [
+      "poll_option",
+      "1",
+      "Test 2"
+    ],
+    [
+      "value_maximum",
+      "null"
+    ],
+    [
+      "value_minimum",
+      "null"
+    ],
+    [
+      "consensus_threshold",
+      "null"
+    ],
+    [
+      "closed_at",
+      "null"
+    ]
+  ],
+  "seenOn": [
+    "wss://relay.damus.io/"
+  ]
+}
+""",
+            true
+        )
+
+        val loggedIn = Hex.decode("e8e7197ccc53c9ed4cf9b1c8dce085475fa1ffdd71f2c14e44fe23d0bdf77598")
+
+        val privateZapRequest = LnZapRequestEvent.create(
+            poll,
+            setOf("wss://relay.damus.io/"),
+            loggedIn,
+            0,
+            "",
+            LnZapEvent.ZapType.PRIVATE
+        )
+
+        val recepientPK = privateZapRequest.zappedAuthor().firstOrNull()
+        val recepientPost = privateZapRequest.zappedPost().firstOrNull()
+
+        if (recepientPK != null && recepientPost != null) {
+            val privateKey = createEncryptionPrivateKey(loggedIn.toHexKey(), recepientPost, privateZapRequest.createdAt)
+            val decodedPrivateZap =
+                LnZapRequestEvent.checkForPrivateZap(privateZapRequest, privateKey, recepientPK)
+
+            println(decodedPrivateZap?.toJson())
+            assertNotNull(decodedPrivateZap)
+        } else {
+            fail("Should not be null")
+        }
+    }
+
+    @Test
+    fun testKind1PrivateZap() {
+        val textNote = Event.Companion.fromJson(
+            """{
+    "content": "Testing copied author. \n\nnostr:npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z",
+    "created_at": 1682369982,
+    "id": "c757e1371d715c711ec9ef9740a3df6475d64b3d0af45ffcbfca08d273baf1c1",
+    "kind": 1,
+    "pubkey": "f8ff11c7a7d3478355d3b4d174e5a473797a906ea4aa61aa9b6bc0652c1ea17a",
+    "sig": "1fb5b6fd980f4c2ef058d5f4f7b166c0e5fb21eff26fe9cacd87a9aa4feb344485841ebcc26a233bf8d6ea0a66acf0db2bfdb11ad1cb04bcea4cfa3e78c3eaf1",
+    "tags": [
+    [
+        "p",
+        "460c25e682fda7832b52d1f22d3d22b3176d972f60dcdc3212ed8c92ef85065c"
+    ]
+    ],
+    "seenOn": [
+    "wss://relay.damus.io/"
+    ]
+}
+""",
+            true
+        )
+
+        val loggedIn = Hex.decode("e8e7197ccc53c9ed4cf9b1c8dce085475fa1ffdd71f2c14e44fe23d0bdf77598")
+
+        val privateZapRequest = LnZapRequestEvent.create(
+            textNote,
+            setOf("wss://relay.damus.io/", "wss://relay.damus2.io/", "wss://relay.damus3.io/"),
+            loggedIn,
+            null,
+            "test",
+            LnZapEvent.ZapType.PRIVATE
+        )
+
+        val recepientPK = privateZapRequest.zappedAuthor().firstOrNull()
+        val recepientPost = privateZapRequest.zappedPost().firstOrNull()
+
+        if (recepientPK != null && recepientPost != null) {
+            val privateKey = createEncryptionPrivateKey(loggedIn.toHexKey(), recepientPost, privateZapRequest.createdAt)
+            val decodedPrivateZap =
+                LnZapRequestEvent.checkForPrivateZap(privateZapRequest, privateKey, recepientPK)
+
+            println(decodedPrivateZap?.toJson())
+            assertNotNull(decodedPrivateZap)
+        } else {
+            fail("Should not be null")
+        }
+    }
+}
--- a/app/src/androidTest/java/com/vitorpamplona/amethyst/UrlUserTagTransformationTest.kt
+++ b/app/src/androidTest/java/com/vitorpamplona/amethyst/UrlUserTagTransformationTest.kt
@@ -0,0 +1,99 @@
+package com.vitorpamplona.amethyst
+
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.vitorpamplona.amethyst.model.LocalCache
+import com.vitorpamplona.amethyst.model.UserMetadata
+import com.vitorpamplona.amethyst.model.decodePublicKey
+import com.vitorpamplona.amethyst.model.toHexKey
+import com.vitorpamplona.amethyst.ui.actions.buildAnnotatedStringWithUrlHighlighting
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * Instrumented test, which will execute on an Android device.
+ *
+ * See [testing documentation](http://d.android.com/tools/testing).
+ */
+@RunWith(AndroidJUnit4::class)
+class UrlUserTagTransformationTest {
+    @Test
+    fun useAppContext() {
+        // Context of the app under test.
+        val appContext = InstrumentationRegistry.getInstrumentation().targetContext
+        assertEquals("com.vitorpamplona.amethyst", appContext.packageName.removeSuffix(".debug"))
+    }
+
+    @Test
+    fun transformationText() {
+        val user = LocalCache.getOrCreateUser(decodePublicKey("npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z").toHexKey())
+        user.info = UserMetadata()
+        user.info?.displayName = "Vitor Pamplona"
+
+        val transformedText = buildAnnotatedStringWithUrlHighlighting(
+            AnnotatedString("New Hey @npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z"),
+            Color.Red
+        )
+
+        assertEquals("New Hey @Vitor Pamplona", transformedText.text.text)
+
+        assertEquals(0, transformedText.offsetMapping.originalToTransformed(0)) // Before N
+        assertEquals(4, transformedText.offsetMapping.originalToTransformed(4)) // Before H
+        assertEquals(8, transformedText.offsetMapping.originalToTransformed(8)) // Before @
+        assertEquals(8, transformedText.offsetMapping.originalToTransformed(9)) // Before n
+        assertEquals(8, transformedText.offsetMapping.originalToTransformed(10)) // Before p
+        assertEquals(9, transformedText.offsetMapping.originalToTransformed(11)) // Before u
+        assertEquals(9, transformedText.offsetMapping.originalToTransformed(12)) // Before b
+        assertEquals(9, transformedText.offsetMapping.originalToTransformed(13)) // Before 1
+
+        assertEquals(23, transformedText.offsetMapping.originalToTransformed(71))
+        assertEquals(23, transformedText.offsetMapping.originalToTransformed(72))
+
+        assertEquals(0, transformedText.offsetMapping.transformedToOriginal(0))
+        assertEquals(4, transformedText.offsetMapping.transformedToOriginal(4))
+        assertEquals(8, transformedText.offsetMapping.transformedToOriginal(8))
+        assertEquals(12, transformedText.offsetMapping.transformedToOriginal(9))
+
+        assertEquals(72, transformedText.offsetMapping.transformedToOriginal(23))
+        assertEquals(73, transformedText.offsetMapping.transformedToOriginal(24))
+    }
+
+    @Test
+    fun transformationTextTwoKeys() {
+        val user = LocalCache.getOrCreateUser(decodePublicKey("npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z").toHexKey())
+        user.info = UserMetadata()
+        user.info?.displayName = "Vitor Pamplona"
+
+        val transformedText = buildAnnotatedStringWithUrlHighlighting(
+            AnnotatedString("New Hey @npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z and @npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z"),
+            Color.Red
+        )
+
+        assertEquals("New Hey @Vitor Pamplona and @Vitor Pamplona", transformedText.text.text)
+
+        assertEquals(9, transformedText.offsetMapping.originalToTransformed(11))
+        assertEquals(9, transformedText.offsetMapping.originalToTransformed(12))
+        assertEquals(9, transformedText.offsetMapping.originalToTransformed(13))
+
+        assertEquals(23, transformedText.offsetMapping.originalToTransformed(70)) // Before 5
+        assertEquals(23, transformedText.offsetMapping.originalToTransformed(71)) // Before z
+        assertEquals(23, transformedText.offsetMapping.originalToTransformed(72)) // Before <space>
+        assertEquals(24, transformedText.offsetMapping.originalToTransformed(73)) // Before a
+        assertEquals(25, transformedText.offsetMapping.originalToTransformed(74)) // Before n
+        assertEquals(26, transformedText.offsetMapping.originalToTransformed(75)) // Before d
+        assertEquals(27, transformedText.offsetMapping.originalToTransformed(76)) // Before <space>
+        assertEquals(28, transformedText.offsetMapping.originalToTransformed(77)) // Before @
+        assertEquals(28, transformedText.offsetMapping.originalToTransformed(78)) // Before n
+
+        assertEquals(68, transformedText.offsetMapping.transformedToOriginal(22)) // Before a
+        assertEquals(72, transformedText.offsetMapping.transformedToOriginal(23)) // Before <space>
+        assertEquals(73, transformedText.offsetMapping.transformedToOriginal(24)) // Before a
+        assertEquals(74, transformedText.offsetMapping.transformedToOriginal(25)) // Before n
+        assertEquals(75, transformedText.offsetMapping.transformedToOriginal(26)) // Before d
+        assertEquals(76, transformedText.offsetMapping.transformedToOriginal(27)) // Before <space>
+        assertEquals(77, transformedText.offsetMapping.transformedToOriginal(28)) // Before @
+    }
+}
--- a/app/src/androidTest/res/values/strings.xml
+++ b/app/src/androidTest/res/values/strings.xml
@@ -0,0 +1,4 @@
+<resources>
+    <string name="app_name_release">Amethyst</string>
+    <string name="app_name_debug">Amethyst Debug</string>
+</resources>
--- a/app/src/androidTestPlay/java/com/vitorpamplona/amethyst/TranslationsTest.kt
+++ b/app/src/androidTestPlay/java/com/vitorpamplona/amethyst/TranslationsTest.kt
@@ -0,0 +1,89 @@
+package com.vitorpamplona.amethyst
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.google.android.gms.tasks.Tasks
+import com.vitorpamplona.amethyst.service.lang.LanguageTranslatorService
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class TranslationsTest {
+
+    fun translatePT(text: String, translateTo: String): String? {
+        val task = LanguageTranslatorService.autoTranslate(text, emptySet(), translateTo)
+        return Tasks.await(task).result
+    }
+
+    fun assertTranslate(expected: String, input: String, translateTo: String) {
+        assertEquals(null, expected, translatePT(input, translateTo))
+    }
+
+    fun assertTranslateContains(expected: String, input: String, translateTo: String) {
+        val translated = translatePT(input, translateTo)!!
+        assertTrue("'$translated' does not contain '$expected'", translated.contains(expected))
+    }
+
+    @Test
+    fun testTranslation() {
+        assertTranslate("Olá mundo", "Hello World", "pt")
+    }
+
+    @Test
+    fun testTranslationName() {
+        assertTranslate("Olá Vitor, como você está?", "Hello Vitor, how are you doing?", "pt")
+    }
+
+    @Test
+    fun testTranslationTag() {
+        assertTranslate("Você já viu isso, #[0]", "Have you seen this, #[0]", "pt")
+    }
+
+    @Test
+    fun testTranslationUrl() {
+        assertTranslateContains("https://t.me/mygroup", "Have you seen this https://t.me/mygroup", "pt")
+        assertTranslateContains("http://bananas.com", "Have you seen this http://bananas.com", "pt")
+        assertTranslateContains("http://bananas.com/myimage.jpg", "Have you seen this http://bananas.com/myimage.jpg", "pt")
+        assertTranslateContains("http://bananas.com?search=true&image=myimage.jpg", "Have you seen this http://bananas.com?search=true&image=myimage.jpg", "pt")
+        assertTranslate("https://i.imgur.com/EZ3QPsw.jpg", "https://i.imgur.com/EZ3QPsw.jpg", "pt")
+        assertTranslate("https://HaveYouSeenThis.com", "https://HaveYouSeenThis.com", "pt")
+        assertTranslate("https://haveyouseenthis.com", "https://haveyouseenthis.com", "pt")
+        assertTranslate("https://i.imgur.com/asdEZ3QPsw.jpg", "https://i.imgur.com/asdEZ3QPsw.jpg", "pt")
+        assertTranslateContains("https://i.imgur.com/asdEZ3QPswadfj2389rioasdjf9834riofaj9834aKLL.jpg", "Hi there! \n How are you doing? \n https://i.imgur.com/asdEZ3QPswadfj2389rioasdjf9834riofaj9834aKLL.jpg", "pt")
+    }
+
+    @Test
+    fun testChineseWithUrlDetector() {
+        assertTranslate("I entered your home page is very carton, perhaps your attention or other data is too much, and the homepage of others is not so carton. From aMethyst client", "我进入你的主页很卡顿，也许是你的关注人数或者其他数据太多了，其他人主页没有这么卡顿。来自amethyst客户端", "en")
+    }
+
+    @Test
+    fun testTranslationEmail() {
+        assertTranslateContains("vitor@amethyst.social", "Have you seen this vitor@amethyst.social", "pt")
+    }
+
+    @Test
+    fun testTranslationLnInvoice() {
+        assertTranslateContains(
+            "lnbc12u1p3lvjeupp5a5ecgp45k6pa8tu7rnkgzfuwdy3l5ylv3k5tdzrg4cr8rj2f364sdq5g9kxy7fqd9h8vmmfvdjscqzpgxqyz5vqsp5zuzyetf33aphetf0e80w7tztw6dfsjs4lmvya4cyk8umfsx00qts9qyyssqke9hphcr36zvcav8wr502g0mhfhxpy8m9tt36zttg8vldm2qxw039ulccr8nwy3hjg2sw5vk65e99lwuhrhw0nuya2u57qszltvx7egp74jydn",
+            "Have you seen this: lnbc12u1p3lvjeupp5a5ecgp45k6pa8tu7rnkgzfuwdy3l5ylv3k5tdzrg4cr8rj2f364sdq5g9kxy7fqd9h8vmmfvdjscqzpgxqyz5vqsp5zuzyetf33aphetf0e80w7tztw6dfsjs4lmvya4cyk8umfsx00qts9qyyssqke9hphcr36zvcav8wr502g0mhfhxpy8m9tt36zttg8vldm2qxw039ulccr8nwy3hjg2sw5vk65e99lwuhrhw0nuya2u57qszltvx7egp74jydn I think I have to pay",
+            "pt"
+        )
+
+        assertTranslateContains(
+            "lnbc10u1p3l0wg0pp5y5y3vxt3429m28uuq56uqhwxadftn67yaarq06h3y9nqapz72n6sdqqxqyjw5q9q7sqqqqqqqqqqqqqqqqqqqqqqqqq9qsqsp5y2tazp42xde3c0tdsz30zqcekrt0lzrneszdtagy2qn7vs0d3p5qrzjqwryaup9lh50kkranzgcdnn2fgvx390wgj5jd07rwr3vxeje0glcll7jdvcln4lhw5qqqqlgqqqqqeqqjqdau9jzseecmvmh03h88xyf5f980xx45fmn0cej654v5jr79ye36pww90jwdda38damlmgt54v8rn6q9kywtw057rh4v3wwrmn8fajagqnssr7v",
+            "Test lnbc10u1p3l0wg0pp5y5y3vxt3429m28uuq56uqhwxadftn67yaarq06h3y9nqapz72n6sdqqxqyjw5q9q7sqqqqqqqqqqqqqqqqqqqqqqqqq9qsqsp5y2tazp42xde3c0tdsz30zqcekrt0lzrneszdtagy2qn7vs0d3p5qrzjqwryaup9lh50kkranzgcdnn2fgvx390wgj5jd07rwr3vxeje0glcll7jdvcln4lhw5qqqqlgqqqqqeqqjqdau9jzseecmvmh03h88xyf5f980xx45fmn0cej654v5jr79ye36pww90jwdda38damlmgt54v8rn6q9kywtw057rh4v3wwrmn8fajagqnssr7v",
+            "pt"
+        )
+    }
+
+    @Test
+    fun testNostrEvents() {
+        assertTranslateContains(
+            "nostr:nevent1qqs0tsw8hjacs4fppgdg7f5yhgwwfkyua4xcs3re9wwkpkk2qeu6mhql22rcy",
+            "sure, nostr:nevent1qqs0tsw8hjacs4fppgdg7f5yhgwwfkyua4xcs3re9wwkpkk2qeu6mhql22rcy",
+            "en"
+        )
+    }
+}
--- a/app/src/fdroid/java/com/vitorpamplona/amethyst/ui/components/TranslatableRichTextViewer.kt
+++ b/app/src/fdroid/java/com/vitorpamplona/amethyst/ui/components/TranslatableRichTextViewer.kt
@@ -0,0 +1,26 @@
+package com.vitorpamplona.amethyst.ui.components
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.navigation.NavController
+import com.vitorpamplona.amethyst.ui.screen.loggedIn.AccountViewModel
+
+@Composable
+fun TranslatableRichTextViewer(
+    content: String,
+    canPreview: Boolean,
+    modifier: Modifier = Modifier,
+    tags: List<List<String>>?,
+    backgroundColor: Color,
+    accountViewModel: AccountViewModel,
+    navController: NavController
+) = ExpandableRichTextViewer(
+    content,
+    canPreview,
+    modifier,
+    tags,
+    backgroundColor,
+    accountViewModel,
+    navController
+)
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -2,35 +2,67 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">

+    <uses-feature android:name="android.hardware.camera" android:required="false" />
+
    <uses-permission android:name="android.permission.INTERNET"/>
    <uses-permission android:name="android.permission.READ_MEDIA_IMAGES"/>
+    <uses-permission android:name="android.permission.READ_MEDIA_VIDEO"/>
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
+    <uses-permission android:name="android.permission.CAMERA" />
+
+    <!-- Used for SDK < 29 -->
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"
+        tools:ignore="ScopedStorage" />

    <application
-        android:allowBackup="true"
+        android:allowBackup="false"
+        android:name=".Amethyst"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:fullBackupContent="@xml/backup_rules"
-        android:icon="@drawable/amethyst_logo"
+        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
-        android:roundIcon="@drawable/amethyst_logo"
        android:enableOnBackInvokedCallback="true"
        android:supportsRtl="true"
        android:theme="@style/Theme.Amethyst"
-        tools:targetApi="31">
+        android:largeHeap="true"
+        android:usesCleartextTraffic="true"
+        android:hardwareAccelerated="true"
+        tools:targetApi="33">
        <activity
            android:name=".ui.MainActivity"
            android:exported="true"
-            android:label="@string/app_name"
+            android:windowSoftInputMode="adjustResize"
            android:theme="@style/Theme.Amethyst">
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />

+            <intent-filter android:label="Amethyst">
+                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>

+            <intent-filter android:label="Amethyst">
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+                <data android:scheme="nostr" />
+            </intent-filter>
+
+            <intent-filter android:label="Amethyst">
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+                <data android:scheme="nostrwalletconnect" />
+                <data android:scheme="nostr+walletconnect" />
+            </intent-filter>
+
            <meta-data
                android:name="android.app.lib_name"
                android:value="" />
        </activity>
+
+        <activity
+            android:name="com.journeyapps.barcodescanner.CaptureActivity"
+            android:screenOrientation="fullSensor"
+            tools:replace="screenOrientation" />
    </application>

 </manifest>
--- a/app/src/main/ic_launcher-playstore.png
+++ b/app/src/main/ic_launcher-playstore.png
--- a/app/src/main/java/com/vitorpamplona/amethyst/Amethyst.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/Amethyst.kt
@@ -0,0 +1,15 @@
+package com.vitorpamplona.amethyst
+
+import android.app.Application
+
+class Amethyst : Application() {
+    override fun onCreate() {
+        super.onCreate()
+        instance = this
+    }
+
+    companion object {
+        lateinit var instance: Amethyst
+            private set
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/EncryptedStorage.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/EncryptedStorage.kt
@@ -0,0 +1,29 @@
+package com.vitorpamplona.amethyst
+
+import androidx.security.crypto.EncryptedSharedPreferences
+import androidx.security.crypto.MasterKey
+
+object EncryptedStorage {
+    private const val PREFERENCES_NAME = "secret_keeper"
+
+    fun prefsFileName(npub: String? = null): String {
+        return if (npub == null) PREFERENCES_NAME else "${PREFERENCES_NAME}_$npub"
+    }
+
+    fun preferences(npub: String? = null): EncryptedSharedPreferences {
+        val context = Amethyst.instance
+        val masterKey: MasterKey = MasterKey.Builder(context, MasterKey.DEFAULT_MASTER_KEY_ALIAS)
+            .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
+            .build()
+
+        val preferencesName = prefsFileName(npub)
+
+        return EncryptedSharedPreferences.create(
+            context,
+            preferencesName,
+            masterKey,
+            EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
+            EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
+        ) as EncryptedSharedPreferences
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/KeyStorage.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/KeyStorage.kt
@@ -1,22 +0,0 @@
-package com.vitorpamplona.amethyst
-
-import android.content.Context
-import androidx.security.crypto.EncryptedSharedPreferences
-import androidx.security.crypto.MasterKeys
-
-class KeyStorage {
-
-  fun encryptedPreferences(context: Context): EncryptedSharedPreferences {
-    val secretKey: String = MasterKeys.getOrCreate(MasterKeys.AES256_GCM_SPEC);
-    val preferencesName = "secret_keeper"
-
-    return EncryptedSharedPreferences.create(
-      preferencesName,
-      secretKey,
-      context,
-      EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
-      EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
-    ) as EncryptedSharedPreferences
-  }
-
-}
--- a/app/src/main/java/com/vitorpamplona/amethyst/LocalPreferences.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/LocalPreferences.kt
@@ -0,0 +1,343 @@
+package com.vitorpamplona.amethyst
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.SharedPreferences
+import com.google.gson.GsonBuilder
+import com.google.gson.reflect.TypeToken
+import com.vitorpamplona.amethyst.model.Account
+import com.vitorpamplona.amethyst.model.RelaySetupInfo
+import com.vitorpamplona.amethyst.model.toByteArray
+import com.vitorpamplona.amethyst.service.model.ContactListEvent
+import com.vitorpamplona.amethyst.service.model.Event
+import com.vitorpamplona.amethyst.service.model.Event.Companion.getRefinedEvent
+import com.vitorpamplona.amethyst.service.model.LnZapEvent
+import com.vitorpamplona.amethyst.ui.actions.ServersAvailable
+import com.vitorpamplona.amethyst.ui.note.Nip47URI
+import fr.acinq.secp256k1.Hex
+import nostr.postr.Persona
+import nostr.postr.toHex
+import nostr.postr.toNpub
+import java.io.File
+import java.util.Locale
+
+// Release mode (!BuildConfig.DEBUG) always uses encrypted preferences
+// To use plaintext SharedPreferences for debugging, set this to true
+// It will only apply in Debug builds
+private const val DEBUG_PLAINTEXT_PREFERENCES = false
+private const val DEBUG_PREFERENCES_NAME = "debug_prefs"
+
+data class AccountInfo(
+    val npub: String,
+    val hasPrivKey: Boolean = false
+)
+
+private object PrefKeys {
+    const val CURRENT_ACCOUNT = "currently_logged_in_account"
+    const val SAVED_ACCOUNTS = "all_saved_accounts"
+    const val NOSTR_PRIVKEY = "nostr_privkey"
+    const val NOSTR_PUBKEY = "nostr_pubkey"
+    const val FOLLOWING_CHANNELS = "following_channels"
+    const val HIDDEN_USERS = "hidden_users"
+    const val RELAYS = "relays"
+    const val DONT_TRANSLATE_FROM = "dontTranslateFrom"
+    const val LANGUAGE_PREFS = "languagePreferences"
+    const val TRANSLATE_TO = "translateTo"
+    const val ZAP_AMOUNTS = "zapAmounts"
+    const val DEFAULT_ZAPTYPE = "defaultZapType"
+    const val DEFAULT_FILE_SERVER = "defaultFileServer"
+    const val ZAP_PAYMENT_REQUEST_SERVER = "zapPaymentServer"
+    const val LATEST_CONTACT_LIST = "latestContactList"
+    const val HIDE_DELETE_REQUEST_DIALOG = "hide_delete_request_dialog"
+    const val HIDE_BLOCK_ALERT_DIALOG = "hide_block_alert_dialog"
+    val LAST_READ: (String) -> String = { route -> "last_read_route_$route" }
+}
+
+private val gson = GsonBuilder().create()
+
+object LocalPreferences {
+    private const val comma = ","
+
+    private var _currentAccount: String? = null
+
+    private fun currentAccount(): String? {
+        if (_currentAccount == null) {
+            _currentAccount = encryptedPreferences().getString(PrefKeys.CURRENT_ACCOUNT, null)
+        }
+        return _currentAccount
+    }
+
+    private fun updateCurrentAccount(npub: String) {
+        if (_currentAccount != npub) {
+            _currentAccount = npub
+
+            encryptedPreferences().edit().apply {
+                putString(PrefKeys.CURRENT_ACCOUNT, npub)
+            }.apply()
+        }
+    }
+
+    private var _savedAccounts: List<String>? = null
+
+    private fun savedAccounts(): List<String> {
+        if (_savedAccounts == null) {
+            _savedAccounts = encryptedPreferences()
+                .getString(PrefKeys.SAVED_ACCOUNTS, null)?.split(comma) ?: listOf()
+        }
+        return _savedAccounts!!
+    }
+
+    private fun updateSavedAccounts(accounts: List<String>) {
+        if (_savedAccounts != accounts) {
+            _savedAccounts = accounts
+
+            encryptedPreferences().edit().apply {
+                putString(PrefKeys.SAVED_ACCOUNTS, accounts.joinToString(comma).ifBlank { null })
+            }.apply()
+        }
+    }
+
+    private val prefsDirPath: String
+        get() = "${Amethyst.instance.filesDir.parent}/shared_prefs/"
+
+    private fun addAccount(npub: String) {
+        val accounts = savedAccounts().toMutableList()
+        if (npub !in accounts) {
+            accounts.add(npub)
+            updateSavedAccounts(accounts)
+        }
+    }
+
+    private fun setCurrentAccount(account: Account) {
+        val npub = account.userProfile().pubkeyNpub()
+        updateCurrentAccount(npub)
+        addAccount(npub)
+    }
+
+    fun switchToAccount(npub: String) {
+        updateCurrentAccount(npub)
+    }
+
+    /**
+     * Removes the account from the app level shared preferences
+     */
+    private fun removeAccount(npub: String) {
+        val accounts = savedAccounts().toMutableList()
+        if (accounts.remove(npub)) {
+            updateSavedAccounts(accounts)
+        }
+    }
+
+    /**
+     * Deletes the npub-specific shared preference file
+     */
+    private fun deleteUserPreferenceFile(npub: String) {
+        val prefsDir = File(prefsDirPath)
+        prefsDir.list()?.forEach {
+            if (it.contains(npub)) {
+                File(prefsDir, it).delete()
+            }
+        }
+    }
+
+    private fun encryptedPreferences(npub: String? = null): SharedPreferences {
+        return if (BuildConfig.DEBUG && DEBUG_PLAINTEXT_PREFERENCES) {
+            val preferenceFile = if (npub == null) DEBUG_PREFERENCES_NAME else "${DEBUG_PREFERENCES_NAME}_$npub"
+            Amethyst.instance.getSharedPreferences(preferenceFile, Context.MODE_PRIVATE)
+        } else {
+            return EncryptedStorage.preferences(npub)
+        }
+    }
+
+    /**
+     * Clears the preferences for a given npub, deletes the preferences xml file,
+     * and switches the user to the first account in the list if it exists
+     *
+     * We need to use `commit()` to write changes to disk and release the file
+     * lock so that it can be deleted. If we use `apply()` there is a race
+     * condition and the file will probably not be deleted
+     */
+    @SuppressLint("ApplySharedPref")
+    fun updatePrefsForLogout(npub: String) {
+        val userPrefs = encryptedPreferences(npub)
+        userPrefs.edit().clear().commit()
+        removeAccount(npub)
+        deleteUserPreferenceFile(npub)
+
+        if (savedAccounts().isEmpty()) {
+            val appPrefs = encryptedPreferences()
+            appPrefs.edit().clear().apply()
+        } else if (currentAccount() == npub) {
+            updateCurrentAccount(savedAccounts().elementAt(0))
+        }
+    }
+
+    fun updatePrefsForLogin(account: Account) {
+        setCurrentAccount(account)
+        saveToEncryptedStorage(account)
+    }
+
+    fun allSavedAccounts(): List<AccountInfo> {
+        return savedAccounts().map { npub ->
+            AccountInfo(npub = npub)
+        }
+    }
+
+    fun saveToEncryptedStorage(account: Account) {
+        val prefs = encryptedPreferences(account.userProfile().pubkeyNpub())
+        prefs.edit().apply {
+            account.loggedIn.privKey?.let { putString(PrefKeys.NOSTR_PRIVKEY, it.toHex()) }
+            account.loggedIn.pubKey.let { putString(PrefKeys.NOSTR_PUBKEY, it.toHex()) }
+            putStringSet(PrefKeys.FOLLOWING_CHANNELS, account.followingChannels)
+            putStringSet(PrefKeys.HIDDEN_USERS, account.hiddenUsers)
+            putString(PrefKeys.RELAYS, gson.toJson(account.localRelays))
+            putStringSet(PrefKeys.DONT_TRANSLATE_FROM, account.dontTranslateFrom)
+            putString(PrefKeys.LANGUAGE_PREFS, gson.toJson(account.languagePreferences))
+            putString(PrefKeys.TRANSLATE_TO, account.translateTo)
+            putString(PrefKeys.ZAP_AMOUNTS, gson.toJson(account.zapAmountChoices))
+            putString(PrefKeys.DEFAULT_ZAPTYPE, gson.toJson(account.defaultZapType))
+            putString(PrefKeys.DEFAULT_FILE_SERVER, gson.toJson(account.defaultFileServer))
+            putString(PrefKeys.ZAP_PAYMENT_REQUEST_SERVER, gson.toJson(account.zapPaymentRequest))
+            putString(PrefKeys.LATEST_CONTACT_LIST, Event.gson.toJson(account.backupContactList))
+            putBoolean(PrefKeys.HIDE_DELETE_REQUEST_DIALOG, account.hideDeleteRequestDialog)
+            putBoolean(PrefKeys.HIDE_BLOCK_ALERT_DIALOG, account.hideBlockAlertDialog)
+        }.apply()
+    }
+
+    fun loadFromEncryptedStorage(): Account? {
+        encryptedPreferences(currentAccount()).apply {
+            val pubKey = getString(PrefKeys.NOSTR_PUBKEY, null) ?: return null
+            val privKey = getString(PrefKeys.NOSTR_PRIVKEY, null)
+            val followingChannels = getStringSet(PrefKeys.FOLLOWING_CHANNELS, null) ?: setOf()
+            val hiddenUsers = getStringSet(PrefKeys.HIDDEN_USERS, emptySet()) ?: setOf()
+            val localRelays = gson.fromJson(
+                getString(PrefKeys.RELAYS, "[]"),
+                object : TypeToken<Set<RelaySetupInfo>>() {}.type
+            ) ?: setOf<RelaySetupInfo>()
+
+            val dontTranslateFrom = getStringSet(PrefKeys.DONT_TRANSLATE_FROM, null) ?: setOf()
+            val translateTo = getString(PrefKeys.TRANSLATE_TO, null) ?: Locale.getDefault().language
+
+            val zapAmountChoices = gson.fromJson(
+                getString(PrefKeys.ZAP_AMOUNTS, "[]"),
+                object : TypeToken<List<Long>>() {}.type
+            ) ?: listOf(500L, 1000L, 5000L)
+
+            val defaultZapType = gson.fromJson(
+                getString(PrefKeys.DEFAULT_ZAPTYPE, "PUBLIC"),
+                object : TypeToken<LnZapEvent.ZapType>() {}.type
+            ) ?: LnZapEvent.ZapType.PUBLIC
+
+            val defaultFileServer = gson.fromJson(
+                getString(PrefKeys.DEFAULT_FILE_SERVER, "IMGUR"),
+                object : TypeToken<ServersAvailable>() {}.type
+            ) ?: ServersAvailable.IMGUR
+
+            val zapPaymentRequestServer = try {
+                getString(PrefKeys.ZAP_PAYMENT_REQUEST_SERVER, null)?.let {
+                    gson.fromJson(it, Nip47URI::class.java)
+                }
+            } catch (e: Throwable) {
+                e.printStackTrace()
+                null
+            }
+
+            val latestContactList = try {
+                getString(PrefKeys.LATEST_CONTACT_LIST, null)?.let {
+                    Event.gson.fromJson(it, Event::class.java)
+                        .getRefinedEvent(true) as ContactListEvent
+                }
+            } catch (e: Throwable) {
+                e.printStackTrace()
+                null
+            }
+
+            val languagePreferences = try {
+                getString(PrefKeys.LANGUAGE_PREFS, null)?.let {
+                    gson.fromJson(
+                        it,
+                        object : TypeToken<Map<String, String>>() {}.type
+                    ) as Map<String, String>
+                } ?: mapOf()
+            } catch (e: Throwable) {
+                e.printStackTrace()
+                mapOf()
+            }
+
+            val hideDeleteRequestDialog = getBoolean(PrefKeys.HIDE_DELETE_REQUEST_DIALOG, false)
+            val hideBlockAlertDialog = getBoolean(PrefKeys.HIDE_BLOCK_ALERT_DIALOG, false)
+
+            val a = Account(
+                Persona(privKey = privKey?.toByteArray(), pubKey = pubKey.toByteArray()),
+                followingChannels,
+                hiddenUsers,
+                localRelays,
+                dontTranslateFrom,
+                languagePreferences,
+                translateTo,
+                zapAmountChoices,
+                defaultZapType,
+                defaultFileServer,
+                zapPaymentRequestServer,
+                hideDeleteRequestDialog,
+                hideBlockAlertDialog,
+                latestContactList
+            )
+
+            return a
+        }
+    }
+
+    fun saveLastRead(route: String, timestampInSecs: Long) {
+        encryptedPreferences(currentAccount()).edit().apply {
+            putLong(PrefKeys.LAST_READ(route), timestampInSecs)
+        }.apply()
+    }
+
+    fun loadLastRead(route: String): Long {
+        encryptedPreferences(currentAccount()).run {
+            return getLong(PrefKeys.LAST_READ(route), 0)
+        }
+    }
+
+    fun migrateSingleUserPrefs() {
+        if (currentAccount() != null) return
+
+        val pubkey = encryptedPreferences().getString(PrefKeys.NOSTR_PUBKEY, null) ?: return
+        val npub = Hex.decode(pubkey).toNpub()
+
+        val stringPrefs = listOf(
+            PrefKeys.NOSTR_PRIVKEY,
+            PrefKeys.NOSTR_PUBKEY,
+            PrefKeys.RELAYS,
+            PrefKeys.LANGUAGE_PREFS,
+            PrefKeys.TRANSLATE_TO,
+            PrefKeys.ZAP_AMOUNTS,
+            PrefKeys.LATEST_CONTACT_LIST
+        )
+
+        val stringSetPrefs = listOf(
+            PrefKeys.FOLLOWING_CHANNELS,
+            PrefKeys.HIDDEN_USERS,
+            PrefKeys.DONT_TRANSLATE_FROM
+        )
+
+        encryptedPreferences().apply {
+            val appPrefs = this
+            encryptedPreferences(npub).edit().apply {
+                val userPrefs = this
+
+                stringPrefs.forEach { userPrefs.putString(it, appPrefs.getString(it, null)) }
+                stringSetPrefs.forEach { userPrefs.putStringSet(it, appPrefs.getStringSet(it, null)) }
+                userPrefs.putBoolean(
+                    PrefKeys.HIDE_DELETE_REQUEST_DIALOG,
+                    appPrefs.getBoolean(PrefKeys.HIDE_DELETE_REQUEST_DIALOG, false)
+                )
+            }.apply()
+        }
+
+        encryptedPreferences().edit().clear().apply()
+        addAccount(npub)
+        updateCurrentAccount(npub)
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/NotificationCache.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/NotificationCache.kt
@@ -0,0 +1,56 @@
+package com.vitorpamplona.amethyst
+
+import androidx.lifecycle.LiveData
+import com.vitorpamplona.amethyst.ui.components.BundledUpdate
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+
+object NotificationCache {
+    val lastReadByRoute = mutableMapOf<String, Long>()
+
+    fun markAsRead(route: String, timestampInSecs: Long) {
+        val lastTime = lastReadByRoute[route]
+        if (lastTime == null || timestampInSecs > lastTime) {
+            lastReadByRoute.put(route, timestampInSecs)
+
+            val scope = CoroutineScope(Job() + Dispatchers.IO)
+            scope.launch {
+                LocalPreferences.saveLastRead(route, timestampInSecs)
+                live.invalidateData()
+            }
+        }
+    }
+
+    fun load(route: String): Long {
+        var lastTime = lastReadByRoute[route]
+        if (lastTime == null) {
+            lastTime = LocalPreferences.loadLastRead(route)
+            lastReadByRoute[route] = lastTime
+        }
+        return lastTime
+    }
+
+    // Observers line up here.
+    val live: NotificationLiveData = NotificationLiveData(this)
+}
+
+class NotificationLiveData(val cache: NotificationCache) : LiveData<NotificationState>(NotificationState(cache)) {
+    // Refreshes observers in batches.
+    private val bundler = BundledUpdate(300, Dispatchers.Main) {
+        if (hasActiveObservers()) {
+            refresh()
+        }
+    }
+
+    fun invalidateData() {
+        bundler.invalidate()
+    }
+
+    fun refresh() {
+        postValue(NotificationState(cache))
+    }
+}
+
+class NotificationState(val cache: NotificationCache)
--- a/app/src/main/java/com/vitorpamplona/amethyst/ServiceManager.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/ServiceManager.kt
@@ -0,0 +1,79 @@
+package com.vitorpamplona.amethyst
+
+import com.vitorpamplona.amethyst.model.Account
+import com.vitorpamplona.amethyst.model.LocalCache
+import com.vitorpamplona.amethyst.service.NostrAccountDataSource
+import com.vitorpamplona.amethyst.service.NostrChannelDataSource
+import com.vitorpamplona.amethyst.service.NostrChatroomListDataSource
+import com.vitorpamplona.amethyst.service.NostrGlobalDataSource
+import com.vitorpamplona.amethyst.service.NostrHomeDataSource
+import com.vitorpamplona.amethyst.service.NostrSingleChannelDataSource
+import com.vitorpamplona.amethyst.service.NostrSingleEventDataSource
+import com.vitorpamplona.amethyst.service.NostrSingleUserDataSource
+import com.vitorpamplona.amethyst.service.NostrThreadDataSource
+import com.vitorpamplona.amethyst.service.NostrUserProfileDataSource
+import com.vitorpamplona.amethyst.service.relays.Client
+import com.vitorpamplona.amethyst.service.relays.Constants
+
+object ServiceManager {
+    private var account: Account? = null
+
+    fun start(account: Account) {
+        this.account = account
+        start()
+    }
+
+    fun start() {
+        val myAccount = account
+
+        if (myAccount != null) {
+            Client.connect(myAccount.activeRelays() ?: myAccount.convertLocalRelays())
+
+            // start services
+            NostrAccountDataSource.account = myAccount
+            NostrHomeDataSource.account = myAccount
+            NostrChatroomListDataSource.account = myAccount
+
+            // Notification Elements
+            NostrAccountDataSource.start()
+            NostrHomeDataSource.start()
+            NostrChatroomListDataSource.start()
+
+            // More Info Data Sources
+            NostrSingleEventDataSource.start()
+            NostrSingleChannelDataSource.start()
+            NostrSingleUserDataSource.start()
+        } else {
+            // if not logged in yet, start a basic service wit default relays
+            Client.connect(Constants.convertDefaultRelays())
+        }
+    }
+
+    fun pause() {
+        NostrAccountDataSource.stop()
+        NostrHomeDataSource.stop()
+        NostrChannelDataSource.stop()
+        NostrChatroomListDataSource.stop()
+
+        NostrGlobalDataSource.stop()
+        NostrSingleChannelDataSource.stop()
+        NostrSingleEventDataSource.stop()
+        NostrSingleUserDataSource.stop()
+        NostrThreadDataSource.stop()
+        NostrUserProfileDataSource.stop()
+
+        Client.disconnect()
+    }
+
+    fun cleanUp() {
+        LocalCache.cleanObservers()
+
+        account?.let {
+            LocalCache.pruneOldAndHiddenMessages(it)
+            LocalCache.pruneHiddenMessages(it)
+            LocalCache.pruneContactLists(it)
+            LocalCache.pruneFileStorageEvents(it)
+            // LocalCache.pruneNonFollows(it)
+        }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/VideoCache.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/VideoCache.kt
@@ -0,0 +1,43 @@
+package com.vitorpamplona.amethyst
+
+import android.content.Context
+import com.google.android.exoplayer2.database.StandaloneDatabaseProvider
+import com.google.android.exoplayer2.upstream.DefaultHttpDataSource
+import com.google.android.exoplayer2.upstream.cache.CacheDataSource
+import com.google.android.exoplayer2.upstream.cache.LeastRecentlyUsedCacheEvictor
+import com.google.android.exoplayer2.upstream.cache.SimpleCache
+
+object VideoCache {
+
+    var exoPlayerCacheSize: Long = 90 * 1024 * 1024 // 90MB
+
+    var leastRecentlyUsedCacheEvictor = LeastRecentlyUsedCacheEvictor(exoPlayerCacheSize)
+
+    lateinit var exoDatabaseProvider: StandaloneDatabaseProvider
+    lateinit var simpleCache: SimpleCache
+
+    lateinit var cacheDataSourceFactory: CacheDataSource.Factory
+
+    fun init(context: Context) {
+        if (!this::simpleCache.isInitialized) {
+            exoDatabaseProvider = StandaloneDatabaseProvider(context)
+
+            simpleCache = SimpleCache(
+                context.cacheDir,
+                leastRecentlyUsedCacheEvictor,
+                exoDatabaseProvider
+            )
+
+            cacheDataSourceFactory = CacheDataSource.Factory()
+                .setCache(simpleCache)
+                .setUpstreamDataSourceFactory(
+                    DefaultHttpDataSource.Factory().setAllowCrossProtocolRedirects(true)
+                )
+                .setFlags(CacheDataSource.FLAG_IGNORE_CACHE_ON_ERROR)
+        }
+    }
+
+    fun get(): CacheDataSource.Factory {
+        return cacheDataSourceFactory
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/model/Account.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/model/Account.kt
--- a/app/src/main/java/com/vitorpamplona/amethyst/model/AntiSpamFilter.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/model/AntiSpamFilter.kt
@@ -0,0 +1,73 @@
+package com.vitorpamplona.amethyst.model
+
+import android.util.Log
+import android.util.LruCache
+import androidx.lifecycle.LiveData
+import com.vitorpamplona.amethyst.service.model.Event
+import com.vitorpamplona.amethyst.service.relays.Relay
+import com.vitorpamplona.amethyst.ui.components.BundledUpdate
+import kotlinx.coroutines.Dispatchers
+
+data class Spammer(val pubkeyHex: HexKey, var duplicatedMessages: Set<HexKey>)
+
+class AntiSpamFilter {
+    val recentMessages = LruCache<Int, String>(1000)
+    val spamMessages = LruCache<Int, Spammer>(1000)
+
+    @Synchronized
+    fun isSpam(event: Event, relay: Relay?): Boolean {
+        val idHex = event.id
+
+        // if short message, ok
+        if (event.content.length < 50) return false
+
+        // double list strategy:
+        // if duplicated, it goes into spam. 1000 spam messages are saved into the spam list.
+
+        // Considers tags so that same replies to different people don't count.
+        val hash = (event.content + event.tags.flatten().joinToString(",")).hashCode()
+
+        if ((recentMessages[hash] != null && recentMessages[hash] != idHex) || spamMessages[hash] != null) {
+            Log.w("Potential SPAM Message", "${event.id} ${recentMessages[hash]} ${spamMessages[hash] != null} ${relay?.url} ${event.content.replace("\n", " | ")}")
+
+            // Log down offenders
+            if (spamMessages.get(hash) == null) {
+                spamMessages.put(hash, Spammer(event.pubKey, setOf(recentMessages[hash], event.id)))
+                liveSpam.invalidateData()
+            } else {
+                val spammer = spamMessages.get(hash)
+                spammer.duplicatedMessages = spammer.duplicatedMessages + event.id
+
+                liveSpam.invalidateData()
+            }
+
+            return true
+        }
+
+        recentMessages.put(hash, idHex)
+
+        return false
+    }
+
+    val liveSpam: AntiSpamLiveData = AntiSpamLiveData(this)
+}
+
+class AntiSpamLiveData(val cache: AntiSpamFilter) : LiveData<AntiSpamState>(AntiSpamState(cache)) {
+
+    // Refreshes observers in batches.
+    private val bundler = BundledUpdate(300, Dispatchers.Main) {
+        if (hasActiveObservers()) {
+            refresh()
+        }
+    }
+
+    fun invalidateData() {
+        bundler.invalidate()
+    }
+
+    private fun refresh() {
+        postValue(AntiSpamState(cache))
+    }
+}
+
+class AntiSpamState(val cache: AntiSpamFilter)
--- a/app/src/main/java/com/vitorpamplona/amethyst/model/Channel.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/model/Channel.kt
@@ -0,0 +1,102 @@
+package com.vitorpamplona.amethyst.model
+
+import androidx.lifecycle.LiveData
+import com.vitorpamplona.amethyst.service.NostrSingleChannelDataSource
+import com.vitorpamplona.amethyst.service.model.ChannelCreateEvent
+import com.vitorpamplona.amethyst.ui.components.BundledUpdate
+import com.vitorpamplona.amethyst.ui.note.toShortenHex
+import fr.acinq.secp256k1.Hex
+import kotlinx.coroutines.Dispatchers
+import java.util.concurrent.ConcurrentHashMap
+
+class Channel(val idHex: String) {
+    var creator: User? = null
+    var info = ChannelCreateEvent.ChannelData(null, null, null)
+
+    var updatedMetadataAt: Long = 0
+
+    val notes = ConcurrentHashMap<HexKey, Note>()
+
+    fun id() = Hex.decode(idHex)
+    fun idNote() = id().toNote()
+    fun idDisplayNote() = idNote().toShortenHex()
+
+    fun toBestDisplayName(): String {
+        return info.name ?: idDisplayNote()
+    }
+
+    fun addNote(note: Note) {
+        notes[note.idHex] = note
+    }
+
+    fun removeNote(note: Note) {
+        notes.remove(note.idHex)
+    }
+
+    fun updateChannelInfo(creator: User, channelInfo: ChannelCreateEvent.ChannelData, updatedAt: Long) {
+        this.creator = creator
+        this.info = channelInfo
+        this.updatedMetadataAt = updatedAt
+
+        live.invalidateData()
+    }
+
+    fun profilePicture(): String? {
+        if (info.picture.isNullOrBlank()) info.picture = null
+        return info.picture
+    }
+
+    fun anyNameStartsWith(prefix: String): Boolean {
+        return listOfNotNull(info.name, info.about)
+            .filter { it.startsWith(prefix, true) }.isNotEmpty()
+    }
+
+    // Observers line up here.
+    val live: ChannelLiveData = ChannelLiveData(this)
+
+    fun pruneOldAndHiddenMessages(account: Account): Set<Note> {
+        val important = notes.values
+            .filter { it.author?.let { it1 -> account.isHidden(it1) } == false }
+            .sortedBy { it.createdAt() }
+            .reversed()
+            .take(1000)
+            .toSet()
+
+        val toBeRemoved = notes.values.filter { it !in important }.toSet()
+
+        toBeRemoved.forEach {
+            notes.remove(it.idHex)
+        }
+
+        return toBeRemoved
+    }
+}
+
+class ChannelLiveData(val channel: Channel) : LiveData<ChannelState>(ChannelState(channel)) {
+    // Refreshes observers in batches.
+    private val bundler = BundledUpdate(300, Dispatchers.Main) {
+        if (hasActiveObservers()) {
+            refresh()
+        }
+    }
+
+    fun invalidateData() {
+        bundler.invalidate()
+    }
+
+    private fun refresh() {
+        postValue(ChannelState(channel))
+    }
+
+    override fun onActive() {
+        super.onActive()
+        NostrSingleChannelDataSource.add(channel.idHex)
+    }
+
+    override fun onInactive() {
+        super.onInactive()
+        NostrSingleChannelDataSource.remove(channel.idHex)
+    }
+}
+
+class ChannelState(val channel: Channel)
--- a/app/src/main/java/com/vitorpamplona/amethyst/model/HashtagIcon.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/model/HashtagIcon.kt
@@ -0,0 +1,27 @@
+package com.vitorpamplona.amethyst.model
+import androidx.compose.foundation.layout.padding
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+import com.vitorpamplona.amethyst.R
+fun checkForHashtagWithIcon(tag: String): HashtagIcon? {
+    return when (tag.lowercase()) {
+        "bitcoin", "btc", "timechain" -> HashtagIcon(R.drawable.ht_btc, "Bitcoin", Color.Unspecified, Modifier.padding(2.dp, 2.dp, 0.dp, 0.dp))
+        "nostr", "nostrich", "nostriches" -> HashtagIcon(R.drawable.ht_nostr, "Nostr", Color.Unspecified, Modifier.padding(1.dp, 2.dp, 0.dp, 0.dp))
+        "lightning", "lightningnetwork" -> HashtagIcon(R.drawable.ht_lightning, "Lightning", Color.Unspecified, Modifier.padding(1.dp, 3.dp, 0.dp, 0.dp))
+        "zap", "zaps", "zapper", "zappers", "zapping", "zapped", "zapathon", "zapraiser", "zaplife", "zapchain" -> HashtagIcon(R.drawable.zap, "Zap", Color.Unspecified, Modifier.padding(1.dp, 3.dp, 0.dp, 0.dp))
+        "amethyst" -> HashtagIcon(R.drawable.amethyst, "Amethyst", Color.Unspecified, Modifier.padding(3.dp, 2.dp, 0.dp, 0.dp))
+        "plebs", "pleb", "plebchain" -> HashtagIcon(R.drawable.plebs, "Pleb", Color.Unspecified, Modifier.padding(2.dp, 2.dp, 0.dp, 1.dp))
+        "coffee", "coffeechain", "cafe" -> HashtagIcon(R.drawable.coffee, "Coffee", Color.Unspecified, Modifier.padding(2.dp, 2.dp, 0.dp, 0.dp))
+        "skullofsatoshi" -> HashtagIcon(R.drawable.skull, "SkullofSatoshi", Color.Unspecified, Modifier.padding(2.dp, 1.dp, 0.dp, 0.dp))
+        "grownostr", "#permaculture", "#gardening", "#garden" -> HashtagIcon(R.drawable.grownostr, "GrowNostr", Color.Unspecified, Modifier.padding(0.dp, 1.dp, 0.dp, 1.dp))
+        "footstr" -> HashtagIcon(R.drawable.footstr, "Footstr", Color.Unspecified, Modifier.padding(1.dp, 1.dp, 0.dp, 0.dp))
+        else -> null
+    }
+}
+class HashtagIcon(
+    val icon: Int,
+    val description: String,
+    val color: Color,
+    val modifier: Modifier
+)
--- a/app/src/main/java/com/vitorpamplona/amethyst/model/Hex.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/model/Hex.kt
@@ -1,39 +1,102 @@
 package com.vitorpamplona.amethyst.model

-import com.vitorpamplona.amethyst.ui.note.toDisplayHex
+import com.vitorpamplona.amethyst.service.nip19.Nip19
+import com.vitorpamplona.amethyst.ui.note.toShortenHex
 import fr.acinq.secp256k1.Hex
-import java.util.regex.Pattern
 import nostr.postr.Bech32
 import nostr.postr.Persona
 import nostr.postr.bechToBytes
 import nostr.postr.toHex
+import nostr.postr.toNpub

 /** Makes the distinction between String and Hex **/
 typealias HexKey = String

+typealias NPubKey = String
+typealias NoteId = String
+
+fun NPubKey.toDisplayKey(): String {
+    return this.toShortenHex()
+}
+
+fun NoteId.toDisplayId(): String {
+    return this.toShortenHex()
+}
+
 fun ByteArray.toNote() = Bech32.encodeBytes(hrp = "note", this, Bech32.Encoding.Bech32)

 fun ByteArray.toHexKey(): HexKey {
-  return toHex()
+    return toHex()
 }

 fun HexKey.toByteArray(): ByteArray {
-  return Hex.decode(this)
+    return Hex.decode(this)
 }

 fun HexKey.toDisplayHexKey(): String {
-  return this.toDisplayHex()
+    return this.toShortenHex()
 }

 fun decodePublicKey(key: String): ByteArray {
-  val pattern = Pattern.compile(".+@.+\\.[a-z]+")
+    val parsed = Nip19.uriToRoute(key)
+    val pubKeyParsed = parsed?.hex?.toByteArray()

-  return if (key.startsWith("nsec")) {
-    Persona(privKey = key.bechToBytes()).pubKey
-  } else if (key.startsWith("npub")) {
-    key.bechToBytes()
-  } else { //if (pattern.matcher(key).matches()) {
-  //} else {
-    Hex.decode(key)
-  }
-}
+    return if (key.startsWith("nsec")) {
+        Persona(privKey = key.bechToBytes()).pubKey
+    } else if (pubKeyParsed != null) {
+        pubKeyParsed
+    } else {
+        Hex.decode(key)
+    }
+}
+
+data class DirtyKeyInfo(val key: Nip19.Return, val restOfWord: String)
+
+fun parseDirtyWordForKey(mightBeAKey: String): DirtyKeyInfo? {
+    var key = mightBeAKey
+    if (key.startsWith("nostr:", true)) {
+        key = key.substring("nostr:".length)
+    }
+
+    key = key.removePrefix("@")
+
+    if (key.length < 63) {
+        return null
+    }
+
+    try {
+        val keyB32 = key.substring(0, 63)
+        val restOfWord = key.substring(63)
+
+        if (key.startsWith("nsec1", true)) {
+            // Converts to npub
+            val pubkey = Nip19.uriToRoute(Persona(privKey = keyB32.bechToBytes()).pubKey.toNpub()) ?: return null
+
+            return DirtyKeyInfo(pubkey, restOfWord)
+        } else if (key.startsWith("npub1", true)) {
+            val pubkey = Nip19.uriToRoute(keyB32) ?: return null
+
+            return DirtyKeyInfo(pubkey, restOfWord)
+        } else if (key.startsWith("note1", true)) {
+            val noteId = Nip19.uriToRoute(keyB32) ?: return null
+
+            return DirtyKeyInfo(noteId, restOfWord)
+        } else if (key.startsWith("nprofile", true)) {
+            val pubkeyRelay = Nip19.uriToRoute(keyB32 + restOfWord) ?: return null
+
+            return DirtyKeyInfo(pubkeyRelay, pubkeyRelay.additionalChars)
+        } else if (key.startsWith("nevent1", true)) {
+            val noteRelayId = Nip19.uriToRoute(keyB32 + restOfWord) ?: return null
+
+            return DirtyKeyInfo(noteRelayId, noteRelayId.additionalChars)
+        } else if (key.startsWith("naddr1", true)) {
+            val address = Nip19.uriToRoute(keyB32 + restOfWord) ?: return null
+
+            return DirtyKeyInfo(address, address.additionalChars) // no way to know when they address ends and dirt begins
+        }
+    } catch (e: Exception) {
+        e.printStackTrace()
+    }
+
+    return null
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/model/LocalCache.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/model/LocalCache.kt
--- a/app/src/main/java/com/vitorpamplona/amethyst/model/Note.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/model/Note.kt
@@ -1,41 +1,85 @@
 package com.vitorpamplona.amethyst.model

 import androidx.lifecycle.LiveData
-import com.baha.url.preview.UrlInfoItem
 import com.vitorpamplona.amethyst.service.NostrSingleEventDataSource
-import com.vitorpamplona.amethyst.ui.note.toDisplayHex
+import com.vitorpamplona.amethyst.service.model.*
+import com.vitorpamplona.amethyst.service.nip19.Nip19
+import com.vitorpamplona.amethyst.service.relays.EOSETime
+import com.vitorpamplona.amethyst.service.relays.Relay
+import com.vitorpamplona.amethyst.ui.components.BundledUpdate
+import com.vitorpamplona.amethyst.ui.note.toShortenHex
 import fr.acinq.secp256k1.Hex
+import kotlinx.coroutines.Dispatchers
+import java.math.BigDecimal
 import java.time.Instant
 import java.time.ZoneId
 import java.time.format.DateTimeFormatter
-import java.util.Collections
-import nostr.postr.events.Event
+import java.util.Date
+import java.util.regex.Pattern

-class Note(val idHex: String) {
-    // These fields are always available.
-    // They are immutable
-    val id = Hex.decode(idHex)
-    val idDisplayHex = id.toDisplayHex()
+val tagSearch = Pattern.compile("(?:\\s|\\A)\\#\\[([0-9]+)\\]")

+class AddressableNote(val address: ATag) : Note(address.toTag()) {
+    override fun idNote() = address.toNAddr()
+    override fun toNEvent() = address.toNAddr()
+    override fun idDisplayNote() = idNote().toShortenHex()
+    override fun address() = address
+    override fun createdAt() = (event as? LongTextNoteEvent)?.publishedAt() ?: event?.createdAt()
+}
+
+open class Note(val idHex: String) {
    // These fields are only available after the Text Note event is received.
    // They are immutable after that.
-    var event: Event? = null
+    var event: EventInterface? = null
    var author: User? = null
-    var mentions: List<User>? = null
-    var replyTo: MutableList<Note>? = null
+    var replyTo: List<Note>? = null

    // These fields are updated every time an event related to this note is received.
-    val replies = Collections.synchronizedSet(mutableSetOf<Note>())
-    val reactions = Collections.synchronizedSet(mutableSetOf<Note>())
-    val boosts = Collections.synchronizedSet(mutableSetOf<Note>())
+    var replies = setOf<Note>()
+        private set
+    var reactions = setOf<Note>()
+        private set
+    var boosts = setOf<Note>()
+        private set
+    var reports = mapOf<User, Set<Note>>()
+        private set
+    var zaps = mapOf<Note, Note?>()
+        private set

-    fun loadEvent(event: Event, author: User, mentions: List<User>, replyTo: MutableList<Note>) {
+    var relays = setOf<String>()
+        private set
+
+    var lastReactionsDownloadTime: Map<String, EOSETime> = emptyMap()
+
+    fun id() = Hex.decode(idHex)
+    open fun idNote() = id().toNote()
+
+    open fun toNEvent(): String {
+        return Nip19.createNEvent(idHex, author?.pubkeyHex, event?.kind(), relays.firstOrNull())
+    }
+
+    open fun idDisplayNote() = idNote().toShortenHex()
+
+    fun channelHex(): HexKey? {
+        return (event as? ChannelMessageEvent)?.channel()
+            ?: (event as? ChannelMetadataEvent)?.channel()
+            ?: (event as? ChannelCreateEvent)?.id
+    }
+
+    fun channel(): Channel? {
+        return channelHex()?.let { LocalCache.checkGetOrCreateChannel(it) }
+    }
+
+    open fun address(): ATag? = null
+
+    open fun createdAt() = event?.createdAt()
+
+    fun loadEvent(event: Event, author: User, replyTo: List<Note>) {
        this.event = event
        this.author = author
-        this.mentions = mentions
        this.replyTo = replyTo

-        refreshObservers()
+        liveSet?.metadata?.invalidateData()
    }

    fun formattedDateTime(timestamp: Long): String {
@@ -43,72 +87,294 @@ class Note(val idHex: String) {
            .format(DateTimeFormatter.ofPattern("uuuu-MM-dd-HH:mm:ss"))
    }

-    fun replyLevelSignature(): String {
+    /**
+     * This method caches signatures during each execution to avoid recalculation in longer threads
+     */
+    fun replyLevelSignature(cachedSignatures: MutableMap<Note, String> = mutableMapOf()): String {
        val replyTo = replyTo
        if (replyTo == null || replyTo.isEmpty()) {
-            return "/" + formattedDateTime(event?.createdAt ?: 0) + ";"
+            return "/" + formattedDateTime(createdAt() ?: 0) + ";"
        }

        return replyTo
-            .map { it.replyLevelSignature() }
-            .maxBy { it.length }.removeSuffix(";") + "/" + formattedDateTime(event?.createdAt ?: 0) + ";"
+            .map {
+                cachedSignatures[it] ?: it.replyLevelSignature(cachedSignatures).apply { cachedSignatures.put(it, this) }
+            }
+            .maxBy { it.length }.removeSuffix(";") + "/" + formattedDateTime(createdAt() ?: 0) + ";"
    }

-    fun replyLevel(): Int {
+    fun replyLevel(cachedLevels: MutableMap<Note, Int> = mutableMapOf()): Int {
        val replyTo = replyTo
        if (replyTo == null || replyTo.isEmpty()) {
            return 0
        }

        return replyTo.maxOf {
-            it.replyLevel()
+            cachedLevels[it] ?: it.replyLevel(cachedLevels).apply { cachedLevels.put(it, this) }
        } + 1
    }

    fun addReply(note: Note) {
-        if (replies.add(note))
-            refreshObservers()
+        if (note !in replies) {
+            replies = replies + note
+            liveSet?.replies?.invalidateData()
+        }
+    }
+
+    fun removeReply(note: Note) {
+        replies = replies - note
+        liveSet?.replies?.invalidateData()
+    }
+    fun removeBoost(note: Note) {
+        boosts = boosts - note
+        liveSet?.boosts?.invalidateData()
+    }
+    fun removeReaction(note: Note) {
+        reactions = reactions - note
+        liveSet?.reactions?.invalidateData()
+    }
+
+    fun removeReport(deleteNote: Note) {
+        val author = deleteNote.author ?: return
+
+        if (author in reports.keys && reports[author]?.contains(deleteNote) == true) {
+            reports[author]?.let {
+                reports = reports + Pair(author, it.minus(deleteNote))
+                liveSet?.reports?.invalidateData()
+            }
+        }
+    }
+
+    fun removeZap(note: Note) {
+        if (zaps[note] != null) {
+            zaps = zaps.minus(note)
+            liveSet?.zaps?.invalidateData()
+        } else if (zaps.containsValue(note)) {
+            val toRemove = zaps.filterValues { it == note }
+            zaps = zaps.minus(toRemove.keys)
+            liveSet?.zaps?.invalidateData()
+        }
    }

    fun addBoost(note: Note) {
-        if (boosts.add(note))
-            refreshObservers()
+        if (note !in boosts) {
+            boosts = boosts + note
+            liveSet?.boosts?.invalidateData()
+        }
+    }
+
+    @Synchronized
+    fun addZap(zapRequest: Note, zap: Note?) {
+        if (zapRequest !in zaps.keys) {
+            zaps = zaps + Pair(zapRequest, zap)
+            liveSet?.zaps?.invalidateData()
+        } else if (zapRequest in zaps.keys && zaps[zapRequest] == null) {
+            zaps = zaps + Pair(zapRequest, zap)
+            liveSet?.zaps?.invalidateData()
+        }
    }

    fun addReaction(note: Note) {
-        if (reactions.add(note))
-            refreshObservers()
+        if (note !in reactions) {
+            reactions = reactions + note
+            liveSet?.reactions?.invalidateData()
+        }
+    }
+
+    fun addReport(note: Note) {
+        val author = note.author ?: return
+
+        if (author !in reports.keys) {
+            reports = reports + Pair(author, setOf(note))
+            liveSet?.reports?.invalidateData()
+        } else if (reports[author]?.contains(note) == false) {
+            reports = reports + Pair(author, (reports[author] ?: emptySet()) + note)
+            liveSet?.reports?.invalidateData()
+        }
+    }
+
+    fun addRelay(relay: Relay) {
+        if (relay.url !in relays) {
+            relays = relays + relay.url
+            liveSet?.relays?.invalidateData()
+        }
+    }
+
+    fun isZappedBy(user: User, account: Account): Boolean {
+        // Zaps who the requester was the user
+        return zaps.any {
+            it.key.author === user || account.decryptZapContentAuthor(it.key)?.pubKey == user.pubkeyHex
+        }
    }

    fun isReactedBy(user: User): Boolean {
-        return reactions.any { it.author == user }
+        return reactions.any { it.author === user }
    }

    fun isBoostedBy(user: User): Boolean {
-        return boosts.any { it.author == user }
+        return boosts.any { it.author === user }
    }

-    // Observers line up here.
-    val live: NoteLiveData = NoteLiveData(this)
+    fun reportsBy(user: User): Set<Note> {
+        return reports[user] ?: emptySet()
+    }

-    private fun refreshObservers() {
-        live.refresh()
+    fun reportAuthorsBy(users: Set<HexKey>): List<User> {
+        return reports.keys.filter { it.pubkeyHex in users }
+    }
+
+    fun countReportAuthorsBy(users: Set<HexKey>): Int {
+        return reports.keys.count { it.pubkeyHex in users }
+    }
+
+    fun reportsBy(users: Set<HexKey>): List<Note> {
+        return reportAuthorsBy(users).mapNotNull {
+            reports[it]
+        }.flatten()
+    }
+
+    fun zappedAmount(): BigDecimal {
+        return zaps.mapNotNull { it.value?.event }
+            .filterIsInstance<LnZapEvent>()
+            .mapNotNull {
+                it.amount
+            }.sumOf { it }
+    }
+
+    fun hasPledgeBy(user: User): Boolean {
+        return replies
+            .filter { it.event?.isTaggedHash("bounty-added-reward") ?: false }
+            .any {
+                val pledgeValue = try {
+                    BigDecimal(it.event?.content())
+                } catch (e: Exception) {
+                    null
+                    // do nothing if it can't convert to bigdecimal
+                }
+
+                pledgeValue != null && it.author == user
+            }
+    }
+
+    fun pledgedAmountByOthers(): BigDecimal {
+        return replies
+            .filter { it.event?.isTaggedHash("bounty-added-reward") ?: false }
+            .mapNotNull {
+                try {
+                    BigDecimal(it.event?.content())
+                } catch (e: Exception) {
+                    null
+                    // do nothing if it can't convert to bigdecimal
+                }
+            }
+            .sumOf { it }
+    }
+
+    fun hasAnyReports(): Boolean {
+        val dayAgo = Date().time / 1000 - 24 * 60 * 60
+        return reports.isNotEmpty() ||
+            (
+                author?.reports?.values?.any {
+                    it.firstOrNull { (it.createdAt() ?: 0) > dayAgo } != null
+                } ?: false
+                )
+    }
+
+    fun isNewThread(): Boolean {
+        return event is RepostEvent || replyTo == null || replyTo?.size == 0
+    }
+
+    fun hasZapped(loggedIn: User): Boolean {
+        return zaps.any { it.key.author == loggedIn }
+    }
+
+    fun hasReacted(loggedIn: User, content: String): Boolean {
+        return reactedBy(loggedIn, content).isNotEmpty()
+    }
+
+    fun reactedBy(loggedIn: User, content: String): List<Note> {
+        return reactions.filter { it.author == loggedIn && it.event?.content() == content }
+    }
+
+    fun hasBoostedInTheLast5Minutes(loggedIn: User): Boolean {
+        val currentTime = Date().time / 1000
+        return boosts.firstOrNull { it.author == loggedIn && (it.createdAt() ?: 0) > currentTime - (60 * 5) } != null // 5 minute protection
+    }
+
+    fun boostedBy(loggedIn: User): List<Note> {
+        return boosts.filter { it.author == loggedIn }
+    }
+
+    var liveSet: NoteLiveSet? = null
+
+    fun live(): NoteLiveSet {
+        if (liveSet == null) {
+            liveSet = NoteLiveSet(this)
+        }
+        return liveSet!!
+    }
+
+    fun clearLive() {
+        if (liveSet != null && liveSet?.isInUse() == false) {
+            liveSet = null
+        }
    }
 }

-class NoteLiveData(val note: Note): LiveData<NoteState>(NoteState(note)) {
-    fun refresh() {
+class NoteLiveSet(u: Note) {
+    // Observers line up here.
+    val metadata: NoteLiveData = NoteLiveData(u)
+
+    val reactions: NoteLiveData = NoteLiveData(u)
+    val boosts: NoteLiveData = NoteLiveData(u)
+    val replies: NoteLiveData = NoteLiveData(u)
+    val reports: NoteLiveData = NoteLiveData(u)
+    val relays: NoteLiveData = NoteLiveData(u)
+    val zaps: NoteLiveData = NoteLiveData(u)
+
+    fun isInUse(): Boolean {
+        return metadata.hasObservers() ||
+            reactions.hasObservers() ||
+            boosts.hasObservers() ||
+            replies.hasObservers() ||
+            reports.hasObservers() ||
+            relays.hasObservers() ||
+            zaps.hasObservers()
+    }
+}
+
+class NoteLiveData(val note: Note) : LiveData<NoteState>(NoteState(note)) {
+    // Refreshes observers in batches.
+    private val bundler = BundledUpdate(300, Dispatchers.Main) {
+        if (hasActiveObservers()) {
+            refresh()
+        }
+    }
+
+    fun invalidateData() {
+        bundler.invalidate()
+    }
+
+    private fun refresh() {
        postValue(NoteState(note))
    }

    override fun onActive() {
        super.onActive()
-        NostrSingleEventDataSource.add(note.idHex)
+        if (note is AddressableNote) {
+            NostrSingleEventDataSource.addAddress(note)
+        } else {
+            NostrSingleEventDataSource.add(note)
+        }
    }

    override fun onInactive() {
        super.onInactive()
-        NostrSingleEventDataSource.remove(note.idHex)
+        if (note is AddressableNote) {
+            NostrSingleEventDataSource.removeAddress(note)
+        } else {
+            NostrSingleEventDataSource.remove(note)
+        }
    }
 }

--- a/app/src/main/java/com/vitorpamplona/amethyst/model/RelaySetupInfo.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/model/RelaySetupInfo.kt
@@ -0,0 +1,14 @@
+package com.vitorpamplona.amethyst.model
+
+import com.vitorpamplona.amethyst.service.relays.FeedType
+
+data class RelaySetupInfo(
+    val url: String,
+    val read: Boolean,
+    val write: Boolean,
+    val errorCount: Int = 0,
+    val downloadCountInBytes: Int = 0,
+    val uploadCountInBytes: Int = 0,
+    val spamCount: Int = 0,
+    val feedTypes: Set<FeedType>
+)
--- a/app/src/main/java/com/vitorpamplona/amethyst/model/ThreadAssembler.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/model/ThreadAssembler.kt
@@ -0,0 +1,82 @@
+package com.vitorpamplona.amethyst.model
+
+import com.vitorpamplona.amethyst.service.model.ATag
+import kotlin.time.ExperimentalTime
+import kotlin.time.measureTimedValue
+
+class ThreadAssembler {
+
+    fun searchRoot(note: Note, testedNotes: MutableSet<Note> = mutableSetOf()): Note? {
+        if (note.replyTo == null || note.replyTo?.isEmpty() == true) return note
+
+        testedNotes.add(note)
+
+        val markedAsRoot = note.event?.tags()?.firstOrNull { it[0] == "e" && it.size > 3 && it[3] == "root" }?.getOrNull(1)
+        if (markedAsRoot != null) return LocalCache.checkGetOrCreateNote(markedAsRoot)
+
+        val hasNoReplyTo = note.replyTo?.firstOrNull { it.replyTo?.isEmpty() == true }
+        if (hasNoReplyTo != null) return hasNoReplyTo
+
+        // recursive
+        val roots = note.replyTo?.map {
+            if (it !in testedNotes) {
+                searchRoot(it, testedNotes)
+            } else {
+                null
+            }
+        }?.filterNotNull()
+
+        if (roots != null && roots.isNotEmpty()) {
+            return roots[0]
+        }
+
+        return null
+    }
+
+    @OptIn(ExperimentalTime::class)
+    fun findThreadFor(noteId: String): Set<Note> {
+        val (result, elapsed) = measureTimedValue {
+            val note = if (noteId.contains(":")) {
+                val aTag = ATag.parse(noteId, null)
+                if (aTag != null) {
+                    LocalCache.getOrCreateAddressableNote(aTag)
+                } else {
+                    return emptySet()
+                }
+            } else {
+                LocalCache.getOrCreateNote(noteId)
+            }
+
+            if (note.event != null) {
+                val thread = mutableSetOf<Note>()
+
+                val threadRoot = searchRoot(note, thread) ?: note
+
+                loadDown(threadRoot, thread)
+                // adds the replies of the note in case the search for Root
+                // did not added them.
+                note.replies.forEach {
+                    loadDown(it, thread)
+                }
+
+                thread.toSet()
+            } else {
+                setOf(note)
+            }
+        }
+
+        println("Model Refresh: Thread loaded in $elapsed")
+
+        return result
+    }
+
+    fun loadDown(note: Note, thread: MutableSet<Note>) {
+        if (note !in thread) {
+            thread.add(note)
+
+            note.replies.forEach {
+                loadDown(it, thread)
+            }
+        }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/model/UrlCachedPreviewer.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/model/UrlCachedPreviewer.kt
@@ -3,53 +3,44 @@ package com.vitorpamplona.amethyst.model
 import com.baha.url.preview.BahaUrlPreview
 import com.baha.url.preview.IUrlPreviewCallback
 import com.baha.url.preview.UrlInfoItem
-import com.vitorpamplona.amethyst.ui.components.imageExtension
-import com.vitorpamplona.amethyst.ui.components.isValidURL
-import com.vitorpamplona.amethyst.ui.components.noProtocolUrlValidator
-import com.vitorpamplona.amethyst.ui.components.videoExtension
-import java.util.concurrent.ConcurrentHashMap
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch

 object UrlCachedPreviewer {
-  val cache = ConcurrentHashMap<String, UrlInfoItem>()
+    var cache = mapOf<String, UrlInfoItem>()
+        private set
+    var failures = mapOf<String, Throwable>()
+        private set

-  fun previewInfo(url: String, callback: IUrlPreviewCallback? = null) {
-    cache[url]?.let {
-      callback?.onComplete(it)
-      return
-    }
-
-    BahaUrlPreview(url, object : IUrlPreviewCallback {
-      override fun onComplete(urlInfo: UrlInfoItem) {
-        cache.put(url, urlInfo)
-        callback?.onComplete(urlInfo)
-      }
-
-      override fun onFailed(throwable: Throwable) {
-        callback?.onFailed(throwable)
-      }
-    }).fetchUrlPreview()
-  }
-
-  fun findUrlsInMessage(message: String): List<String> {
-    return message.split('\n').map { paragraph ->
-      paragraph.split(' ').filter { word: String ->
-        isValidURL(word) || noProtocolUrlValidator.matcher(word).matches()
-      }
-    }.flatten()
-  }
-
-  fun preloadPreviewsFor(note: Note) {
-    note.event?.content?.let {
-      findUrlsInMessage(it).forEach {
-        val removedParamsFromUrl = it.split("?")[0].toLowerCase()
-        if (imageExtension.matcher(removedParamsFromUrl).matches()) {
-          // Preload Images? Isn't this too heavy?
-        } else if (videoExtension.matcher(removedParamsFromUrl).matches()) {
-          // Do nothing for now.
-        } else {
-          previewInfo(it)
+    fun previewInfo(url: String, callback: IUrlPreviewCallback? = null) {
+        cache[url]?.let {
+            callback?.onComplete(it)
+            return
+        }
+
+        failures[url]?.let {
+            callback?.onFailed(it)
+            return
+        }
+
+        val scope = CoroutineScope(Job() + Dispatchers.IO)
+        scope.launch {
+            BahaUrlPreview(
+                url,
+                object : IUrlPreviewCallback {
+                    override fun onComplete(urlInfo: UrlInfoItem) {
+                        cache = cache + Pair(url, urlInfo)
+                        callback?.onComplete(urlInfo)
+                    }
+
+                    override fun onFailed(throwable: Throwable) {
+                        failures = failures + Pair(url, throwable)
+                        callback?.onFailed(throwable)
+                    }
+                }
+            ).fetchUrlPreview()
        }
-      }
    }
-  }
-}
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/model/User.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/model/User.kt
@@ -2,73 +2,376 @@ package com.vitorpamplona.amethyst.model

 import androidx.lifecycle.LiveData
 import com.vitorpamplona.amethyst.service.NostrSingleUserDataSource
-import com.vitorpamplona.amethyst.ui.note.toDisplayHex
-import java.util.Collections
+import com.vitorpamplona.amethyst.service.model.BookmarkListEvent
+import com.vitorpamplona.amethyst.service.model.ContactListEvent
+import com.vitorpamplona.amethyst.service.model.LnZapEvent
+import com.vitorpamplona.amethyst.service.model.MetadataEvent
+import com.vitorpamplona.amethyst.service.model.ReportEvent
+import com.vitorpamplona.amethyst.service.relays.EOSETime
+import com.vitorpamplona.amethyst.service.relays.Relay
+import com.vitorpamplona.amethyst.ui.components.BundledUpdate
+import com.vitorpamplona.amethyst.ui.note.toShortenHex
+import fr.acinq.secp256k1.Hex
+import kotlinx.coroutines.Dispatchers
+import nostr.postr.Bech32
+import nostr.postr.toNpub
+import java.math.BigDecimal
+import java.util.regex.Pattern

-class User(val pubkey: ByteArray) {
-    val pubkeyHex = pubkey.toHexKey()
-    val pubkeyDisplayHex = pubkey.toDisplayHex()
+val lnurlpPattern = Pattern.compile("(?i:http|https):\\/\\/((.+)\\/)*\\.well-known\\/lnurlp\\/(.*)")

-    var info = UserMetadata()
+class User(val pubkeyHex: String) {
+    var info: UserMetadata? = null

-    var updatedMetadataAt: Long = 0;
-    var updatedFollowsAt: Long = 0;
+    var latestContactList: ContactListEvent? = null
+    var latestBookmarkList: BookmarkListEvent? = null

-    val notes = Collections.synchronizedSet(mutableSetOf<Note>())
-    val follows = Collections.synchronizedSet(mutableSetOf<User>())
-    val taggedPosts = Collections.synchronizedSet(mutableSetOf<Note>())
+    var notes = setOf<Note>()
+        private set

-    var follower: Number? = null
+    var reports = mapOf<User, Set<Note>>()
+        private set
+
+    var latestEOSEs: Map<String, EOSETime> = emptyMap()
+
+    var zaps = mapOf<Note, Note?>()
+        private set
+
+    var relaysBeingUsed = mapOf<String, RelayInfo>()
+        private set
+
+    var privateChatrooms = mapOf<User, Chatroom>()
+        private set
+
+    var acceptedBadges: AddressableNote? = null
+
+    fun pubkey() = Hex.decode(pubkeyHex)
+    fun pubkeyNpub() = pubkey().toNpub()
+
+    fun pubkeyDisplayHex() = pubkeyNpub().toShortenHex()
+
+    override fun toString(): String = pubkeyHex

    fun toBestDisplayName(): String {
-        return bestDisplayName() ?: bestUsername() ?: pubkeyDisplayHex
+        return bestDisplayName() ?: bestUsername() ?: pubkeyDisplayHex()
    }

    fun bestUsername(): String? {
-        return info.name?.ifBlank { null } ?: info.username?.ifBlank { null }
+        return info?.name?.ifBlank { null } ?: info?.username?.ifBlank { null }
    }

    fun bestDisplayName(): String? {
-        return info.displayName?.ifBlank { null } ?: info.display_name?.ifBlank { null }
+        return info?.displayName?.ifBlank { null } ?: info?.display_name?.ifBlank { null }
    }

-    fun profilePicture(): String {
-        if (info.picture.isNullOrBlank()) info.picture = null
-        return info.picture ?: "https://robohash.org/${pubkeyHex}.png"
+    fun nip05(): String? {
+        return info?.nip05?.ifBlank { null }
    }

-    fun updateFollows(newFollows: List<User>, updateAt: Long) {
-        follows.clear()
-        follows.addAll(newFollows)
-        updatedFollowsAt = updateAt
-
-        live.refresh()
+    fun profilePicture(): String? {
+        if (info?.picture.isNullOrBlank()) info?.picture = null
+        return info?.picture
    }

-    fun updateUserInfo(newUserInfo: UserMetadata, updateAt: Long) {
+    fun updateBookmark(event: BookmarkListEvent) {
+        if (event.id == latestBookmarkList?.id) return
+
+        latestBookmarkList = event
+        liveSet?.bookmarks?.invalidateData()
+    }
+
+    fun updateContactList(event: ContactListEvent) {
+        if (event.id == latestContactList?.id) return
+
+        val oldContactListEvent = latestContactList
+        latestContactList = event
+
+        // Update following of the current user
+        liveSet?.follows?.invalidateData()
+
+        // Update Followers of the past user list
+        // Update Followers of the new contact list
+        (oldContactListEvent)?.unverifiedFollowKeySet()?.forEach {
+            LocalCache.users[it]?.liveSet?.follows?.invalidateData()
+        }
+        (latestContactList)?.unverifiedFollowKeySet()?.forEach {
+            LocalCache.users[it]?.liveSet?.follows?.invalidateData()
+        }
+
+        liveSet?.relays?.invalidateData()
+    }
+
+    fun addNote(note: Note) {
+        if (note !in notes) {
+            notes = notes + note
+            // No need for Listener yet
+        }
+    }
+
+    fun removeNote(note: Note) {
+        notes = notes - note
+    }
+
+    fun clearNotes() {
+        notes = setOf<Note>()
+    }
+
+    fun addReport(note: Note) {
+        val author = note.author ?: return
+
+        if (author !in reports.keys) {
+            reports = reports + Pair(author, setOf(note))
+            liveSet?.reports?.invalidateData()
+        } else if (reports[author]?.contains(note) == false) {
+            reports = reports + Pair(author, (reports[author] ?: emptySet()) + note)
+            liveSet?.reports?.invalidateData()
+        }
+    }
+
+    fun removeReport(deleteNote: Note) {
+        val author = deleteNote.author ?: return
+
+        if (author in reports.keys && reports[author]?.contains(deleteNote) == true) {
+            reports[author]?.let {
+                reports = reports + Pair(author, it.minus(deleteNote))
+                liveSet?.reports?.invalidateData()
+            }
+        }
+    }
+
+    fun updateAcceptedBadges(note: AddressableNote) {
+        acceptedBadges = note
+        liveSet?.badges?.invalidateData()
+    }
+
+    fun addZap(zapRequest: Note, zap: Note?) {
+        if (zapRequest !in zaps.keys) {
+            zaps = zaps + Pair(zapRequest, zap)
+            liveSet?.zaps?.invalidateData()
+        } else if (zapRequest in zaps.keys && zaps[zapRequest] == null) {
+            zaps = zaps + Pair(zapRequest, zap)
+            liveSet?.zaps?.invalidateData()
+        }
+    }
+
+    fun zappedAmount(): BigDecimal {
+        return zaps.mapNotNull { it.value?.event }
+            .filterIsInstance<LnZapEvent>()
+            .mapNotNull {
+                it.amount
+            }.sumOf { it }
+    }
+
+    fun reportsBy(user: User): Set<Note> {
+        return reports[user] ?: emptySet()
+    }
+
+    fun reportAuthorsBy(users: Set<HexKey>): List<User> {
+        return reports.keys.filter { it.pubkeyHex in users }
+    }
+
+    fun countReportAuthorsBy(users: Set<HexKey>): Int {
+        return reports.keys.count { it.pubkeyHex in users }
+    }
+
+    fun reportsBy(users: Set<HexKey>): List<Note> {
+        return reportAuthorsBy(users).mapNotNull {
+            reports[it]
+        }.flatten()
+    }
+
+    @Synchronized
+    fun getOrCreatePrivateChatroom(user: User): Chatroom {
+        return privateChatrooms[user] ?: run {
+            val privateChatroom = Chatroom(setOf<Note>())
+            privateChatrooms = privateChatrooms + Pair(user, privateChatroom)
+            privateChatroom
+        }
+    }
+
+    @Synchronized
+    fun addMessage(user: User, msg: Note) {
+        val privateChatroom = getOrCreatePrivateChatroom(user)
+        if (msg !in privateChatroom.roomMessages) {
+            privateChatroom.roomMessages = privateChatroom.roomMessages + msg
+            liveSet?.messages?.invalidateData()
+        }
+    }
+
+    @Synchronized
+    fun removeMessage(user: User, msg: Note) {
+        val privateChatroom = getOrCreatePrivateChatroom(user)
+        if (msg in privateChatroom.roomMessages) {
+            privateChatroom.roomMessages = privateChatroom.roomMessages - msg
+            liveSet?.messages?.invalidateData()
+        }
+    }
+
+    fun addRelayBeingUsed(relay: Relay, eventTime: Long) {
+        val here = relaysBeingUsed[relay.url]
+        if (here == null) {
+            relaysBeingUsed = relaysBeingUsed + Pair(relay.url, RelayInfo(relay.url, eventTime, 1))
+        } else {
+            if (eventTime > here.lastEvent) {
+                here.lastEvent = eventTime
+            }
+            here.counter++
+        }
+
+        liveSet?.relayInfo?.invalidateData()
+    }
+
+    fun updateUserInfo(newUserInfo: UserMetadata, latestMetadata: MetadataEvent) {
        info = newUserInfo
-        updatedMetadataAt = updateAt
+        info?.latestMetadata = latestMetadata
+        info?.updatedMetadataAt = latestMetadata.createdAt

-        live.refresh()
+        if (newUserInfo.lud16.isNullOrBlank() && newUserInfo.lud06?.lowercase()?.startsWith("lnurl") == true) {
+            try {
+                val url = String(Bech32.decodeBytes(newUserInfo.lud06!!, false).second)
+
+                val matcher = lnurlpPattern.matcher(url)
+                while (matcher.find()) {
+                    val domain = matcher.group(2)
+                    val username = matcher.group(3)
+
+                    info?.lud16 = "$username@$domain"
+                }
+            } catch (t: Throwable) {
+                // Doesn't create errors.
+            }
+        }
+
+        liveSet?.metadata?.invalidateData()
    }

-    // Observers line up here.
-    val live: UserLiveData = UserLiveData(this)
+    fun isFollowing(user: User): Boolean {
+        return latestContactList?.unverifiedFollowKeySet()?.toSet()?.let {
+            return user.pubkeyHex in it
+        } ?: false
+    }

-    private fun refreshObservers() {
-        live.refresh()
+    fun isFollowingHashtag(tag: String): Boolean {
+        return latestContactList?.unverifiedFollowTagSet()?.toSet()?.let {
+            return tag in it
+        } ?: false
+    }
+
+    fun isFollowingHashtagCached(tag: String): Boolean {
+        return latestContactList?.verifiedFollowTagSet?.let {
+            return tag.lowercase() in it
+        } ?: false
+    }
+
+    fun isFollowingCached(user: User): Boolean {
+        return latestContactList?.verifiedFollowKeySet?.let {
+            return user.pubkeyHex in it
+        } ?: false
+    }
+
+    fun transientFollowCount(): Int? {
+        return latestContactList?.unverifiedFollowKeySet()?.size
+    }
+
+    fun transientFollowerCount(): Int {
+        return LocalCache.users.values.count { it.latestContactList?.isTaggedUser(pubkeyHex) ?: false }
+    }
+
+    fun cachedFollowingKeySet(): Set<HexKey> {
+        return latestContactList?.verifiedFollowKeySet ?: emptySet()
+    }
+
+    fun cachedFollowingTagSet(): Set<HexKey> {
+        return latestContactList?.verifiedFollowTagSet ?: emptySet()
+    }
+
+    fun cachedFollowCount(): Int? {
+        return latestContactList?.verifiedFollowKeySet?.size
+    }
+
+    fun cachedFollowerCount(): Int {
+        return LocalCache.users.values.count { it.latestContactList?.isTaggedUser(pubkeyHex) ?: false }
+    }
+
+    fun hasSentMessagesTo(user: User?): Boolean {
+        val messagesToUser = privateChatrooms[user] ?: return false
+
+        return messagesToUser.roomMessages.any { this === it.author }
+    }
+
+    fun hasReport(loggedIn: User, type: ReportEvent.ReportType): Boolean {
+        return reports[loggedIn]?.firstOrNull() {
+            it.event is ReportEvent && (it.event as ReportEvent).reportedAuthor().any { it.reportType == type }
+        } != null
+    }
+
+    fun anyNameStartsWith(username: String): Boolean {
+        return info?.anyNameStartsWith(username) ?: false
+    }
+
+    var liveSet: UserLiveSet? = null
+
+    fun live(): UserLiveSet {
+        if (liveSet == null) {
+            liveSet = UserLiveSet(this)
+        }
+        return liveSet!!
+    }
+
+    fun clearLive() {
+        if (liveSet != null && liveSet?.isInUse() == false) {
+            liveSet = null
+        }
    }
 }

+class UserLiveSet(u: User) {
+    // UI Observers line up here.
+    val follows: UserLiveData = UserLiveData(u)
+    val reports: UserLiveData = UserLiveData(u)
+    val messages: UserLiveData = UserLiveData(u)
+    val relays: UserLiveData = UserLiveData(u)
+    val relayInfo: UserLiveData = UserLiveData(u)
+    val metadata: UserLiveData = UserLiveData(u)
+    val zaps: UserLiveData = UserLiveData(u)
+    val badges: UserLiveData = UserLiveData(u)
+    val bookmarks: UserLiveData = UserLiveData(u)
+
+    fun isInUse(): Boolean {
+        return follows.hasObservers() ||
+            reports.hasObservers() ||
+            messages.hasObservers() ||
+            relays.hasObservers() ||
+            relayInfo.hasObservers() ||
+            metadata.hasObservers() ||
+            zaps.hasObservers() ||
+            badges.hasObservers() ||
+            bookmarks.hasObservers()
+    }
+}
+
+data class RelayInfo(
+    val url: String,
+    var lastEvent: Long,
+    var counter: Long
+)
+
+data class Chatroom(var roomMessages: Set<Note>)
+
 class UserMetadata {
    var name: String? = null
    var username: String? = null
    var display_name: String? = null
    var displayName: String? = null
    var picture: String? = null
+    var banner: String? = null
    var website: String? = null
    var about: String? = null
+
    var nip05: String? = null
+    var nip05Verified: Boolean = false
+    var nip05LastVerificationTime: Long? = 0
+
    var domain: String? = null
    var lud06: String? = null
    var lud16: String? = null
@@ -77,21 +380,44 @@ class UserMetadata {
    var iris: String? = null
    var main_relay: String? = null
    var twitter: String? = null
+
+    var updatedMetadataAt: Long = 0
+    var latestMetadata: MetadataEvent? = null
+
+    fun anyNameStartsWith(prefix: String): Boolean {
+        return listOfNotNull(name, username, display_name, displayName, nip05, lud06, lud16)
+            .any { it.startsWith(prefix, true) }
+    }
+
+    fun lnAddress(): String? {
+        return (lud16?.trim() ?: lud06?.trim())?.ifBlank { null }
+    }
 }

-class UserLiveData(val user: User): LiveData<UserState>(UserState(user)) {
-    fun refresh() {
+class UserLiveData(val user: User) : LiveData<UserState>(UserState(user)) {
+    // Refreshes observers in batches.
+    private val bundler = BundledUpdate(300, Dispatchers.Main) {
+        if (hasActiveObservers()) {
+            refresh()
+        }
+    }
+
+    fun invalidateData() {
+        bundler.invalidate()
+    }
+
+    private fun refresh() {
        postValue(UserState(user))
    }

    override fun onActive() {
        super.onActive()
-        NostrSingleUserDataSource.add(user.pubkeyHex)
+        NostrSingleUserDataSource.add(user)
    }

    override fun onInactive() {
        super.onInactive()
-        NostrSingleUserDataSource.remove(user.pubkeyHex)
+        NostrSingleUserDataSource.remove(user)
    }
 }

--- a/app/src/main/java/com/vitorpamplona/amethyst/service/BlurHashDecoder.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/BlurHashDecoder.kt
@@ -0,0 +1,203 @@
+package com.vitorpamplona.amethyst.service
+
+import android.graphics.Bitmap
+import android.graphics.Color
+import kotlin.math.cos
+import kotlin.math.pow
+import kotlin.math.withSign
+
+object BlurHashDecoder {
+
+    // cache Math.cos() calculations to improve performance.
+    // The number of calculations can be huge for many bitmaps: width * height * numCompX * numCompY * 2 * nBitmaps
+    // the cache is enabled by default, it is recommended to disable it only when just a few images are displayed
+    private val cacheCosinesX = HashMap<Int, DoubleArray>()
+    private val cacheCosinesY = HashMap<Int, DoubleArray>()
+
+    /**
+     * Clear calculations stored in memory cache.
+     * The cache is not big, but will increase when many image sizes are used,
+     * if the app needs memory it is recommended to clear it.
+     */
+    fun clearCache() {
+        cacheCosinesX.clear()
+        cacheCosinesY.clear()
+    }
+
+    /**
+     * Returns width/height
+     */
+    fun aspectRatio(blurHash: String?): Float? {
+        if (blurHash == null || blurHash.length < 6) {
+            return null
+        }
+        val numCompEnc = decode83(blurHash, 0, 1)
+        val numCompX = (numCompEnc % 9) + 1
+        val numCompY = (numCompEnc / 9) + 1
+        if (blurHash.length != 4 + 2 * numCompX * numCompY) {
+            return null
+        }
+
+        return numCompX.toFloat() / numCompY.toFloat()
+    }
+
+    /**
+     * Decode a blur hash into a new bitmap.
+     *
+     * @param useCache use in memory cache for the calculated math, reused by images with same size.
+     *                 if the cache does not exist yet it will be created and populated with new calculations.
+     *                 By default it is true.
+     */
+    fun decode(blurHash: String?, width: Int, height: Int, punch: Float = 1f, useCache: Boolean = true): Bitmap? {
+        if (blurHash == null || blurHash.length < 6) {
+            return null
+        }
+        val numCompEnc = decode83(blurHash, 0, 1)
+        val numCompX = (numCompEnc % 9) + 1
+        val numCompY = (numCompEnc / 9) + 1
+        if (blurHash.length != 4 + 2 * numCompX * numCompY) {
+            return null
+        }
+        val maxAcEnc = decode83(blurHash, 1, 2)
+        val maxAc = (maxAcEnc + 1) / 166f
+        val colors = Array(numCompX * numCompY) { i ->
+            if (i == 0) {
+                val colorEnc = decode83(blurHash, 2, 6)
+                decodeDc(colorEnc)
+            } else {
+                val from = 4 + i * 2
+                val colorEnc = decode83(blurHash, from, from + 2)
+                decodeAc(colorEnc, maxAc * punch)
+            }
+        }
+        return composeBitmap(width, height, numCompX, numCompY, colors, useCache)
+    }
+
+    private fun decode83(str: String, from: Int = 0, to: Int = str.length): Int {
+        var result = 0
+        for (i in from until to) {
+            val index = charMap[str[i]] ?: -1
+            if (index != -1) {
+                result = result * 83 + index
+            }
+        }
+        return result
+    }
+
+    private fun decodeDc(colorEnc: Int): FloatArray {
+        val r = colorEnc shr 16
+        val g = (colorEnc shr 8) and 255
+        val b = colorEnc and 255
+        return floatArrayOf(srgbToLinear(r), srgbToLinear(g), srgbToLinear(b))
+    }
+
+    private fun srgbToLinear(colorEnc: Int): Float {
+        val v = colorEnc / 255f
+        return if (v <= 0.04045f) {
+            (v / 12.92f)
+        } else {
+            ((v + 0.055f) / 1.055f).pow(2.4f)
+        }
+    }
+
+    private fun decodeAc(value: Int, maxAc: Float): FloatArray {
+        val r = value / (19 * 19)
+        val g = (value / 19) % 19
+        val b = value % 19
+        return floatArrayOf(
+            signedPow2((r - 9) / 9.0f) * maxAc,
+            signedPow2((g - 9) / 9.0f) * maxAc,
+            signedPow2((b - 9) / 9.0f) * maxAc
+        )
+    }
+
+    private fun signedPow2(value: Float) = value.pow(2f).withSign(value)
+
+    private fun composeBitmap(
+        width: Int,
+        height: Int,
+        numCompX: Int,
+        numCompY: Int,
+        colors: Array<FloatArray>,
+        useCache: Boolean
+    ): Bitmap {
+        // use an array for better performance when writing pixel colors
+        val imageArray = IntArray(width * height)
+        val calculateCosX = !useCache || !cacheCosinesX.containsKey(width * numCompX)
+        val cosinesX = getArrayForCosinesX(calculateCosX, width, numCompX)
+        val calculateCosY = !useCache || !cacheCosinesY.containsKey(height * numCompY)
+        val cosinesY = getArrayForCosinesY(calculateCosY, height, numCompY)
+        for (y in 0 until height) {
+            for (x in 0 until width) {
+                var r = 0f
+                var g = 0f
+                var b = 0f
+                for (j in 0 until numCompY) {
+                    for (i in 0 until numCompX) {
+                        val cosX = cosinesX.getCos(calculateCosX, i, numCompX, x, width)
+                        val cosY = cosinesY.getCos(calculateCosY, j, numCompY, y, height)
+                        val basis = (cosX * cosY).toFloat()
+                        val color = colors[j * numCompX + i]
+                        r += color[0] * basis
+                        g += color[1] * basis
+                        b += color[2] * basis
+                    }
+                }
+                imageArray[x + width * y] = Color.rgb(linearToSrgb(r), linearToSrgb(g), linearToSrgb(b))
+            }
+        }
+        return Bitmap.createBitmap(imageArray, width, height, Bitmap.Config.ARGB_8888)
+    }
+
+    private fun getArrayForCosinesY(calculate: Boolean, height: Int, numCompY: Int) = when {
+        calculate -> {
+            DoubleArray(height * numCompY).also {
+                cacheCosinesY[height * numCompY] = it
+            }
+        }
+        else -> {
+            cacheCosinesY[height * numCompY]!!
+        }
+    }
+
+    private fun getArrayForCosinesX(calculate: Boolean, width: Int, numCompX: Int) = when {
+        calculate -> {
+            DoubleArray(width * numCompX).also {
+                cacheCosinesX[width * numCompX] = it
+            }
+        }
+        else -> cacheCosinesX[width * numCompX]!!
+    }
+
+    private fun DoubleArray.getCos(
+        calculate: Boolean,
+        x: Int,
+        numComp: Int,
+        y: Int,
+        size: Int
+    ): Double {
+        if (calculate) {
+            this[x + numComp * y] = cos(Math.PI * y * x / size)
+        }
+        return this[x + numComp * y]
+    }
+
+    private fun linearToSrgb(value: Float): Int {
+        val v = value.coerceIn(0f, 1f)
+        return if (v <= 0.0031308f) {
+            (v * 12.92f * 255f + 0.5f).toInt()
+        } else {
+            ((1.055f * v.pow(1 / 2.4f) - 0.055f) * 255 + 0.5f).toInt()
+        }
+    }
+
+    private val charMap = listOf(
+        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
+        'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
+        'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
+        'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '#', '$', '%', '*', '+', ',',
+        '-', '.', ':', ';', '=', '?', '@', '[', ']', '^', '_', '{', '|', '}', '~'
+    )
+        .mapIndexed { i, c -> c to i }
+        .toMap()
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/BlurHashImage.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/BlurHashImage.kt
@@ -0,0 +1,65 @@
+package com.vitorpamplona.amethyst.service
+
+import android.content.Context
+import android.net.Uri
+import androidx.core.graphics.drawable.toDrawable
+import coil.ImageLoader
+import coil.decode.DataSource
+import coil.fetch.DrawableResult
+import coil.fetch.FetchResult
+import coil.fetch.Fetcher
+import coil.request.ImageRequest
+import coil.request.Options
+import java.net.URLDecoder
+import java.net.URLEncoder
+import kotlin.math.roundToInt
+
+class BlurHashFetcher(
+    private val options: Options,
+    private val data: Uri
+) : Fetcher {
+
+    override suspend fun fetch(): FetchResult {
+        val encodedHash = data.toString().removePrefix("bluehash:")
+        val hash = URLDecoder.decode(encodedHash, "utf-8")
+
+        val aspectRatio = BlurHashDecoder.aspectRatio(hash) ?: 1.0f
+
+        val preferredWidth = 100
+
+        val bitmap = BlurHashDecoder.decode(
+            hash,
+            preferredWidth,
+            (preferredWidth * (1 / aspectRatio)).roundToInt()
+        )
+
+        if (bitmap == null) {
+            throw Exception("Unable to convert Bluehash $hash")
+        }
+
+        return DrawableResult(
+            drawable = bitmap.toDrawable(options.context.resources),
+            isSampled = false,
+            dataSource = DataSource.MEMORY
+        )
+    }
+
+    object Factory : Fetcher.Factory<Uri> {
+        override fun create(data: Uri, options: Options, imageLoader: ImageLoader): Fetcher {
+            return BlurHashFetcher(options, data)
+        }
+    }
+}
+
+object BlurHashRequester {
+    fun imageRequest(context: Context, message: String): ImageRequest {
+        val encodedMessage = URLEncoder.encode(message, "utf-8")
+
+        return ImageRequest
+            .Builder(context)
+            .data("bluehash:$encodedMessage")
+            .fetcherFactory(BlurHashFetcher.Factory)
+            .crossfade(100)
+            .build()
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/Channel.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/Channel.kt
@@ -1,10 +0,0 @@
-package com.vitorpamplona.amethyst.service
-
-import java.util.UUID
-import nostr.postr.JsonFilter
-
-data class Channel (
-  val id: String = UUID.randomUUID().toString().substring(0,4)
-) {
-  var filter: JsonFilter? = null // Inactive when null
-}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/Constants.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/Constants.kt
@@ -1,24 +0,0 @@
-package com.vitorpamplona.amethyst.service
-
-import com.vitorpamplona.amethyst.service.relays.Relay
-
-object Constants {
-    val defaultRelays = arrayOf(
-      Relay("wss://nostr.bitcoiner.social", read = true, write = true),
-      Relay("wss://relay.nostr.bg", read = true, write = true),
-      //Relay("wss://brb.io", read = true, write = true),
-      Relay("wss://nostr.v0l.io", read = true, write = true),
-      Relay("wss://nostr.rocks", read = true, write = true),
-      Relay("wss://relay.damus.io", read = true, write = true),
-      Relay("wss://nostr.fmt.wiz.biz", read = true, write = true),
-      Relay("wss://nostr.oxtr.dev", read = true, write = true),
-      Relay("wss://nostr-relay.wlvs.space", read = true, write = true),
-      //Relay("wss://nostr-2.zebedee.cloud", read = true, write = true),
-      Relay("wss://nostr-pub.wellorder.net", read = true, write = true),
-      Relay("wss://nostr.mom", read = true, write = true),
-      Relay("wss://nostr.orangepill.dev", read = true, write = true),
-      //Relay("wss://nostr-pub.semisol.dev", read = true, write = true),
-      Relay("wss://nostr.onsats.org", read = true, write = true),
-      Relay("wss://nostr.sandwich.farm", read = true, write = true)
-    )
-}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/FileHeader.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/FileHeader.kt
@@ -0,0 +1,70 @@
+package com.vitorpamplona.amethyst.service
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.util.Log
+import com.vitorpamplona.amethyst.model.toHexKey
+import io.trbl.blurhash.BlurHash
+import java.net.URL
+import java.security.MessageDigest
+import kotlin.math.roundToInt
+
+class FileHeader(
+    val url: String,
+    val mimeType: String?,
+    val hash: String,
+    val size: Int,
+    val blurHash: String?,
+    val description: String? = null
+) {
+    companion object {
+        fun prepare(fileUrl: String, mimeType: String?, description: String?, onReady: (FileHeader) -> Unit, onError: () -> Unit) {
+            val imageData = URL(fileUrl).readBytes()
+
+            prepare(imageData, fileUrl, mimeType, description, onReady, onError)
+        }
+
+        fun prepare(data: ByteArray, fileUrl: String, mimeType: String?, description: String?, onReady: (FileHeader) -> Unit, onError: () -> Unit) {
+            try {
+                val sha256 = MessageDigest.getInstance("SHA-256")
+
+                val hash = sha256.digest(data).toHexKey()
+                val size = data.size
+
+                val blurHash = if (mimeType?.startsWith("image/") == true) {
+                    val opt = BitmapFactory.Options()
+                    opt.inPreferredConfig = Bitmap.Config.ARGB_8888
+                    val mBitmap = BitmapFactory.decodeByteArray(data, 0, data.size, opt)
+
+                    val intArray = IntArray(mBitmap.width * mBitmap.height)
+                    mBitmap.getPixels(
+                        intArray,
+                        0,
+                        mBitmap.width,
+                        0,
+                        0,
+                        mBitmap.width,
+                        mBitmap.height
+                    )
+
+                    val aspectRatio = (mBitmap.width).toFloat() / (mBitmap.height).toFloat()
+
+                    if (aspectRatio > 1) {
+                        BlurHash.encode(intArray, mBitmap.width, mBitmap.height, 9, (9 * (1 / aspectRatio)).roundToInt())
+                    } else if (aspectRatio < 1) {
+                        BlurHash.encode(intArray, mBitmap.width, mBitmap.height, (9 * aspectRatio).roundToInt(), 9)
+                    } else {
+                        BlurHash.encode(intArray, mBitmap.width, mBitmap.height, 4, 4)
+                    }
+                } else {
+                    null
+                }
+
+                onReady(FileHeader(fileUrl, mimeType, hash, size, blurHash, description))
+            } catch (e: Exception) {
+                Log.e("ImageDownload", "Couldn't convert image in to File Header: ${e.message}")
+                onError()
+            }
+        }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/Nip05Verifier.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/Nip05Verifier.kt
@@ -0,0 +1,99 @@
+package com.vitorpamplona.amethyst.service
+
+import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import com.vitorpamplona.amethyst.BuildConfig
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+
+class Nip05Verifier {
+    val client = OkHttpClient.Builder().build()
+
+    fun assembleUrl(nip05address: String): String? {
+        val parts = nip05address.trim().split("@")
+
+        if (parts.size == 2) {
+            return "https://${parts[1]}/.well-known/nostr.json?name=${parts[0]}"
+        }
+
+        return null
+    }
+
+    fun fetchNip05Json(nip05address: String, onSuccess: (String) -> Unit, onError: (String) -> Unit) {
+        val scope = CoroutineScope(Job() + Dispatchers.IO)
+        scope.launch {
+            fetchNip05JsonSuspend(nip05address, onSuccess, onError)
+        }
+    }
+
+    private suspend fun fetchNip05JsonSuspend(nip05: String, onSuccess: (String) -> Unit, onError: (String) -> Unit) {
+        val url = assembleUrl(nip05)
+
+        if (url == null) {
+            onError("Could not assemble url from Nip05: \"${nip05}\". Check the user's setup")
+            return
+        }
+
+        withContext(Dispatchers.IO) {
+            try {
+                val request = Request.Builder()
+                    .header("User-Agent", "Amethyst/${BuildConfig.VERSION_NAME}")
+                    .url(url)
+                    .build()
+
+                client.newCall(request).enqueue(object : Callback {
+                    override fun onResponse(call: Call, response: Response) {
+                        response.use {
+                            if (it.isSuccessful) {
+                                onSuccess(it.body.string())
+                            } else {
+                                onError("Could not resolve $nip05. Error: ${it.code}. Check if the server up and if the address $nip05 is correct")
+                            }
+                        }
+                    }
+
+                    override fun onFailure(call: Call, e: java.io.IOException) {
+                        onError("Could not resolve $url. Check if the server up and if the address $nip05 is correct")
+                        e.printStackTrace()
+                    }
+                })
+            } catch (e: java.lang.Exception) {
+                onError("Could not resolve '$url': ${e.message}")
+            }
+        }
+    }
+
+    fun verifyNip05(nip05: String, onSuccess: (String) -> Unit, onError: (String) -> Unit) {
+        val mapper = jacksonObjectMapper()
+
+        fetchNip05Json(
+            nip05,
+            onSuccess = {
+                val nip05url = try {
+                    mapper.readTree(it)
+                } catch (t: Throwable) {
+                    onError("Error Parsing JSON from Lightning Address. Check the user's lightning setup")
+                    null
+                }
+
+                val user = nip05.split("@")[0]
+
+                val hexKey = nip05url?.get("names")?.get(user)?.asText()
+
+                if (hexKey == null) {
+                    onError("Username not found in the NIP05 JSON")
+                } else {
+                    onSuccess(hexKey)
+                }
+            },
+            onError = onError
+        )
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/Nip47.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/Nip47.kt
@@ -0,0 +1,34 @@
+package com.vitorpamplona.amethyst.ui.note
+
+import android.net.Uri
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.decodePublicKey
+import com.vitorpamplona.amethyst.model.toHexKey
+
+data class Nip47URI(val pubKeyHex: HexKey, val relayUri: String?, val secret: HexKey?)
+
+// Rename to the corect nip number when ready.
+object Nip47 {
+    fun parse(uri: String): Nip47URI {
+        // nostrwalletconnect://b889ff5b1513b641e2a139f661a661364979c5beee91842f8f0ef42ab558e9d4?relay=wss%3A%2F%2Frelay.damus.io&metadata=%7B%22name%22%3A%22Example%22%7D
+
+        val url = Uri.parse(uri)
+
+        if (url.scheme != "nostrwalletconnect" && url.scheme != "nostr+walletconnect") {
+            throw IllegalArgumentException("Not a Wallet Connect QR Code")
+        }
+
+        val pubkey = url.host ?: throw IllegalArgumentException("Hostname cannot be null")
+
+        val pubkeyHex = try {
+            decodePublicKey(pubkey).toHexKey()
+        } catch (e: Exception) {
+            throw IllegalArgumentException("Hostname is not a valid Nostr Pubkey")
+        }
+
+        val relay = url.getQueryParameter("relay")
+        val secret = url.getQueryParameter("secret")
+
+        return Nip47URI(pubkeyHex, relay, secret)
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/NostrAccountDataSource.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/NostrAccountDataSource.kt
@@ -1,74 +1,133 @@
 package com.vitorpamplona.amethyst.service

 import com.vitorpamplona.amethyst.model.Account
-import com.vitorpamplona.amethyst.model.LocalCache
-import com.vitorpamplona.amethyst.model.Note
-import com.vitorpamplona.amethyst.model.UserState
+import com.vitorpamplona.amethyst.service.model.*
+import com.vitorpamplona.amethyst.service.model.BadgeAwardEvent
+import com.vitorpamplona.amethyst.service.model.BadgeProfilesEvent
+import com.vitorpamplona.amethyst.service.model.BookmarkListEvent
+import com.vitorpamplona.amethyst.service.model.ChannelMessageEvent
+import com.vitorpamplona.amethyst.service.model.ContactListEvent
+import com.vitorpamplona.amethyst.service.model.LnZapEvent
+import com.vitorpamplona.amethyst.service.model.MetadataEvent
+import com.vitorpamplona.amethyst.service.model.ReactionEvent
+import com.vitorpamplona.amethyst.service.model.ReportEvent
 import com.vitorpamplona.amethyst.service.model.RepostEvent
-import nostr.postr.JsonFilter
-import nostr.postr.events.TextNoteEvent
-import nostr.postr.toHex
+import com.vitorpamplona.amethyst.service.model.TextNoteEvent
+import com.vitorpamplona.amethyst.service.relays.COMMON_FEED_TYPES
+import com.vitorpamplona.amethyst.service.relays.Client
+import com.vitorpamplona.amethyst.service.relays.EOSEAccount
+import com.vitorpamplona.amethyst.service.relays.JsonFilter
+import com.vitorpamplona.amethyst.service.relays.Relay
+import com.vitorpamplona.amethyst.service.relays.TypedFilter

-object NostrAccountDataSource: NostrDataSource("AccountData") {
-  lateinit var account: Account
+object NostrAccountDataSource : NostrDataSource("AccountData") {
+    lateinit var account: Account

-  private val cacheListener: (UserState) -> Unit = {
-    resetFilters()
-  }
+    val latestEOSEs = EOSEAccount()

-  override fun start() {
-    if (this::account.isInitialized)
-      account.userProfile().live.observeForever(cacheListener)
-    super.start()
-  }
-
-  override fun stop() {
-    super.stop()
-    if (this::account.isInitialized)
-      account.userProfile().live.removeObserver(cacheListener)
-  }
-
-  fun createAccountFilter(): JsonFilter {
-    return JsonFilter(
-      authors = listOf(account.userProfile().pubkeyHex),
-      since = System.currentTimeMillis() / 1000 - (60 * 60 * 24 * 7), // 4 days
-    )
-  }
-
-  val accountChannel = requestNewChannel()
-
-  fun <T> equalsIgnoreOrder(list1:List<T>?, list2:List<T>?): Boolean {
-    if (list1 == null && list2 == null) return true
-    if (list1 == null) return false
-    if (list2 == null) return false
-
-    return list1.size == list2.size && list1.toSet() == list2.toSet()
-  }
-
-  fun equalAuthors(list1:JsonFilter?, list2:JsonFilter?): Boolean {
-    if (list1 == null && list2 == null) return true
-    if (list1 == null) return false
-    if (list2 == null) return false
-
-    return equalsIgnoreOrder(list1.authors, list2.authors)
-  }
-
-  override fun feed(): List<Note> {
-    val user = account.userProfile()
-    val follows = user.follows.map { it.pubkeyHex }.plus(user.pubkeyHex).toSet()
-
-    return LocalCache.notes.values
-      .filter { (it.event is TextNoteEvent || it.event is RepostEvent) && it.author?.pubkeyHex in follows }
-      .sortedBy { it.event!!.createdAt }
-      .reversed()
-  }
-
-  override fun updateChannelFilters() {
-    // gets everthing about the user logged in
-    val newAccountFilter = createAccountFilter()
-
-    if (!equalAuthors(newAccountFilter, accountChannel.filter)) {
-      accountChannel.filter = newAccountFilter
+    fun createAccountContactListFilter(): TypedFilter {
+        return TypedFilter(
+            types = COMMON_FEED_TYPES,
+            filter = JsonFilter(
+                kinds = listOf(ContactListEvent.kind),
+                authors = listOf(account.userProfile().pubkeyHex),
+                limit = 1
+            )
+        )
    }
-  }
-}
+
+    fun createAccountMetadataFilter(): TypedFilter {
+        return TypedFilter(
+            types = COMMON_FEED_TYPES,
+            filter = JsonFilter(
+                kinds = listOf(MetadataEvent.kind),
+                authors = listOf(account.userProfile().pubkeyHex),
+                limit = 1
+            )
+        )
+    }
+
+    fun createAccountAcceptedAwardsFilter(): TypedFilter {
+        return TypedFilter(
+            types = COMMON_FEED_TYPES,
+            filter = JsonFilter(
+                kinds = listOf(BadgeProfilesEvent.kind),
+                authors = listOf(account.userProfile().pubkeyHex),
+                limit = 1
+            )
+        )
+    }
+
+    fun createAccountBookmarkListFilter(): TypedFilter {
+        return TypedFilter(
+            types = COMMON_FEED_TYPES,
+            filter = JsonFilter(
+                kinds = listOf(BookmarkListEvent.kind),
+                authors = listOf(account.userProfile().pubkeyHex),
+                limit = 1
+            )
+        )
+    }
+
+    fun createAccountReportsFilter(): TypedFilter {
+        return TypedFilter(
+            types = COMMON_FEED_TYPES,
+            filter = JsonFilter(
+                kinds = listOf(ReportEvent.kind),
+                authors = listOf(account.userProfile().pubkeyHex),
+                since = latestEOSEs.users[account.userProfile()]?.relayList
+            )
+        )
+    }
+
+    fun createNotificationFilter() = TypedFilter(
+        types = COMMON_FEED_TYPES,
+        filter = JsonFilter(
+            kinds = listOf(
+                TextNoteEvent.kind,
+                PollNoteEvent.kind,
+                ReactionEvent.kind,
+                RepostEvent.kind,
+                ReportEvent.kind,
+                LnZapEvent.kind,
+                LnZapPaymentResponseEvent.kind,
+                ChannelMessageEvent.kind,
+                BadgeAwardEvent.kind
+            ),
+            tags = mapOf("p" to listOf(account.userProfile().pubkeyHex)),
+            limit = 400,
+            since = latestEOSEs.users[account.userProfile()]?.relayList
+        )
+    )
+
+    val accountChannel = requestNewChannel { time, relayUrl ->
+        latestEOSEs.addOrUpdate(account.userProfile(), relayUrl, time)
+    }
+
+    override fun updateChannelFilters() {
+        // gets everthing about the user logged in
+        accountChannel.typedFilters = listOf(
+            createAccountMetadataFilter(),
+            createAccountContactListFilter(),
+            createNotificationFilter(),
+            createAccountReportsFilter(),
+            createAccountAcceptedAwardsFilter(),
+            createAccountBookmarkListFilter()
+        ).ifEmpty { null }
+    }
+
+    override fun auth(relay: Relay, challenge: String) {
+        super.auth(relay, challenge)
+
+        if (this::account.isInitialized) {
+            val event = account.createAuthEvent(relay, challenge)
+
+            if (event != null) {
+                Client.send(
+                    event,
+                    relay.url
+                )
+            }
+        }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/NostrChannelDataSource.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/NostrChannelDataSource.kt
@@ -0,0 +1,67 @@
+package com.vitorpamplona.amethyst.service
+
+import com.vitorpamplona.amethyst.model.Account
+import com.vitorpamplona.amethyst.model.Channel
+import com.vitorpamplona.amethyst.model.LocalCache
+import com.vitorpamplona.amethyst.service.model.ChannelMessageEvent
+import com.vitorpamplona.amethyst.service.relays.FeedType
+import com.vitorpamplona.amethyst.service.relays.JsonFilter
+import com.vitorpamplona.amethyst.service.relays.TypedFilter
+
+object NostrChannelDataSource : NostrDataSource("ChatroomFeed") {
+    var account: Account? = null
+    var channel: Channel? = null
+
+    fun loadMessagesBetween(account: Account, channelId: String) {
+        this.account = account
+        channel = LocalCache.getOrCreateChannel(channelId)
+        resetFilters()
+    }
+
+    fun clear() {
+        account = null
+        channel = null
+    }
+
+    fun createMessagesByMeToChannelFilter(): TypedFilter? {
+        val myAccount = account ?: return null
+
+        if (channel != null) {
+            // Brings on messages by the user from all other relays.
+            // Since we ship with write to public, read from private only
+            // this guarantees that messages from the author do not disappear.
+            return TypedFilter(
+                types = setOf(FeedType.FOLLOWS, FeedType.PRIVATE_DMS, FeedType.GLOBAL, FeedType.SEARCH),
+                filter = JsonFilter(
+                    kinds = listOf(ChannelMessageEvent.kind),
+                    authors = listOf(myAccount.userProfile().pubkeyHex),
+                    limit = 50
+                )
+            )
+        }
+        return null
+    }
+
+    fun createMessagesToChannelFilter(): TypedFilter? {
+        if (channel != null) {
+            return TypedFilter(
+                types = setOf(FeedType.PUBLIC_CHATS),
+                filter = JsonFilter(
+                    kinds = listOf(ChannelMessageEvent.kind),
+                    tags = mapOf("e" to listOfNotNull(channel?.idHex)),
+                    limit = 200
+                )
+            )
+        }
+        return null
+    }
+
+    val messagesChannel = requestNewChannel()
+
+    override fun updateChannelFilters() {
+        messagesChannel.typedFilters = listOfNotNull(
+            createMessagesToChannelFilter(),
+            createMessagesByMeToChannelFilter()
+        ).ifEmpty { null }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/NostrChatroomDataSource.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/NostrChatroomDataSource.kt
@@ -0,0 +1,60 @@
+package com.vitorpamplona.amethyst.service
+
+import com.vitorpamplona.amethyst.model.Account
+import com.vitorpamplona.amethyst.model.LocalCache
+import com.vitorpamplona.amethyst.model.User
+import com.vitorpamplona.amethyst.service.model.PrivateDmEvent
+import com.vitorpamplona.amethyst.service.relays.FeedType
+import com.vitorpamplona.amethyst.service.relays.JsonFilter
+import com.vitorpamplona.amethyst.service.relays.TypedFilter
+
+object NostrChatroomDataSource : NostrDataSource("ChatroomFeed") {
+    lateinit var account: Account
+    var withUser: User? = null
+
+    fun loadMessagesBetween(accountIn: Account, userId: String) {
+        account = accountIn
+        withUser = LocalCache.users[userId]
+        resetFilters()
+    }
+
+    fun createMessagesToMeFilter(): TypedFilter? {
+        val myPeer = withUser
+
+        return if (myPeer != null) {
+            TypedFilter(
+                types = setOf(FeedType.PRIVATE_DMS),
+                filter = JsonFilter(
+                    kinds = listOf(PrivateDmEvent.kind),
+                    authors = listOf(myPeer.pubkeyHex),
+                    tags = mapOf("p" to listOf(account.userProfile().pubkeyHex))
+                )
+            )
+        } else {
+            null
+        }
+    }
+
+    fun createMessagesFromMeFilter(): TypedFilter? {
+        val myPeer = withUser
+
+        return if (myPeer != null) {
+            TypedFilter(
+                types = setOf(FeedType.PRIVATE_DMS),
+                filter = JsonFilter(
+                    kinds = listOf(PrivateDmEvent.kind),
+                    authors = listOf(account.userProfile().pubkeyHex),
+                    tags = mapOf("p" to listOf(myPeer.pubkeyHex))
+                )
+            )
+        } else {
+            null
+        }
+    }
+
+    val inandoutChannel = requestNewChannel()
+
+    override fun updateChannelFilters() {
+        inandoutChannel.typedFilters = listOfNotNull(createMessagesToMeFilter(), createMessagesFromMeFilter()).ifEmpty { null }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/NostrChatroomListDataSource.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/NostrChatroomListDataSource.kt
@@ -0,0 +1,99 @@
+package com.vitorpamplona.amethyst.service
+
+import com.vitorpamplona.amethyst.model.Account
+import com.vitorpamplona.amethyst.service.model.ChannelCreateEvent
+import com.vitorpamplona.amethyst.service.model.ChannelMessageEvent
+import com.vitorpamplona.amethyst.service.model.ChannelMetadataEvent
+import com.vitorpamplona.amethyst.service.model.PrivateDmEvent
+import com.vitorpamplona.amethyst.service.relays.COMMON_FEED_TYPES
+import com.vitorpamplona.amethyst.service.relays.EOSEAccount
+import com.vitorpamplona.amethyst.service.relays.FeedType
+import com.vitorpamplona.amethyst.service.relays.JsonFilter
+import com.vitorpamplona.amethyst.service.relays.TypedFilter
+
+object NostrChatroomListDataSource : NostrDataSource("MailBoxFeed") {
+    lateinit var account: Account
+
+    val latestEOSEs = EOSEAccount()
+
+    fun createMessagesToMeFilter() = TypedFilter(
+        types = setOf(FeedType.PRIVATE_DMS),
+        filter = JsonFilter(
+            kinds = listOf(PrivateDmEvent.kind),
+            tags = mapOf("p" to listOf(account.userProfile().pubkeyHex)),
+            since = latestEOSEs.users[account.userProfile()]?.relayList
+        )
+    )
+
+    fun createMessagesFromMeFilter() = TypedFilter(
+        types = setOf(FeedType.PRIVATE_DMS),
+        filter = JsonFilter(
+            kinds = listOf(PrivateDmEvent.kind),
+            authors = listOf(account.userProfile().pubkeyHex),
+            since = latestEOSEs.users[account.userProfile()]?.relayList
+        )
+    )
+
+    fun createChannelsCreatedbyMeFilter() = TypedFilter(
+        types = setOf(FeedType.PUBLIC_CHATS),
+        filter = JsonFilter(
+            kinds = listOf(ChannelCreateEvent.kind, ChannelMetadataEvent.kind),
+            authors = listOf(account.userProfile().pubkeyHex),
+            since = latestEOSEs.users[account.userProfile()]?.relayList
+        )
+    )
+
+    fun createMyChannelsFilter() = TypedFilter(
+        types = COMMON_FEED_TYPES, // Metadata comes from any relay
+        filter = JsonFilter(
+            kinds = listOf(ChannelCreateEvent.kind),
+            ids = account.followingChannels.toList(),
+            since = latestEOSEs.users[account.userProfile()]?.relayList
+        )
+    )
+
+    fun createLastChannelInfoFilter(): List<TypedFilter> {
+        return account.followingChannels.map {
+            TypedFilter(
+                types = COMMON_FEED_TYPES, // Metadata comes from any relay
+                filter = JsonFilter(
+                    kinds = listOf(ChannelMetadataEvent.kind),
+                    tags = mapOf("e" to listOf(it)),
+                    limit = 1
+                )
+            )
+        }
+    }
+
+    fun createLastMessageOfEachChannelFilter(): List<TypedFilter> {
+        return account.followingChannels.map {
+            TypedFilter(
+                types = setOf(FeedType.PUBLIC_CHATS),
+                filter = JsonFilter(
+                    kinds = listOf(ChannelMessageEvent.kind),
+                    tags = mapOf("e" to listOf(it)),
+                    since = latestEOSEs.users[account.userProfile()]?.relayList,
+                    limit = 25 // Remember to consider spam that is being removed from the UI
+                )
+            )
+        }
+    }
+
+    val chatroomListChannel = requestNewChannel { time, relayUrl ->
+        latestEOSEs.addOrUpdate(account.userProfile(), relayUrl, time)
+    }
+
+    override fun updateChannelFilters() {
+        val list = listOf(
+            createMessagesToMeFilter(),
+            createMessagesFromMeFilter(),
+            createMyChannelsFilter()
+        )
+
+        chatroomListChannel.typedFilters = listOfNotNull(
+            list,
+            createLastChannelInfoFilter(),
+            createLastMessageOfEachChannelFilter()
+        ).flatten().ifEmpty { null }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/NostrDataSource.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/NostrDataSource.kt
@@ -1,135 +1,231 @@
 package com.vitorpamplona.amethyst.service

+import android.util.Log
 import com.vitorpamplona.amethyst.model.LocalCache
-import com.vitorpamplona.amethyst.model.Note
+import com.vitorpamplona.amethyst.service.model.*
+import com.vitorpamplona.amethyst.service.model.BadgeAwardEvent
+import com.vitorpamplona.amethyst.service.model.BadgeDefinitionEvent
+import com.vitorpamplona.amethyst.service.model.BadgeProfilesEvent
+import com.vitorpamplona.amethyst.service.model.BookmarkListEvent
+import com.vitorpamplona.amethyst.service.model.ChannelCreateEvent
+import com.vitorpamplona.amethyst.service.model.ChannelHideMessageEvent
+import com.vitorpamplona.amethyst.service.model.ChannelMessageEvent
+import com.vitorpamplona.amethyst.service.model.ChannelMetadataEvent
+import com.vitorpamplona.amethyst.service.model.ChannelMuteUserEvent
+import com.vitorpamplona.amethyst.service.model.ContactListEvent
+import com.vitorpamplona.amethyst.service.model.DeletionEvent
+import com.vitorpamplona.amethyst.service.model.Event
+import com.vitorpamplona.amethyst.service.model.LnZapEvent
+import com.vitorpamplona.amethyst.service.model.LnZapRequestEvent
+import com.vitorpamplona.amethyst.service.model.LongTextNoteEvent
+import com.vitorpamplona.amethyst.service.model.MetadataEvent
+import com.vitorpamplona.amethyst.service.model.PrivateDmEvent
 import com.vitorpamplona.amethyst.service.model.ReactionEvent
+import com.vitorpamplona.amethyst.service.model.RecommendRelayEvent
+import com.vitorpamplona.amethyst.service.model.ReportEvent
 import com.vitorpamplona.amethyst.service.model.RepostEvent
+import com.vitorpamplona.amethyst.service.model.TextNoteEvent
 import com.vitorpamplona.amethyst.service.relays.Client
 import com.vitorpamplona.amethyst.service.relays.Relay
-import java.util.Collections
-import nostr.postr.events.ContactListEvent
-import nostr.postr.events.DeletionEvent
-import nostr.postr.events.Event
-import nostr.postr.events.MetadataEvent
-import nostr.postr.events.PrivateDmEvent
-import nostr.postr.events.RecommendRelayEvent
-import nostr.postr.events.TextNoteEvent
+import com.vitorpamplona.amethyst.service.relays.Subscription
+import com.vitorpamplona.amethyst.ui.components.BundledUpdate
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+import java.util.Date
+import java.util.UUID
+import kotlin.Error

 abstract class NostrDataSource(val debugName: String) {
-  private val channels = Collections.synchronizedSet(mutableSetOf<Channel>())
-  private val channelIds =  Collections.synchronizedSet(mutableSetOf<String>())
+    private var subscriptions = mapOf<String, Subscription>()
+    data class Counter(var counter: Int)

-  private val clientListener = object : Client.Listener() {
-    override fun onEvent(event: Event, subscriptionId: String, relay: Relay) {
-      if (subscriptionId in channelIds) {
-        when (event) {
-          is MetadataEvent -> LocalCache.consume(event)
-          is TextNoteEvent -> LocalCache.consume(event)
-          is RecommendRelayEvent -> LocalCache.consume(event)
-          is ContactListEvent -> LocalCache.consume(event)
-          is PrivateDmEvent -> LocalCache.consume(event)
-          is DeletionEvent -> LocalCache.consume(event)
-          is RepostEvent -> LocalCache.consume(event)
-          is ReactionEvent -> LocalCache.consume(event)
-          else -> when (event.kind) {
-            RepostEvent.kind -> LocalCache.consume(RepostEvent(event.id, event.pubKey, event.createdAt, event.tags, event.content, event.sig))
-            ReactionEvent.kind -> LocalCache.consume(ReactionEvent(event.id, event.pubKey, event.createdAt, event.tags, event.content, event.sig))
-          }
+    private var eventCounter = mapOf<String, Counter>()
+
+    fun printCounter() {
+        eventCounter.forEach {
+            Log.d("STATE DUMP", "Received Events ${it.key}: ${it.value.counter}")
        }
-      }
    }

-    override fun onError(error: Error, subscriptionId: String, relay: Relay) {
-      //Log.e("ERROR", "Relay ${relay.url}: ${error.message}")
+    private val clientListener = object : Client.Listener() {
+        override fun onEvent(event: Event, subscriptionId: String, relay: Relay) {
+            if (subscriptionId in subscriptions.keys) {
+                if (!event.hasValidSignature()) return
+
+                val key = "$debugName $subscriptionId ${event.kind}"
+                val keyValue = eventCounter.get(key)
+                if (keyValue != null) {
+                    keyValue.counter++
+                } else {
+                    eventCounter = eventCounter + Pair(key, Counter(1))
+                }
+
+                try {
+                    when (event) {
+                        is BadgeAwardEvent -> LocalCache.consume(event)
+                        is BadgeDefinitionEvent -> LocalCache.consume(event)
+                        is BadgeProfilesEvent -> LocalCache.consume(event)
+                        is BookmarkListEvent -> LocalCache.consume(event)
+                        is ChannelCreateEvent -> LocalCache.consume(event)
+                        is ChannelHideMessageEvent -> LocalCache.consume(event)
+                        is ChannelMessageEvent -> LocalCache.consume(event, relay)
+                        is ChannelMetadataEvent -> LocalCache.consume(event)
+                        is ChannelMuteUserEvent -> LocalCache.consume(event)
+                        is ContactListEvent -> LocalCache.consume(event)
+                        is DeletionEvent -> LocalCache.consume(event)
+
+                        is FileHeaderEvent -> LocalCache.consume(event)
+                        is FileStorageEvent -> LocalCache.consume(event)
+                        is FileStorageHeaderEvent -> LocalCache.consume(event)
+                        is LnZapEvent -> {
+                            event.zapRequest?.let { onEvent(it, subscriptionId, relay) }
+                            LocalCache.consume(event)
+                        }
+                        is LnZapRequestEvent -> LocalCache.consume(event)
+                        is LnZapPaymentRequestEvent -> LocalCache.consume(event)
+                        is LnZapPaymentResponseEvent -> LocalCache.consume(event)
+                        is LongTextNoteEvent -> LocalCache.consume(event, relay)
+                        is MetadataEvent -> LocalCache.consume(event)
+                        is PrivateDmEvent -> LocalCache.consume(event, relay)
+                        is ReactionEvent -> LocalCache.consume(event)
+                        is RecommendRelayEvent -> LocalCache.consume(event)
+                        is ReportEvent -> LocalCache.consume(event, relay)
+                        is RepostEvent -> {
+                            event.containedPost()?.let { onEvent(it, subscriptionId, relay) }
+                            LocalCache.consume(event)
+                        }
+                        is TextNoteEvent -> LocalCache.consume(event, relay)
+                        is PollNoteEvent -> LocalCache.consume(event, relay)
+                        else -> {
+                            Log.w("Event Not Supported", event.toJson())
+                        }
+                    }
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                }
+            }
+        }
+
+        override fun onError(error: Error, subscriptionId: String, relay: Relay) {
+            // Log.e("ERROR", "Relay ${relay.url}: ${error.message}")
+        }
+
+        override fun onRelayStateChange(type: Relay.Type, relay: Relay, channel: String?) {
+            // Log.d("RELAY", "Relay ${relay.url} ${when (type) {
+            //  Relay.Type.CONNECT -> "connected."
+            //  Relay.Type.DISCONNECT -> "disconnected."
+            //  Relay.Type.DISCONNECTING -> "disconnecting."
+            //  Relay.Type.EOSE -> "sent all events it had stored."
+            // }}")
+
+            if (type == Relay.Type.EOSE && channel != null) {
+                // updates a per subscripton since date
+                subscriptions[channel]?.updateEOSE(Date().time / 1000, relay.url)
+            }
+        }
+
+        override fun onSendResponse(eventId: String, success: Boolean, message: String, relay: Relay) {
+        }
+
+        override fun onAuth(relay: Relay, challenge: String) {
+            auth(relay, challenge)
+        }
    }

-    override fun onRelayStateChange(type: Relay.Type, relay: Relay) {
-      //Log.d("RELAY", "Relay ${relay.url} ${when (type) {
-      //  Relay.Type.CONNECT -> "connected."
-      //  Relay.Type.DISCONNECT -> "disconnected."
-      //  Relay.Type.DISCONNECTING -> "disconnecting."
-      //  Relay.Type.EOSE -> "sent all events it had stored."
-      //}}")
+    init {
+        Client.subscribe(clientListener)
+    }

-      /*
-      if (type == Relay.Type.EOSE) {
-        // One everything is loaded, if new users are found, update filters
+    fun destroy() {
+        stop()
+        Client.unsubscribe(clientListener)
+    }
+
+    open fun start() {
+        println("DataSource: ${this.javaClass.simpleName} Start")
        resetFilters()
-      }*/
    }
-  }

-  init {
-    Client.subscribe(clientListener)
-  }
-
-  open fun start() {
-    resetFilters()
-  }
-
-  open fun stop() {
-    channels.forEach { channel ->
-      if (channel.filter != null) // if it is active, close
-        Client.close(channel.id)
-    }
-  }
-
-  fun loadTop(): List<Note> {
-    return feed().take(100)
-  }
-
-  fun requestNewChannel(): Channel {
-    val newChannel = Channel()
-    channels.add(newChannel)
-    channelIds.add(newChannel.id)
-    return newChannel
-  }
-
-  fun dismissChannel(channel: Channel) {
-    Client.close(channel.id)
-    channels.remove(channel)
-    channelIds.remove(channel.id)
-  }
-
-  fun resetFilters() {
-    // saves the channels that are currently active
-    val activeChannels = channels.filter { it.filter != null }
-    // saves the current content to only update if it changes
-    val currentFilter = activeChannels.associate { it.id to it.filter!!.toJson() }
-
-    updateChannelFilters()
-
-    // Makes sure to only send an updated filter when it actually changes.
-    channels.forEach { channel ->
-      val channelsNewFilter = channel.filter
-
-      if (channel in activeChannels) {
-        if (channelsNewFilter == null) {
-          // was active and is not active anymore, just close.
-          Client.close(channel.id)
-        } else {
-          // was active and is still active, check if it has changed.
-          if (channelsNewFilter.toJson() != currentFilter[channel.id]) {
+    open fun stop() {
+        println("DataSource: ${this.javaClass.simpleName} Stop")
+        subscriptions.values.forEach { channel ->
            Client.close(channel.id)
-            Client.sendFilter(channel.id, mutableListOf(channelsNewFilter))
-          } else {
-            // hasn't changed, does nothing.
-            Client.sendFilterOnlyIfDisconnected(channel.id, mutableListOf(channelsNewFilter))
-          }
+            channel.typedFilters = null
        }
-      } else {
-        if (channelsNewFilter == null) {
-          // was not active and is still not active, does nothing
-        } else {
-          // was not active and becomes active, sends the filter.
-          if (channelsNewFilter.toJson() != currentFilter[channel.id]) {
-            Client.sendFilter(channel.id, mutableListOf(channelsNewFilter))
-          }
-        }
-      }
    }
-  }

-  abstract fun updateChannelFilters()
-  abstract fun feed(): List<Note>
-}
+    fun requestNewChannel(onEOSE: ((Long, String) -> Unit)? = null): Subscription {
+        val newSubscription = Subscription(UUID.randomUUID().toString().substring(0, 4), onEOSE)
+        subscriptions = subscriptions + Pair(newSubscription.id, newSubscription)
+        return newSubscription
+    }
+
+    fun dismissChannel(subscription: Subscription) {
+        Client.close(subscription.id)
+        subscriptions = subscriptions.minus(subscription.id)
+    }
+
+    // Refreshes observers in batches.
+    private val bundler = BundledUpdate(250, Dispatchers.IO) {
+        // println("DataSource: ${this.javaClass.simpleName} InvalidateFilters")
+
+        // adds the time to perform the refresh into this delay
+        // holding off new updates in case of heavy refresh routines.
+        resetFiltersSuspend()
+    }
+
+    fun invalidateFilters() {
+        bundler.invalidate()
+    }
+
+    fun resetFilters() {
+        val scope = CoroutineScope(Job() + Dispatchers.IO)
+        scope.launch {
+            resetFiltersSuspend()
+        }
+    }
+
+    fun resetFiltersSuspend() {
+        // saves the channels that are currently active
+        val activeSubscriptions = subscriptions.values.filter { it.typedFilters != null }
+        // saves the current content to only update if it changes
+        val currentFilters = activeSubscriptions.associate { it.id to it.toJson() }
+
+        updateChannelFilters()
+
+        // Makes sure to only send an updated filter when it actually changes.
+        subscriptions.values.forEach { updatedSubscription ->
+            val updatedSubscriotionNewFilters = updatedSubscription.typedFilters
+
+            if (updatedSubscription.id in currentFilters.keys) {
+                if (updatedSubscriotionNewFilters == null) {
+                    // was active and is not active anymore, just close.
+                    Client.close(updatedSubscription.id)
+                } else {
+                    // was active and is still active, check if it has changed.
+                    if (updatedSubscription.toJson() != currentFilters[updatedSubscription.id]) {
+                        Client.close(updatedSubscription.id)
+                        Client.sendFilter(updatedSubscription.id, updatedSubscriotionNewFilters)
+                    } else {
+                        // hasn't changed, does nothing.
+                        Client.sendFilterOnlyIfDisconnected(updatedSubscription.id, updatedSubscriotionNewFilters)
+                    }
+                }
+            } else {
+                if (updatedSubscriotionNewFilters == null) {
+                    // was not active and is still not active, does nothing
+                } else {
+                    // was not active and becomes active, sends the filter.
+                    if (updatedSubscription.toJson() != currentFilters[updatedSubscription.id]) {
+                        Client.sendFilter(updatedSubscription.id, updatedSubscriotionNewFilters)
+                    }
+                }
+            }
+        }
+    }
+
+    abstract fun updateChannelFilters()
+    open fun auth(relay: Relay, challenge: String) = Unit
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/NostrGlobalDataSource.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/NostrGlobalDataSource.kt
@@ -1,47 +1,25 @@
 package com.vitorpamplona.amethyst.service

-import com.vitorpamplona.amethyst.model.LocalCache
-import nostr.postr.JsonFilter
-import nostr.postr.events.TextNoteEvent
+import com.vitorpamplona.amethyst.service.model.ChannelMessageEvent
+import com.vitorpamplona.amethyst.service.model.LongTextNoteEvent
+import com.vitorpamplona.amethyst.service.model.PollNoteEvent
+import com.vitorpamplona.amethyst.service.model.TextNoteEvent
+import com.vitorpamplona.amethyst.service.relays.FeedType
+import com.vitorpamplona.amethyst.service.relays.JsonFilter
+import com.vitorpamplona.amethyst.service.relays.TypedFilter

-object NostrGlobalDataSource: NostrDataSource("GlobalFeed") {
-  val fifteenMinutes = (60*15) // 15 mins
-
-  fun createGlobalFilter() = JsonFilter(
-      kinds = listOf(TextNoteEvent.kind),
-      since = System.currentTimeMillis() / 1000 - fifteenMinutes
+object NostrGlobalDataSource : NostrDataSource("GlobalFeed") {
+    fun createGlobalFilter() = TypedFilter(
+        types = setOf(FeedType.GLOBAL),
+        filter = JsonFilter(
+            kinds = listOf(TextNoteEvent.kind, PollNoteEvent.kind, ChannelMessageEvent.kind, LongTextNoteEvent.kind),
+            limit = 200
+        )
    )

-  val globalFeedChannel = requestNewChannel()
+    val globalFeedChannel = requestNewChannel()

-  fun equalTime(list1:Long?, list2:Long?): Boolean {
-    if (list1 == null && list2 == null) return true
-    if (list1 == null) return false
-    if (list2 == null) return false
-
-    return Math.abs(list1 - list2) < (4*fifteenMinutes)
-  }
-
-  fun equalFilters(list1:JsonFilter?, list2:JsonFilter?): Boolean {
-    if (list1 == null && list2 == null) return true
-    if (list1 == null) return false
-    if (list2 == null) return false
-
-    return equalTime(list1.since, list2.since)
-  }
-
-  override fun feed() = LocalCache.notes.values
-    .filter {
-      it.event is TextNoteEvent && (it.event as TextNoteEvent).replyTos.isEmpty()
+    override fun updateChannelFilters() {
+        globalFeedChannel.typedFilters = listOf(createGlobalFilter()).ifEmpty { null }
    }
-    .sortedBy { it.event!!.createdAt }
-    .reversed()
-
-  override fun updateChannelFilters() {
-    val newFilter = createGlobalFilter()
-
-    if (!equalFilters(newFilter, globalFeedChannel.filter)) {
-      globalFeedChannel.filter = newFilter
-    }
-  }
-}
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/NostrHashtagDataSource.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/NostrHashtagDataSource.kt
@@ -0,0 +1,45 @@
+package com.vitorpamplona.amethyst.service
+
+import androidx.compose.ui.text.capitalize
+import com.vitorpamplona.amethyst.service.model.ChannelMessageEvent
+import com.vitorpamplona.amethyst.service.model.LongTextNoteEvent
+import com.vitorpamplona.amethyst.service.model.TextNoteEvent
+import com.vitorpamplona.amethyst.service.relays.COMMON_FEED_TYPES
+import com.vitorpamplona.amethyst.service.relays.JsonFilter
+import com.vitorpamplona.amethyst.service.relays.TypedFilter
+
+object NostrHashtagDataSource : NostrDataSource("SingleHashtagFeed") {
+    private var hashtagToWatch: String? = null
+
+    fun createLoadHashtagFilter(): TypedFilter? {
+        val hashToLoad = hashtagToWatch ?: return null
+
+        return TypedFilter(
+            types = COMMON_FEED_TYPES,
+            filter = JsonFilter(
+                tags = mapOf(
+                    "t" to listOf(
+                        hashToLoad,
+                        hashToLoad.lowercase(),
+                        hashToLoad.uppercase(),
+                        hashToLoad.capitalize()
+                    )
+                ),
+                kinds = listOf(TextNoteEvent.kind, ChannelMessageEvent.kind, LongTextNoteEvent.kind),
+                limit = 200
+            )
+        )
+    }
+
+    val loadHashtagChannel = requestNewChannel()
+
+    override fun updateChannelFilters() {
+        loadHashtagChannel.typedFilters = listOfNotNull(createLoadHashtagFilter()).ifEmpty { null }
+    }
+
+    fun loadHashtag(tag: String?) {
+        hashtagToWatch = tag
+
+        invalidateFilters()
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/NostrHomeDataSource.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/NostrHomeDataSource.kt
@@ -1,80 +1,93 @@
 package com.vitorpamplona.amethyst.service

 import com.vitorpamplona.amethyst.model.Account
-import com.vitorpamplona.amethyst.model.LocalCache
-import com.vitorpamplona.amethyst.model.Note
 import com.vitorpamplona.amethyst.model.UserState
-import com.vitorpamplona.amethyst.service.model.RepostEvent
-import nostr.postr.JsonFilter
-import nostr.postr.events.TextNoteEvent
-import nostr.postr.toHex
+import com.vitorpamplona.amethyst.service.model.LongTextNoteEvent
+import com.vitorpamplona.amethyst.service.model.PollNoteEvent
+import com.vitorpamplona.amethyst.service.model.TextNoteEvent
+import com.vitorpamplona.amethyst.service.relays.EOSEAccount
+import com.vitorpamplona.amethyst.service.relays.FeedType
+import com.vitorpamplona.amethyst.service.relays.JsonFilter
+import com.vitorpamplona.amethyst.service.relays.TypedFilter
+import kotlinx.coroutines.DelicateCoroutinesApi
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch

-object NostrHomeDataSource: NostrDataSource("HomeFeed") {
-  lateinit var account: Account
+object NostrHomeDataSource : NostrDataSource("HomeFeed") {
+    lateinit var account: Account

-  private val cacheListener: (UserState) -> Unit = {
-    resetFilters()
-  }
+    val latestEOSEs = EOSEAccount()

-  override fun start() {
-    if (this::account.isInitialized)
-      account.userProfile().live.observeForever(cacheListener)
-    super.start()
-  }
-
-  override fun stop() {
-    super.stop()
-    if (this::account.isInitialized)
-      account.userProfile().live.removeObserver(cacheListener)
-  }
-
-  fun createFollowAccountsFilter(): JsonFilter? {
-    val follows = account.userProfile().follows?.map {
-      it.pubkey.toHex().substring(0, 6)
+    private val cacheListener: (UserState) -> Unit = {
+        invalidateFilters()
    }

-    if (follows == null || follows.isEmpty()) return null
-
-    return JsonFilter(
-      kinds = listOf(TextNoteEvent.kind, RepostEvent.kind),
-      authors = follows,
-      since = System.currentTimeMillis() / 1000 - (60 * 60 * 24 * 1), // 24 hours
-    )
-  }
-
-  val followAccountChannel = requestNewChannel()
-
-  fun <T> equalsIgnoreOrder(list1:List<T>?, list2:List<T>?): Boolean {
-    if (list1 == null && list2 == null) return true
-    if (list1 == null) return false
-    if (list2 == null) return false
-
-    return list1.size == list2.size && list1.toSet() == list2.toSet()
-  }
-
-  fun equalAuthors(list1:JsonFilter?, list2:JsonFilter?): Boolean {
-    if (list1 == null && list2 == null) return true
-    if (list1 == null) return false
-    if (list2 == null) return false
-
-    return equalsIgnoreOrder(list1.authors, list2.authors)
-  }
-
-  override fun feed(): List<Note> {
-    val user = account.userProfile()
-    val follows = user.follows.map { it.pubkeyHex }.plus(user.pubkeyHex).toSet()
-
-    return LocalCache.notes.values
-      .filter { (it.event is TextNoteEvent || it.event is RepostEvent) && it.author?.pubkeyHex in follows }
-      .sortedBy { it.event!!.createdAt }
-      .reversed()
-  }
-
-  override fun updateChannelFilters() {
-    val newFollowAccountsFilter = createFollowAccountsFilter()
-
-    if (!equalAuthors(newFollowAccountsFilter, followAccountChannel.filter)) {
-      followAccountChannel.filter = newFollowAccountsFilter
+    @OptIn(DelicateCoroutinesApi::class)
+    override fun start() {
+        if (this::account.isInitialized) {
+            GlobalScope.launch(Dispatchers.Main) {
+                account.userProfile().live().follows.observeForever(cacheListener)
+            }
+        }
+        super.start()
    }
-  }
-}
+
+    @OptIn(DelicateCoroutinesApi::class)
+    override fun stop() {
+        super.stop()
+        if (this::account.isInitialized) {
+            GlobalScope.launch(Dispatchers.Main) {
+                account.userProfile().live().follows.removeObserver(cacheListener)
+            }
+        }
+    }
+
+    fun createFollowAccountsFilter(): TypedFilter {
+        val follows = account.followingKeySet()
+
+        val followKeys = follows.map {
+            it.substring(0, 6)
+        }
+
+        val followSet = followKeys.plus(account.userProfile().pubkeyHex.substring(0, 6))
+
+        return TypedFilter(
+            types = setOf(FeedType.FOLLOWS),
+            filter = JsonFilter(
+                kinds = listOf(TextNoteEvent.kind, LongTextNoteEvent.kind, PollNoteEvent.kind),
+                authors = followSet,
+                limit = 400,
+                since = latestEOSEs.users[account.userProfile()]?.relayList
+            )
+        )
+    }
+
+    fun createFollowTagsFilter(): TypedFilter? {
+        val hashToLoad = account.followingTagSet()
+
+        if (hashToLoad.isEmpty()) return null
+
+        return TypedFilter(
+            types = setOf(FeedType.FOLLOWS),
+            filter = JsonFilter(
+                kinds = listOf(TextNoteEvent.kind, LongTextNoteEvent.kind),
+                tags = mapOf(
+                    "t" to hashToLoad.map {
+                        listOf(it, it.lowercase(), it.uppercase(), it.capitalize())
+                    }.flatten()
+                ),
+                limit = 100,
+                since = latestEOSEs.users[account.userProfile()]?.relayList
+            )
+        )
+    }
+
+    val followAccountChannel = requestNewChannel { time, relayUrl ->
+        latestEOSEs.addOrUpdate(account.userProfile(), relayUrl, time)
+    }
+
+    override fun updateChannelFilters() {
+        followAccountChannel.typedFilters = listOfNotNull(createFollowAccountsFilter(), createFollowTagsFilter()).ifEmpty { null }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/NostrLnZapPaymentResponseDataSource.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/NostrLnZapPaymentResponseDataSource.kt
@@ -0,0 +1,39 @@
+package com.vitorpamplona.amethyst.service
+
+import com.vitorpamplona.amethyst.service.model.LnZapPaymentResponseEvent
+import com.vitorpamplona.amethyst.service.relays.FeedType
+import com.vitorpamplona.amethyst.service.relays.JsonFilter
+import com.vitorpamplona.amethyst.service.relays.TypedFilter
+
+class NostrLnZapPaymentResponseDataSource(
+    private var fromServiceHex: String,
+    private var toUserHex: String,
+    private var replyingToHex: String
+) : NostrDataSource("LnZapPaymentResponseFeed") {
+
+    val feedTypes = setOf(FeedType.WALLET_CONNECT)
+
+    private fun createWalletConnectServiceWatcher(): TypedFilter {
+        // downloads all the reactions to a given event.
+        return TypedFilter(
+            types = feedTypes,
+            filter = JsonFilter(
+                kinds = listOf(LnZapPaymentResponseEvent.kind),
+                authors = listOf(fromServiceHex),
+                tags = mapOf(
+                    "e" to listOf(replyingToHex),
+                    "p" to listOf(toUserHex)
+                ),
+                limit = 1
+            )
+        )
+    }
+
+    val channel = requestNewChannel()
+
+    override fun updateChannelFilters() {
+        val wc = createWalletConnectServiceWatcher()
+
+        channel.typedFilters = listOfNotNull(wc).ifEmpty { null }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/NostrNotificationDataSource.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/NostrNotificationDataSource.kt
@@ -1,48 +0,0 @@
-package com.vitorpamplona.amethyst.service
-
-import com.vitorpamplona.amethyst.model.Account
-import com.vitorpamplona.amethyst.model.Note
-import nostr.postr.JsonFilter
-
-object NostrNotificationDataSource: NostrDataSource("GlobalFeed") {
-  lateinit var account: Account
-
-  fun createGlobalFilter() = JsonFilter(
-    since = System.currentTimeMillis() / 1000 - (60 * 60 * 24 * 7), // 2 days
-    tags = mapOf("p" to listOf(account.userProfile().pubkeyHex).filterNotNull())
-  )
-
-  val notificationChannel = requestNewChannel()
-
-  fun <T> equalsIgnoreOrder(list1:List<T>?, list2:List<T>?): Boolean {
-    if (list1 == null && list2 == null) return true
-    if (list1 == null) return false
-    if (list2 == null) return false
-
-    return list1.size == list2.size && list1.toSet() == list2.toSet()
-  }
-
-  fun equalFilters(list1:JsonFilter?, list2:JsonFilter?): Boolean {
-    if (list1 == null && list2 == null) return true
-    if (list1 == null) return false
-    if (list2 == null) return false
-
-    return equalsIgnoreOrder(list1.tags?.get("p"), list2.tags?.get("p"))
-        && equalsIgnoreOrder(list1.tags?.get("e"), list2.tags?.get("e"))
-  }
-
-  override fun feed(): List<Note> {
-    return account.userProfile().taggedPosts
-      .filter { it.event != null }
-      .sortedBy { it.event!!.createdAt }
-      .reversed()
-  }
-
-  override fun updateChannelFilters() {
-    val newFilter = createGlobalFilter()
-
-    if (!equalFilters(newFilter, notificationChannel.filter)) {
-      notificationChannel.filter = newFilter
-    }
-  }
-}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/NostrSearchEventOrUserDataSource.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/NostrSearchEventOrUserDataSource.kt
@@ -0,0 +1,85 @@
+package com.vitorpamplona.amethyst.service
+
+import com.vitorpamplona.amethyst.model.decodePublicKey
+import com.vitorpamplona.amethyst.service.model.*
+import com.vitorpamplona.amethyst.service.relays.COMMON_FEED_TYPES
+import com.vitorpamplona.amethyst.service.relays.JsonFilter
+import com.vitorpamplona.amethyst.service.relays.TypedFilter
+import nostr.postr.bechToBytes
+import nostr.postr.toHex
+
+object NostrSearchEventOrUserDataSource : NostrDataSource("SingleEventFeed") {
+    private var searchString: String? = null
+
+    private fun createAnythingWithIDFilter(): List<TypedFilter>? {
+        val mySearchString = searchString
+        if (mySearchString.isNullOrBlank()) {
+            return null
+        }
+
+        val hexToWatch = try {
+            if (mySearchString.startsWith("npub") || mySearchString.startsWith("nsec")) {
+                decodePublicKey(mySearchString).toHex()
+            } else if (mySearchString.startsWith("note")) {
+                mySearchString.bechToBytes().toHex()
+            } else {
+                mySearchString
+            }
+        } catch (e: Exception) {
+            // Usually when people add an incomplete npub or note.
+            null
+        }
+
+        // downloads all the reactions to a given event.
+        return listOfNotNull(
+            hexToWatch?.let {
+                TypedFilter(
+                    types = COMMON_FEED_TYPES,
+                    filter = JsonFilter(
+                        ids = listOfNotNull(hexToWatch)
+                    )
+                )
+            },
+            hexToWatch?.let {
+                TypedFilter(
+                    types = COMMON_FEED_TYPES,
+                    filter = JsonFilter(
+                        kinds = listOf(MetadataEvent.kind),
+                        authors = listOfNotNull(hexToWatch)
+                    )
+                )
+            },
+            TypedFilter(
+                types = COMMON_FEED_TYPES,
+                filter = JsonFilter(
+                    kinds = listOf(MetadataEvent.kind),
+                    search = mySearchString,
+                    limit = 20
+                )
+            ),
+            TypedFilter(
+                types = COMMON_FEED_TYPES,
+                filter = JsonFilter(
+                    kinds = listOf(TextNoteEvent.kind, LongTextNoteEvent.kind, PollNoteEvent.kind, ChannelMetadataEvent.kind, ChannelCreateEvent.kind, ChannelMessageEvent.kind),
+                    search = mySearchString,
+                    limit = 20
+                )
+            )
+        )
+    }
+
+    val searchChannel = requestNewChannel()
+
+    override fun updateChannelFilters() {
+        searchChannel.typedFilters = createAnythingWithIDFilter()
+    }
+
+    fun search(searchString: String) {
+        this.searchString = searchString
+        invalidateFilters()
+    }
+
+    fun clear() {
+        searchString = null
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/NostrSingleChannelDataSource.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/NostrSingleChannelDataSource.kt
@@ -0,0 +1,70 @@
+package com.vitorpamplona.amethyst.service
+
+import com.vitorpamplona.amethyst.model.LocalCache
+import com.vitorpamplona.amethyst.service.model.ChannelCreateEvent
+import com.vitorpamplona.amethyst.service.model.ChannelMetadataEvent
+import com.vitorpamplona.amethyst.service.relays.COMMON_FEED_TYPES
+import com.vitorpamplona.amethyst.service.relays.FeedType
+import com.vitorpamplona.amethyst.service.relays.JsonFilter
+import com.vitorpamplona.amethyst.service.relays.TypedFilter
+
+object NostrSingleChannelDataSource : NostrDataSource("SingleChannelFeed") {
+    private var channelsToWatch = setOf<String>()
+
+    private fun createRepliesAndReactionsFilter(): TypedFilter? {
+        val reactionsToWatch = channelsToWatch.map { it }
+
+        if (reactionsToWatch.isEmpty()) {
+            return null
+        }
+
+        // downloads all the reactions to a given event.
+        return TypedFilter(
+            types = setOf(FeedType.PUBLIC_CHATS),
+            filter = JsonFilter(
+                kinds = listOf(ChannelMetadataEvent.kind),
+                tags = mapOf("e" to reactionsToWatch)
+            )
+        )
+    }
+
+    fun createLoadEventsIfNotLoadedFilter(): TypedFilter? {
+        val directEventsToLoad = channelsToWatch
+            .map { LocalCache.getOrCreateChannel(it) }
+            .filter { it.notes.isEmpty() }
+
+        val interestedEvents = (directEventsToLoad).map { it.idHex }.toSet()
+
+        if (interestedEvents.isEmpty()) {
+            return null
+        }
+
+        // downloads linked events to this event.
+        return TypedFilter(
+            types = COMMON_FEED_TYPES,
+            filter = JsonFilter(
+                kinds = listOf(ChannelCreateEvent.kind),
+                ids = interestedEvents.toList()
+            )
+        )
+    }
+
+    val singleChannelChannel = requestNewChannel()
+
+    override fun updateChannelFilters() {
+        val reactions = createRepliesAndReactionsFilter()
+        val missing = createLoadEventsIfNotLoadedFilter()
+
+        singleChannelChannel.typedFilters = listOfNotNull(reactions, missing).ifEmpty { null }
+    }
+
+    fun add(eventId: String) {
+        channelsToWatch = channelsToWatch.plus(eventId)
+        invalidateFilters()
+    }
+
+    fun remove(eventId: String) {
+        channelsToWatch = channelsToWatch.minus(eventId)
+        invalidateFilters()
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/NostrSingleEventDataSource.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/NostrSingleEventDataSource.kt
@@ -1,70 +1,171 @@
 package com.vitorpamplona.amethyst.service

-import com.vitorpamplona.amethyst.model.LocalCache
+import com.vitorpamplona.amethyst.model.AddressableNote
 import com.vitorpamplona.amethyst.model.Note
-import java.util.Collections
-import nostr.postr.JsonFilter
+import com.vitorpamplona.amethyst.service.model.*
+import com.vitorpamplona.amethyst.service.relays.COMMON_FEED_TYPES
+import com.vitorpamplona.amethyst.service.relays.EOSETime
+import com.vitorpamplona.amethyst.service.relays.JsonFilter
+import com.vitorpamplona.amethyst.service.relays.TypedFilter

-object NostrSingleEventDataSource: NostrDataSource("SingleEventFeed") {
-  val eventsToWatch = Collections.synchronizedList(mutableListOf<String>())
+object NostrSingleEventDataSource : NostrDataSource("SingleEventFeed") {
+    private var eventsToWatch = setOf<Note>()
+    private var addressesToWatch = setOf<Note>()

-  fun createRepliesAndReactionsFilter(): JsonFilter? {
-    val reactionsToWatch = eventsToWatch.map { it.substring(0, 8) }
+    private fun createTagToAddressFilter(): List<TypedFilter>? {
+        val addressesToWatch = eventsToWatch.filter { it.address() != null } + addressesToWatch

-    if (reactionsToWatch.isEmpty()) {
-      return null
+        if (addressesToWatch.isEmpty()) {
+            return null
+        }
+
+        return addressesToWatch.mapNotNull {
+            it.address()?.let { aTag ->
+                TypedFilter(
+                    types = COMMON_FEED_TYPES,
+                    filter = JsonFilter(
+                        kinds = listOf(
+                            TextNoteEvent.kind, LongTextNoteEvent.kind,
+                            ReactionEvent.kind, RepostEvent.kind, ReportEvent.kind,
+                            LnZapEvent.kind, LnZapRequestEvent.kind,
+                            BadgeAwardEvent.kind, BadgeDefinitionEvent.kind, BadgeProfilesEvent.kind,
+                            PollNoteEvent.kind
+                        ),
+                        tags = mapOf("a" to listOf(aTag.toTag())),
+                        since = it.lastReactionsDownloadTime
+                    )
+                )
+            }
+        }
    }

-    return JsonFilter(
-      tags = mapOf("e" to reactionsToWatch)
-    )
-  }
+    private fun createAddressFilter(): List<TypedFilter>? {
+        val addressesToWatch = addressesToWatch.filter { it.event == null }

-  fun createLoadEventsIfNotLoadedFilter(): JsonFilter? {
-    val directEventsToLoad = eventsToWatch
-      .mapNotNull { LocalCache.notes[it] }
-      .filter { it.event == null }
+        if (addressesToWatch.isEmpty()) {
+            return null
+        }

-    val threadingEventsToLoad = eventsToWatch
-      .mapNotNull { LocalCache.notes[it] }
-      .mapNotNull { it.replyTo }
-      .flatten()
-      .filter { it.event == null }
-
-    val interestedEvents =
-      (directEventsToLoad + threadingEventsToLoad)
-      .map { it.idHex.substring(0, 8) }
-
-    if (interestedEvents.isEmpty()) {
-      return null
+        return addressesToWatch.mapNotNull {
+            it.address()?.let { aTag ->
+                TypedFilter(
+                    types = COMMON_FEED_TYPES,
+                    filter = JsonFilter(
+                        kinds = listOf(aTag.kind),
+                        tags = mapOf("d" to listOf(aTag.dTag)),
+                        authors = listOf(aTag.pubKeyHex.substring(0, 8))
+                    )
+                )
+            }
+        }
    }

-    return JsonFilter(
-      ids = interestedEvents
-    )
-  }
+    private fun createRepliesAndReactionsFilter(): List<TypedFilter>? {
+        val reactionsToWatch = eventsToWatch

-  val repliesAndReactionsChannel = requestNewChannel()
-  val loadEventsChannel = requestNewChannel()
+        if (reactionsToWatch.isEmpty()) {
+            return null
+        }

-  override fun feed(): List<Note> {
-    return eventsToWatch.map {
-      LocalCache.notes[it]
-    }.filterNotNull()
-  }
+        return reactionsToWatch.map {
+            TypedFilter(
+                types = COMMON_FEED_TYPES,
+                filter = JsonFilter(
+                    kinds = listOf(
+                        TextNoteEvent.kind,
+                        LongTextNoteEvent.kind,
+                        ReactionEvent.kind,
+                        RepostEvent.kind,
+                        ReportEvent.kind,
+                        LnZapEvent.kind,
+                        LnZapRequestEvent.kind,
+                        PollNoteEvent.kind
+                    ),
+                    tags = mapOf("e" to listOf(it.idHex)),
+                    since = it.lastReactionsDownloadTime
+                )
+            )
+        }
+    }

-  override fun updateChannelFilters() {
-    repliesAndReactionsChannel.filter = createRepliesAndReactionsFilter()
-    loadEventsChannel.filter = createLoadEventsIfNotLoadedFilter()
-  }
+    fun createLoadEventsIfNotLoadedFilter(): List<TypedFilter>? {
+        val directEventsToLoad = eventsToWatch
+            .filter { it.event == null }

-  fun add(eventId: String) {
-    eventsToWatch.add(eventId)
-    resetFilters()
-  }
+        val threadingEventsToLoad = eventsToWatch
+            .mapNotNull { it.replyTo }
+            .flatten()
+            .filter { it !is AddressableNote && it.event == null }

-  fun remove(eventId: String) {
-    eventsToWatch.remove(eventId)
-    resetFilters()
-  }
-}
+        val interestedEvents =
+            (directEventsToLoad + threadingEventsToLoad)
+                .map { it.idHex }.toSet()
+
+        if (interestedEvents.isEmpty()) {
+            return null
+        }
+
+        // downloads linked events to this event.
+        return listOf(
+            TypedFilter(
+                types = COMMON_FEED_TYPES,
+                filter = JsonFilter(
+                    kinds = listOf(
+                        TextNoteEvent.kind, LongTextNoteEvent.kind, PollNoteEvent.kind,
+                        ReactionEvent.kind, RepostEvent.kind,
+                        LnZapEvent.kind, LnZapRequestEvent.kind,
+                        ChannelMessageEvent.kind, ChannelCreateEvent.kind, ChannelMetadataEvent.kind,
+                        BadgeDefinitionEvent.kind, BadgeAwardEvent.kind, BadgeProfilesEvent.kind,
+                        PrivateDmEvent.kind,
+                        FileHeaderEvent.kind, FileStorageEvent.kind, FileStorageHeaderEvent.kind
+                    ),
+                    ids = interestedEvents.toList()
+                )
+            )
+        )
+    }
+
+    val singleEventChannel = requestNewChannel { time, relayUrl ->
+        eventsToWatch.forEach {
+            val eose = it.lastReactionsDownloadTime[relayUrl]
+            if (eose == null) {
+                it.lastReactionsDownloadTime = it.lastReactionsDownloadTime + Pair(relayUrl, EOSETime(time))
+            } else {
+                eose.time = time
+            }
+        }
+
+        // Many relays operate with limits in the amount of filters.
+        // As information comes, the filters will be rotated to get more data.
+        invalidateFilters()
+    }
+
+    override fun updateChannelFilters() {
+        val reactions = createRepliesAndReactionsFilter()
+        val missing = createLoadEventsIfNotLoadedFilter()
+        val addresses = createAddressFilter()
+        val addressReactions = createTagToAddressFilter()
+
+        singleEventChannel.typedFilters = listOfNotNull(missing, addresses, reactions, addressReactions).flatten().ifEmpty { null }
+    }
+
+    fun add(eventId: Note) {
+        eventsToWatch = eventsToWatch.plus(eventId)
+        invalidateFilters()
+    }
+
+    fun remove(eventId: Note) {
+        eventsToWatch = eventsToWatch.minus(eventId)
+        invalidateFilters()
+    }
+
+    fun addAddress(aTag: Note) {
+        addressesToWatch = addressesToWatch.plus(aTag)
+        invalidateFilters()
+    }
+
+    fun removeAddress(aTag: Note) {
+        addressesToWatch = addressesToWatch.minus(aTag)
+        invalidateFilters()
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/NostrSingleUserDataSource.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/NostrSingleUserDataSource.kt
@@ -1,42 +1,75 @@
 package com.vitorpamplona.amethyst.service

-import com.vitorpamplona.amethyst.model.LocalCache
-import com.vitorpamplona.amethyst.model.Note
-import java.util.Collections
-import nostr.postr.JsonFilter
-import nostr.postr.events.MetadataEvent
+import com.vitorpamplona.amethyst.model.User
+import com.vitorpamplona.amethyst.service.model.MetadataEvent
+import com.vitorpamplona.amethyst.service.model.ReportEvent
+import com.vitorpamplona.amethyst.service.relays.COMMON_FEED_TYPES
+import com.vitorpamplona.amethyst.service.relays.EOSETime
+import com.vitorpamplona.amethyst.service.relays.JsonFilter
+import com.vitorpamplona.amethyst.service.relays.TypedFilter

-object NostrSingleUserDataSource: NostrDataSource("SingleUserFeed") {
-  val usersToWatch = Collections.synchronizedList(mutableListOf<String>())
+object NostrSingleUserDataSource : NostrDataSource("SingleUserFeed") {
+    var usersToWatch = setOf<User>()

-  fun createUserFilter(): JsonFilter? {
-    if (usersToWatch.isEmpty()) return null
+    fun createUserFilter(): List<TypedFilter>? {
+        if (usersToWatch.isEmpty()) return null

-    return JsonFilter(
-      kinds = listOf(MetadataEvent.kind),
-      authors = usersToWatch.map { it.substring(0, 8) }
-    )
-  }
+        return usersToWatch.filter { it.info?.latestMetadata == null }.map {
+            TypedFilter(
+                types = COMMON_FEED_TYPES,
+                filter = JsonFilter(
+                    kinds = listOf(MetadataEvent.kind),
+                    authors = listOf(it.pubkeyHex),
+                    limit = 1
+                )
+            )
+        }
+    }

-  val userChannel = requestNewChannel()
+    fun createUserReportFilter(): List<TypedFilter>? {
+        if (usersToWatch.isEmpty()) return null

-  override fun feed(): List<Note> {
-    return usersToWatch.map {
-      LocalCache.notes[it]
-    }.filterNotNull()
-  }
+        return usersToWatch.map {
+            TypedFilter(
+                types = COMMON_FEED_TYPES,
+                filter = JsonFilter(
+                    kinds = listOf(ReportEvent.kind),
+                    tags = mapOf("p" to listOf(it.pubkeyHex)),
+                    since = it.latestEOSEs
+                )
+            )
+        }
+    }

-  override fun updateChannelFilters() {
-    userChannel.filter = createUserFilter()
-  }
+    val userChannel = requestNewChannel() { time, relayUrl ->
+        usersToWatch.forEach {
+            val eose = it.latestEOSEs[relayUrl]
+            if (eose == null) {
+                it.latestEOSEs = it.latestEOSEs + Pair(relayUrl, EOSETime(time))
+            } else {
+                eose.time = time
+            }
+        }

-  fun add(userId: String) {
-    usersToWatch.add(userId)
-    resetFilters()
-  }
+        // Many relays operate with limits in the amount of filters.
+        // As information comes, the filters will be rotated to get more data.
+        invalidateFilters()
+    }

-  fun remove(userId: String) {
-    usersToWatch.remove(userId)
-    resetFilters()
-  }
-}
+    val userChannelOnce = requestNewChannel()
+
+    override fun updateChannelFilters() {
+        userChannel.typedFilters = listOfNotNull(createUserFilter()).flatten().ifEmpty { null }
+        userChannelOnce.typedFilters = listOfNotNull(createUserReportFilter()).flatten().ifEmpty { null }
+    }
+
+    fun add(user: User) {
+        usersToWatch = usersToWatch.plus(user)
+        invalidateFilters()
+    }
+
+    fun remove(user: User) {
+        usersToWatch = usersToWatch.minus(user)
+        invalidateFilters()
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/NostrThreadDataSource.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/NostrThreadDataSource.kt
@@ -1,82 +1,43 @@
 package com.vitorpamplona.amethyst.service

-import com.vitorpamplona.amethyst.model.LocalCache
-import com.vitorpamplona.amethyst.model.Note
-import java.util.Collections
-import nostr.postr.JsonFilter
+import com.vitorpamplona.amethyst.model.ThreadAssembler
+import com.vitorpamplona.amethyst.service.relays.COMMON_FEED_TYPES
+import com.vitorpamplona.amethyst.service.relays.JsonFilter
+import com.vitorpamplona.amethyst.service.relays.TypedFilter

-object NostrThreadDataSource: NostrDataSource("SingleThreadFeed") {
-  val eventsToWatch = Collections.synchronizedList(mutableListOf<String>())
+object NostrThreadDataSource : NostrDataSource("SingleThreadFeed") {
+    private var eventToWatch: String? = null

-  fun createRepliesAndReactionsFilter(): JsonFilter? {
-    val reactionsToWatch = eventsToWatch.map { it.substring(0, 8) }
+    fun createLoadEventsIfNotLoadedFilter(): TypedFilter? {
+        val threadToLoad = eventToWatch ?: return null

-    if (reactionsToWatch.isEmpty()) {
-      return null
+        val eventsToLoad = ThreadAssembler().findThreadFor(threadToLoad)
+            .filter { it.event == null }
+            .map { it.idHex }
+            .toSet()
+            .ifEmpty { null } ?: return null
+
+        return TypedFilter(
+            types = COMMON_FEED_TYPES,
+            filter = JsonFilter(
+                ids = eventsToLoad.map { it.substring(0, 8) }
+            )
+        )
    }

-    return JsonFilter(
-      tags = mapOf("e" to reactionsToWatch)
-    )
-  }
-
-  fun createLoadEventsIfNotLoadedFilter(): JsonFilter? {
-    val eventsToLoad = eventsToWatch
-      .map { LocalCache.notes[it] }
-      .filterNotNull()
-      .filter { it.event == null }
-      .map { it.idHex.substring(0, 8) }
-
-    if (eventsToLoad.isEmpty()) {
-      return null
+    val loadEventsChannel = requestNewChannel() { _, _ ->
+        // Many relays operate with limits in the amount of filters.
+        // As information comes, the filters will be rotated to get more data.
+        invalidateFilters()
    }

-    return JsonFilter(
-      ids = eventsToLoad
-    )
-  }
-
-  val repliesAndReactionsChannel = requestNewChannel()
-  val loadEventsChannel = requestNewChannel()
-
-  override fun feed(): List<Note> {
-    return eventsToWatch.map {
-      LocalCache.notes[it]
-    }.filterNotNull()
-  }
-
-  override fun updateChannelFilters() {
-    repliesAndReactionsChannel.filter = createRepliesAndReactionsFilter()
-    loadEventsChannel.filter = createLoadEventsIfNotLoadedFilter()
-  }
-
-  fun loadThread(noteId: String) {
-    val note = LocalCache.notes[noteId] ?: return
-
-    val thread = mutableListOf<Note>()
-    val threadSet = mutableSetOf<Note>()
-
-    val threadRoot = note.replyTo?.firstOrNull() ?: note
-
-    loadDown(threadRoot, thread, threadSet)
-
-    // Currently orders by date of each event, descending, at each level of the reply stack
-    val order = compareByDescending<Note> { it.replyLevelSignature() }
-
-    eventsToWatch.clear()
-    eventsToWatch.addAll(thread.sortedWith(order).map { it.idHex })
-
-    resetFilters()
-  }
-
-  fun loadDown(note: Note, thread: MutableList<Note>, threadSet: MutableSet<Note>) {
-    if (note !in threadSet) {
-      thread.add(note)
-      threadSet.add(note)
-
-      note.replies.forEach {
-        loadDown(it, thread, threadSet)
-      }
+    override fun updateChannelFilters() {
+        loadEventsChannel.typedFilters = listOfNotNull(createLoadEventsIfNotLoadedFilter()).ifEmpty { null }
    }
-  }
-}
+
+    fun loadThread(noteId: String?) {
+        eventToWatch = noteId
+
+        invalidateFilters()
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/NostrUserProfileDataSource.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/NostrUserProfileDataSource.kt
@@ -0,0 +1,123 @@
+package com.vitorpamplona.amethyst.service
+
+import com.vitorpamplona.amethyst.model.LocalCache
+import com.vitorpamplona.amethyst.model.User
+import com.vitorpamplona.amethyst.service.model.*
+import com.vitorpamplona.amethyst.service.relays.COMMON_FEED_TYPES
+import com.vitorpamplona.amethyst.service.relays.JsonFilter
+import com.vitorpamplona.amethyst.service.relays.TypedFilter
+
+object NostrUserProfileDataSource : NostrDataSource("UserProfileFeed") {
+    var user: User? = null
+
+    fun loadUserProfile(userId: String?) {
+        if (userId != null) {
+            user = LocalCache.getOrCreateUser(userId)
+        } else {
+            user = null
+        }
+
+        resetFilters()
+    }
+
+    fun createUserInfoFilter() = user?.let {
+        TypedFilter(
+            types = COMMON_FEED_TYPES,
+            filter = JsonFilter(
+                kinds = listOf(MetadataEvent.kind),
+                authors = listOf(it.pubkeyHex),
+                limit = 1
+            )
+        )
+    }
+
+    fun createUserPostsFilter() = user?.let {
+        TypedFilter(
+            types = COMMON_FEED_TYPES,
+            filter = JsonFilter(
+                kinds = listOf(TextNoteEvent.kind, RepostEvent.kind, LongTextNoteEvent.kind, PollNoteEvent.kind),
+                authors = listOf(it.pubkeyHex),
+                limit = 200
+            )
+        )
+    }
+
+    fun createUserReceivedZapsFilter() = user?.let {
+        TypedFilter(
+            types = COMMON_FEED_TYPES,
+            filter = JsonFilter(
+                kinds = listOf(LnZapEvent.kind),
+                tags = mapOf("p" to listOf(it.pubkeyHex))
+            )
+        )
+    }
+
+    fun createFollowFilter() = user?.let {
+        TypedFilter(
+            types = COMMON_FEED_TYPES,
+            filter = JsonFilter(
+                kinds = listOf(ContactListEvent.kind),
+                authors = listOf(it.pubkeyHex),
+                limit = 1
+            )
+        )
+    }
+
+    fun createFollowersFilter() = user?.let {
+        TypedFilter(
+            types = COMMON_FEED_TYPES,
+            filter = JsonFilter(
+                kinds = listOf(ContactListEvent.kind),
+                tags = mapOf("p" to listOf(it.pubkeyHex))
+            )
+        )
+    }
+
+    fun createAcceptedAwardsFilter() = user?.let {
+        TypedFilter(
+            types = COMMON_FEED_TYPES,
+            filter = JsonFilter(
+                kinds = listOf(BadgeProfilesEvent.kind),
+                authors = listOf(it.pubkeyHex),
+                limit = 1
+            )
+        )
+    }
+
+    fun createBookmarksFilter() = user?.let {
+        TypedFilter(
+            types = COMMON_FEED_TYPES,
+            filter = JsonFilter(
+                kinds = listOf(BookmarkListEvent.kind),
+                authors = listOf(it.pubkeyHex),
+                limit = 1
+            )
+        )
+    }
+
+    fun createReceivedAwardsFilter() = user?.let {
+        TypedFilter(
+            types = COMMON_FEED_TYPES,
+            filter = JsonFilter(
+                kinds = listOf(BadgeAwardEvent.kind),
+                tags = mapOf("p" to listOf(it.pubkeyHex)),
+                limit = 20
+            )
+        )
+    }
+
+    val userInfoChannel = requestNewChannel()
+
+    override fun updateChannelFilters() {
+        userInfoChannel.typedFilters = listOfNotNull(
+            createUserInfoFilter(),
+            createUserPostsFilter(),
+            createFollowFilter(),
+            createFollowersFilter(),
+            createUserReceivedZapsFilter(),
+            createAcceptedAwardsFilter(),
+            createReceivedAwardsFilter(),
+            createBookmarksFilter()
+        ).ifEmpty { null }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/lnurl/LightningAddressResolver.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/lnurl/LightningAddressResolver.kt
@@ -0,0 +1,190 @@
+package com.vitorpamplona.amethyst.service.lnurl
+
+import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import com.vitorpamplona.amethyst.BuildConfig
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import nostr.postr.Bech32
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import java.math.BigDecimal
+import java.net.URLEncoder
+
+class LightningAddressResolver {
+    val client = OkHttpClient.Builder().build()
+
+    fun assembleUrl(lnaddress: String): String? {
+        val parts = lnaddress.split("@")
+
+        if (parts.size == 2) {
+            return "https://${parts[1]}/.well-known/lnurlp/${parts[0]}"
+        }
+
+        if (lnaddress.lowercase().startsWith("lnurl")) {
+            return try {
+                String(Bech32.decodeBytes(lnaddress, false).second)
+            } catch (e: Exception) {
+                null
+            }
+        }
+
+        return null
+    }
+
+    fun fetchLightningAddressJson(lnaddress: String, onSuccess: (String) -> Unit, onError: (String) -> Unit) {
+        val scope = CoroutineScope(Job() + Dispatchers.IO)
+        scope.launch {
+            fetchLightningAddressJsonSuspend(lnaddress, onSuccess, onError)
+        }
+    }
+
+    private suspend fun fetchLightningAddressJsonSuspend(lnaddress: String, onSuccess: (String) -> Unit, onError: (String) -> Unit) {
+        val url = assembleUrl(lnaddress)
+
+        if (url == null) {
+            onError("Could not assemble LNUrl from Lightning Address \"${lnaddress}\". Check the user's setup")
+            return
+        }
+
+        withContext(Dispatchers.IO) {
+            val request: Request = Request.Builder()
+                .header("User-Agent", "Amethyst/${BuildConfig.VERSION_NAME}")
+                .url(url)
+                .build()
+
+            client.newCall(request).enqueue(object : Callback {
+                override fun onResponse(call: Call, response: Response) {
+                    response.use {
+                        if (it.isSuccessful) {
+                            onSuccess(it.body.string())
+                        } else {
+                            onError("Could not resolve $lnaddress. Error: ${it.code}. Check if the server up and if the lightning address $lnaddress is correct")
+                        }
+                    }
+                }
+
+                override fun onFailure(call: Call, e: java.io.IOException) {
+                    onError("Could not resolve $url. Check if the server up and if the lightning address $lnaddress is correct")
+                    e.printStackTrace()
+                }
+            })
+        }
+    }
+
+    fun fetchLightningInvoice(lnCallback: String, milliSats: Long, message: String, nostrRequest: String? = null, onSuccess: (String) -> Unit, onError: (String) -> Unit) {
+        val scope = CoroutineScope(Job() + Dispatchers.IO)
+        scope.launch {
+            fetchLightningInvoiceSuspend(lnCallback, milliSats, message, nostrRequest, onSuccess, onError)
+        }
+    }
+
+    private suspend fun fetchLightningInvoiceSuspend(lnCallback: String, milliSats: Long, message: String, nostrRequest: String? = null, onSuccess: (String) -> Unit, onError: (String) -> Unit) {
+        withContext(Dispatchers.IO) {
+            val encodedMessage = URLEncoder.encode(message, "utf-8")
+
+            val urlBinder = if (lnCallback.contains("?")) "&" else "?"
+            var url = "$lnCallback${urlBinder}amount=$milliSats&comment=$encodedMessage"
+
+            if (nostrRequest != null) {
+                val encodedNostrRequest = URLEncoder.encode(nostrRequest, "utf-8")
+                url += "&nostr=$encodedNostrRequest"
+            }
+
+            val request: Request = Request.Builder()
+                .header("User-Agent", "Amethyst/${BuildConfig.VERSION_NAME}")
+                .url(url)
+                .build()
+
+            client.newCall(request).enqueue(object : Callback {
+                override fun onResponse(call: Call, response: Response) {
+                    response.use {
+                        if (it.isSuccessful) {
+                            onSuccess(response.body.string())
+                        } else {
+                            onError("Could not fetch invoice from $lnCallback")
+                        }
+                    }
+                }
+
+                override fun onFailure(call: Call, e: java.io.IOException) {
+                    onError("Could not fetch an invoice from $lnCallback. Message ${e.message}")
+                    e.printStackTrace()
+                }
+            })
+        }
+    }
+
+    fun lnAddressToLnUrl(lnaddress: String, onSuccess: (String) -> Unit, onError: (String) -> Unit) {
+        fetchLightningAddressJson(
+            lnaddress,
+            onSuccess = {
+                onSuccess(Bech32.encodeBytes("lnurl", it.toByteArray(), Bech32.Encoding.Bech32))
+            },
+            onError = onError
+        )
+    }
+
+    fun lnAddressInvoice(lnaddress: String, milliSats: Long, message: String, nostrRequest: String? = null, onSuccess: (String) -> Unit, onError: (String) -> Unit, onProgress: (percent: Float) -> Unit) {
+        val mapper = jacksonObjectMapper()
+
+        fetchLightningAddressJson(
+            lnaddress,
+            onSuccess = { lnAddressJson ->
+                onProgress(0.4f)
+
+                val lnurlp = try {
+                    mapper.readTree(lnAddressJson)
+                } catch (t: Throwable) {
+                    onError("Error Parsing JSON from Lightning Address. Check the user's lightning setup")
+                    null
+                }
+
+                val callback = lnurlp?.get("callback")?.asText()
+
+                if (callback == null) {
+                    onError("Callback URL not found in the User's lightning address server configuration")
+                }
+
+                val allowsNostr = lnurlp?.get("allowsNostr")?.asBoolean() ?: false
+
+                callback?.let { cb ->
+                    fetchLightningInvoice(
+                        cb,
+                        milliSats,
+                        message,
+                        if (allowsNostr) nostrRequest else null,
+                        onSuccess = {
+                            onProgress(0.6f)
+
+                            val lnInvoice = try {
+                                mapper.readTree(it)
+                            } catch (t: Throwable) {
+                                onError("Error Parsing JSON from Lightning Address's invoice fetch. Check the user's lightning setup")
+                                null
+                            }
+
+                            lnInvoice?.get("pr")?.asText()?.let { pr ->
+                                // Forces LN Invoice amount to be the requested amount.
+                                val invoiceAmount = LnInvoiceUtil.getAmountInSats(pr)
+                                if (invoiceAmount.multiply(BigDecimal(1000)).toLong() == BigDecimal(milliSats).toLong()) {
+                                    onProgress(0.7f)
+                                    onSuccess(pr)
+                                } else {
+                                    onError("Incorrect invoice amount (${invoiceAmount.toLong()} sats) from server")
+                                }
+                            } ?: onError("Invoice Not Created (element pr not found in the resulting JSON)")
+                        },
+                        onError = onError
+                    )
+                }
+            },
+            onError = onError
+        )
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/lnurl/LnInvoiceUtil.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/lnurl/LnInvoiceUtil.kt
@@ -0,0 +1,173 @@
+package com.vitorpamplona.amethyst.service.lnurl
+
+import java.math.BigDecimal
+import java.util.Locale
+import java.util.regex.Pattern
+
+/** based on litecoinj */
+object LnInvoiceUtil {
+    private val invoicePattern = Pattern.compile("lnbc((?<amount>\\d+)(?<multiplier>[munp])?)?1[^1\\s]+", Pattern.CASE_INSENSITIVE)
+
+    /** The Bech32 character set for encoding.  */
+    private const val CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l"
+
+    /** The Bech32 character set for decoding.  */
+    private val CHARSET_REV = byteArrayOf(
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        15, -1, 10, 17, 21, 20, 26, 30, 7, 5, -1, -1, -1, -1, -1, -1,
+        -1, 29, -1, 24, 13, 25, 9, 8, 23, -1, 18, 22, 31, 27, 19, -1,
+        1, 0, 3, 16, 11, 28, 12, 14, 6, 4, 2, -1, -1, -1, -1, -1,
+        -1, 29, -1, 24, 13, 25, 9, 8, 23, -1, 18, 22, 31, 27, 19, -1,
+        1, 0, 3, 16, 11, 28, 12, 14, 6, 4, 2, -1, -1, -1, -1, -1
+    )
+
+    /** Find the polynomial with value coefficients mod the generator as 30-bit.  */
+    private fun polymod(values: ByteArray): Int {
+        var c = 1
+        for (v_i in values) {
+            val c0 = c ushr 25 and 0xff
+            c = c and 0x1ffffff shl 5 xor (v_i.toInt() and 0xff)
+            if (c0 and 1 != 0) c = c xor 0x3b6a57b2
+            if (c0 and 2 != 0) c = c xor 0x26508e6d
+            if (c0 and 4 != 0) c = c xor 0x1ea119fa
+            if (c0 and 8 != 0) c = c xor 0x3d4233dd
+            if (c0 and 16 != 0) c = c xor 0x2a1462b3
+        }
+        return c
+    }
+
+    /** Expand a HRP for use in checksum computation.  */
+    private fun expandHrp(hrp: String): ByteArray {
+        val hrpLength = hrp.length
+        val ret = ByteArray(hrpLength * 2 + 1)
+        for (i in 0 until hrpLength) {
+            val c = hrp[i].code and 0x7f // Limit to standard 7-bit ASCII
+            ret[i] = (c ushr 5 and 0x07).toByte()
+            ret[i + hrpLength + 1] = (c and 0x1f).toByte()
+        }
+        ret[hrpLength] = 0
+        return ret
+    }
+
+    /** Verify a checksum.  */
+    private fun verifyChecksum(hrp: String, values: ByteArray): Boolean {
+        val hrpExpanded: ByteArray = expandHrp(hrp)
+        val combined = ByteArray(hrpExpanded.size + values.size)
+        System.arraycopy(hrpExpanded, 0, combined, 0, hrpExpanded.size)
+        System.arraycopy(values, 0, combined, hrpExpanded.size, values.size)
+        return polymod(combined) == 1
+    }
+
+    class AddressFormatException(message: String) : Exception(message)
+
+    fun decodeUnlimitedLength(invoice: String): Boolean {
+        var lower = false
+        var upper = false
+        for (i in 0 until invoice.length) {
+            val c = invoice[i]
+            if (c.code < 33 || c.code > 126) throw AddressFormatException("Invalid character: $c, pos: $i")
+            if (c in 'a'..'z') {
+                if (upper) throw AddressFormatException("Invalid character: $c, pos: $i")
+                lower = true
+            }
+            if (c in 'A'..'Z') {
+                if (lower) throw AddressFormatException("Invalid character: $c, pos: $i")
+                upper = true
+            }
+        }
+        val pos = invoice.lastIndexOf('1')
+        if (pos < 1) throw AddressFormatException("Missing human-readable part")
+        val dataPartLength = invoice.length - 1 - pos
+        if (dataPartLength < 6) throw AddressFormatException("Data part too short: $dataPartLength")
+        val values = ByteArray(dataPartLength)
+        for (i in 0 until dataPartLength) {
+            val c = invoice[i + pos + 1]
+            if (CHARSET_REV.get(c.code).toInt() == -1) throw AddressFormatException("Invalid character: " + c + ", pos: " + (i + pos + 1))
+            values[i] = CHARSET_REV.get(c.code)
+        }
+        val hrp = invoice.substring(0, pos).lowercase(Locale.ROOT)
+        if (!verifyChecksum(hrp, values)) throw AddressFormatException("Invalid Checksum")
+        return true
+    }
+
+    /**
+     * Parses invoice amount according to
+     * https://github.com/lightningnetwork/lightning-rfc/blob/master/11-payment-encoding.md#human-readable-part
+     * @return invoice amount in bitcoins, zero if the invoice has no amount
+     * @throws RuntimeException if invoice format is incorrect
+     */
+    fun getAmount(invoice: String): BigDecimal {
+        try {
+            decodeUnlimitedLength(invoice) // checksum must match
+        } catch (e: AddressFormatException) {
+            throw IllegalArgumentException("Cannot decode invoice", e)
+        }
+
+        val matcher = invoicePattern.matcher(invoice)
+        require(matcher.matches()) { "Failed to match HRP pattern" }
+        val amountGroup = matcher.group("amount")
+        val multiplierGroup = matcher.group("multiplier")
+        if (amountGroup == null) {
+            return BigDecimal.ZERO
+        }
+        val amount = BigDecimal(amountGroup)
+        if (multiplierGroup == null) {
+            return amount
+        }
+        require(!(multiplierGroup == "p" && amountGroup[amountGroup.length - 1] != '0')) { "sub-millisatoshi amount" }
+        return amount.multiply(multiplier(multiplierGroup))
+    }
+
+    fun getAmountInSats(invoice: String): BigDecimal {
+        return getAmount(invoice).multiply(BigDecimal(100000000))
+    }
+
+    private fun multiplier(multiplier: String): BigDecimal {
+        return when (multiplier.lowercase()) {
+            "m" -> BigDecimal("0.001")
+            "u" -> BigDecimal("0.000001")
+            "n" -> BigDecimal("0.000000001")
+            "p" -> BigDecimal("0.000000000001")
+            else -> throw IllegalArgumentException("Invalid multiplier: $multiplier")
+        }
+    }
+
+    /**
+     * Finds LN invoice in the provided input string and returns it.
+     * For example for input = "aaa bbb lnbc1xxx ccc" it will return "lnbc1xxx"
+     * It will only return the first invoice found in the input.
+     *
+     * @return the invoice if it was found. null for null input or if no invoice is found
+     */
+    fun findInvoice(input: String?): String? {
+        if (input == null) {
+            return null
+        }
+        val matcher = invoicePattern.matcher(input)
+        return if (matcher.find()) {
+            matcher.group()
+        } else {
+            null
+        }
+    }
+
+    /**
+     * If the string contains an LN invoice, returns a Pair of the start and end
+     * positions of the invoice in the string. Otherwise, returns (0, 0). This is
+     * used to ensure we don't accidentally cut an invoice in the middle when taking
+     * only a portion of the available text.
+     */
+    fun locateInvoice(input: String?): Pair<Int, Int> {
+        if (input == null) {
+            return Pair(0, 0)
+        }
+        val matcher = invoicePattern.matcher(input)
+        return if (matcher.find()) {
+            Pair(matcher.start(), matcher.end())
+        } else {
+            Pair(0, 0)
+        }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/lnurl/LnWithdrawalUtil.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/lnurl/LnWithdrawalUtil.kt
@@ -0,0 +1,29 @@
+package com.vitorpamplona.amethyst.service.lnurl
+
+import java.util.regex.Pattern
+
+object LnWithdrawalUtil {
+    private val withdrawalPattern = Pattern.compile(
+        "lnurl.*",
+        Pattern.CASE_INSENSITIVE
+    )
+
+    /**
+     * Finds LN withdrawal in the provided input string and returns it.
+     * For example for input = "aaa bbb lnbc1xxx ccc" it will return "lnbc1xxx"
+     * It will only return the first withdrawal found in the input.
+     *
+     * @return the invoice if it was found. null for null input or if no invoice is found
+     */
+    fun findWithdrawal(input: String?): String? {
+        if (input == null) {
+            return null
+        }
+        val matcher = withdrawalPattern.matcher(input)
+        return if (matcher.find()) {
+            matcher.group()
+        } else {
+            null
+        }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/ATag.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/ATag.kt
@@ -0,0 +1,81 @@
+package com.vitorpamplona.amethyst.service.model
+
+import android.util.Log
+import com.vitorpamplona.amethyst.model.toByteArray
+import com.vitorpamplona.amethyst.model.toHexKey
+import com.vitorpamplona.amethyst.service.nip19.Tlv
+import fr.acinq.secp256k1.Hex
+import nostr.postr.Bech32
+import nostr.postr.bechToBytes
+import nostr.postr.toByteArray
+
+data class ATag(val kind: Int, val pubKeyHex: String, val dTag: String, val relay: String?) {
+    fun toTag() = "$kind:$pubKeyHex:$dTag"
+
+    fun toNAddr(): String {
+        val kind = kind.toByteArray()
+        val author = pubKeyHex.toByteArray()
+        val dTag = dTag.toByteArray(Charsets.UTF_8)
+        val relay = relay?.toByteArray(Charsets.UTF_8)
+
+        var fullArray = byteArrayOf(Tlv.Type.SPECIAL.id, dTag.size.toByte()) + dTag
+
+        if (relay != null) {
+            fullArray = fullArray + byteArrayOf(Tlv.Type.RELAY.id, relay.size.toByte()) + relay
+        }
+
+        fullArray = fullArray +
+            byteArrayOf(Tlv.Type.AUTHOR.id, author.size.toByte()) + author +
+            byteArrayOf(Tlv.Type.KIND.id, kind.size.toByte()) + kind
+
+        return Bech32.encodeBytes(hrp = "naddr", fullArray, Bech32.Encoding.Bech32)
+    }
+
+    companion object {
+        fun isATag(key: String): Boolean {
+            return key.startsWith("naddr1") || key.contains(":")
+        }
+
+        fun parse(address: String, relay: String?): ATag? {
+            return if (address.startsWith("naddr") || address.startsWith("nostr:naddr")) {
+                parseNAddr(address)
+            } else {
+                parseAtag(address, relay)
+            }
+        }
+
+        fun parseAtag(atag: String, relay: String?): ATag? {
+            return try {
+                val parts = atag.split(":")
+                Hex.decode(parts[1])
+                ATag(parts[0].toInt(), parts[1], parts[2], relay)
+            } catch (t: Throwable) {
+                Log.w("ATag", "Error parsing A Tag: $atag: ${t.message}")
+                null
+            }
+        }
+
+        fun parseNAddr(naddr: String): ATag? {
+            try {
+                val key = naddr.removePrefix("nostr:")
+
+                if (key.startsWith("naddr")) {
+                    val tlv = Tlv.parse(key.bechToBytes())
+                    val d = tlv.get(Tlv.Type.SPECIAL.id)?.get(0)?.toString(Charsets.UTF_8) ?: ""
+                    val relay = tlv.get(Tlv.Type.RELAY.id)?.get(0)?.toString(Charsets.UTF_8)
+                    val author = tlv.get(Tlv.Type.AUTHOR.id)?.get(0)?.toHexKey()
+                    val kind = tlv.get(Tlv.Type.KIND.id)?.get(0)?.let { Tlv.toInt32(it) }
+
+                    if (kind != null && author != null) {
+                        return ATag(kind, author, d, relay)
+                    }
+                }
+            } catch (e: Throwable) {
+                Log.w("ATag", "Issue trying to Decode NIP19 $this: ${e.message}")
+                // e.printStackTrace()
+            }
+
+            return null
+        }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/BadgeAwardEvent.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/BadgeAwardEvent.kt
@@ -0,0 +1,24 @@
+package com.vitorpamplona.amethyst.service.model
+
+import com.vitorpamplona.amethyst.model.HexKey
+
+class BadgeAwardEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
+    fun awardees() = tags.filter { it.firstOrNull() == "p" }.mapNotNull { it.getOrNull(1) }
+    fun awardDefinition() = tags.filter { it.firstOrNull() == "a" }.mapNotNull {
+        val aTagValue = it.getOrNull(1)
+        val relay = it.getOrNull(2)
+
+        if (aTagValue != null) ATag.parse(aTagValue, relay) else null
+    }
+
+    companion object {
+        const val kind = 8
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/BadgeDefinitionEvent.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/BadgeDefinitionEvent.kt
@@ -0,0 +1,24 @@
+package com.vitorpamplona.amethyst.service.model
+
+import com.vitorpamplona.amethyst.model.HexKey
+
+class BadgeDefinitionEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
+    fun dTag() = tags.filter { it.firstOrNull() == "d" }.mapNotNull { it.getOrNull(1) }.firstOrNull() ?: ""
+    fun address() = ATag(kind, pubKey, dTag(), null)
+
+    fun name() = tags.filter { it.firstOrNull() == "name" }.mapNotNull { it.getOrNull(1) }.firstOrNull()
+    fun thumb() = tags.filter { it.firstOrNull() == "thumb" }.mapNotNull { it.getOrNull(1) }.firstOrNull()
+    fun image() = tags.filter { it.firstOrNull() == "image" }.mapNotNull { it.getOrNull(1) }.firstOrNull()
+    fun description() = tags.filter { it.firstOrNull() == "description" }.mapNotNull { it.getOrNull(1) }.firstOrNull()
+
+    companion object {
+        const val kind = 30009
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/BadgeProfilesEvent.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/BadgeProfilesEvent.kt
@@ -0,0 +1,27 @@
+package com.vitorpamplona.amethyst.service.model
+
+import com.vitorpamplona.amethyst.model.HexKey
+
+class BadgeProfilesEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
+    fun badgeAwardEvents() = tags.filter { it.firstOrNull() == "e" }.mapNotNull { it.getOrNull(1) }
+    fun badgeAwardDefinitions() = tags.filter { it.firstOrNull() == "a" }.mapNotNull {
+        val aTagValue = it.getOrNull(1)
+        val relay = it.getOrNull(2)
+
+        if (aTagValue != null) ATag.parse(aTagValue, relay) else null
+    }
+
+    fun dTag() = tags.filter { it.firstOrNull() == "d" }.mapNotNull { it.getOrNull(1) }.firstOrNull() ?: ""
+    fun address() = ATag(kind, pubKey, dTag(), null)
+
+    companion object {
+        const val kind = 30008
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/BaseTextNoteEvent.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/BaseTextNoteEvent.kt
@@ -0,0 +1,123 @@
+package com.vitorpamplona.amethyst.service.model
+
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.tagSearch
+import com.vitorpamplona.amethyst.service.nip19.Nip19
+import com.vitorpamplona.amethyst.service.nip19.Nip19.nip19regex
+
+open class BaseTextNoteEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    kind: Int,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
+    fun mentions() = taggedUsers()
+    open fun replyTos() = tags.filter { it.firstOrNull() == "e" }.mapNotNull { it.getOrNull(1) }
+
+    private var citedUsersCache: Set<HexKey>? = null
+
+    fun citedUsers(): Set<HexKey> {
+        citedUsersCache?.let { return it }
+
+        val matcher = tagSearch.matcher(content)
+        val returningList = mutableSetOf<String>()
+        while (matcher.find()) {
+            try {
+                val tag = matcher.group(1)?.let { tags[it.toInt()] }
+                if (tag != null && tag.size > 1 && tag[0] == "p") {
+                    returningList.add(tag[1])
+                }
+            } catch (e: Exception) {
+            }
+        }
+
+        val matcher2 = nip19regex.matcher(content)
+        while (matcher2.find()) {
+            val uriScheme = matcher2.group(1) // nostr:
+            val type = matcher2.group(2) // npub1
+            val key = matcher2.group(3) // bech32
+            val additionalChars = matcher2.group(4) // additional chars
+
+            val parsed = Nip19.parseComponents(uriScheme, type, key, additionalChars)
+
+            if (parsed != null) {
+                try {
+                    val tag = tags.firstOrNull { it.size > 1 && it[1] == parsed.hex }
+
+                    if (tag != null && tag[0] == "p") {
+                        returningList.add(tag[1])
+                    }
+                } catch (e: Exception) {
+                }
+            }
+        }
+
+        citedUsersCache = returningList
+        return returningList
+    }
+
+    fun findCitations(): Set<String> {
+        var citations = mutableSetOf<String>()
+        // Removes citations from replies:
+        val matcher = tagSearch.matcher(content)
+        while (matcher.find()) {
+            try {
+                val tag = matcher.group(1)?.let { tags[it.toInt()] }
+                if (tag != null && tag.size > 1 && tag[0] == "e") {
+                    citations.add(tag[1])
+                }
+                if (tag != null && tag.size > 1 && tag[0] == "a") {
+                    citations.add(tag[1])
+                }
+            } catch (e: Exception) {
+            }
+        }
+
+        val matcher2 = nip19regex.matcher(content)
+        while (matcher2.find()) {
+            val uriScheme = matcher2.group(1) // nostr:
+            val type = matcher2.group(2) // npub1
+            val key = matcher2.group(3) // bech32
+            val additionalChars = matcher2.group(4) // additional chars
+
+            val parsed = Nip19.parseComponents(uriScheme, type, key, additionalChars)
+
+            if (parsed != null) {
+                if (content.contains("Testing event")) {
+                    println("AAAA $key")
+                }
+
+                try {
+                    val tag = tags.firstOrNull { it.size > 1 && it[1] == parsed.hex }
+
+                    if (tag != null && tag[0] == "e") {
+                        citations.add(tag[1])
+                    }
+                    if (tag != null && tag[0] == "a") {
+                        citations.add(tag[1])
+                    }
+                } catch (e: Exception) {
+                }
+            }
+        }
+
+        return citations
+    }
+
+    fun tagsWithoutCitations(): List<String> {
+        val repliesTo = replyTos()
+        val tagAddresses = taggedAddresses().map { it.toTag() }
+        if (repliesTo.isEmpty() && tagAddresses.isEmpty()) return emptyList()
+
+        val citations = findCitations()
+
+        return if (citations.isEmpty()) {
+            repliesTo + tagAddresses
+        } else {
+            repliesTo.filter { it !in citations }
+        }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/BookmarkListEvent.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/BookmarkListEvent.kt
@@ -0,0 +1,117 @@
+package com.vitorpamplona.amethyst.service.model
+
+import android.util.Log
+import com.google.gson.reflect.TypeToken
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.toByteArray
+import com.vitorpamplona.amethyst.model.toHexKey
+import nostr.postr.Utils
+import java.util.Date
+
+class BookmarkListEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
+    fun dTag() = tags.filter { it.firstOrNull() == "d" }.mapNotNull { it.getOrNull(1) }.firstOrNull() ?: ""
+    fun address() = ATag(kind, pubKey, dTag(), null)
+
+    fun category() = dTag()
+    fun bookmarkedPosts() = tags.filter { it[0] == "e" }.mapNotNull { it.getOrNull(1) }
+
+    fun plainContent(privKey: ByteArray): String? {
+        return try {
+            val sharedSecret = Utils.getSharedSecret(privKey, pubKey.toByteArray())
+
+            return Utils.decrypt(content, sharedSecret)
+        } catch (e: Exception) {
+            Log.w("BookmarkList", "Error decrypting the message ${e.message}")
+            null
+        }
+    }
+
+    @Transient
+    private var privateTagsCache: List<List<String>>? = null
+
+    fun privateTags(privKey: ByteArray): List<List<String>>? {
+        if (privateTagsCache != null) {
+            return privateTagsCache
+        }
+
+        privateTagsCache = try {
+            gson.fromJson(plainContent(privKey), object : TypeToken<List<List<String>>>() {}.type)
+        } catch (e: Throwable) {
+            Log.w("BookmarkList", "Error parsing the JSON ${e.message}")
+            null
+        }
+        return privateTagsCache
+    }
+
+    fun privateTaggedUsers(privKey: ByteArray) = privateTags(privKey)?.filter { it.firstOrNull() == "p" }?.mapNotNull { it.getOrNull(1) }
+    fun privateTaggedEvents(privKey: ByteArray) = privateTags(privKey)?.filter { it.firstOrNull() == "e" }?.mapNotNull { it.getOrNull(1) }
+    fun privateTaggedAddresses(privKey: ByteArray) = privateTags(privKey)?.filter { it.firstOrNull() == "a" }?.mapNotNull {
+        val aTagValue = it.getOrNull(1)
+        val relay = it.getOrNull(2)
+
+        if (aTagValue != null) ATag.parse(aTagValue, relay) else null
+    }
+
+    companion object {
+        const val kind = 30001
+
+        fun create(
+            name: String = "",
+
+            events: List<String>? = null,
+            users: List<String>? = null,
+            addresses: List<ATag>? = null,
+
+            privEvents: List<String>? = null,
+            privUsers: List<String>? = null,
+            privAddresses: List<ATag>? = null,
+
+            privateKey: ByteArray,
+            createdAt: Long = Date().time / 1000
+        ): BookmarkListEvent {
+            val pubKey = Utils.pubkeyCreate(privateKey)
+
+            val privTags = mutableListOf<List<String>>()
+            privEvents?.forEach {
+                privTags.add(listOf("e", it))
+            }
+            privUsers?.forEach {
+                privTags.add(listOf("p", it))
+            }
+            privAddresses?.forEach {
+                privTags.add(listOf("a", it.toTag()))
+            }
+            val msg = gson.toJson(privTags)
+
+            val content = Utils.encrypt(
+                msg,
+                privateKey,
+                pubKey
+            )
+
+            val tags = mutableListOf<List<String>>()
+            tags.add(listOf("d", name))
+
+            events?.forEach {
+                tags.add(listOf("e", it))
+            }
+            users?.forEach {
+                tags.add(listOf("p", it))
+            }
+            addresses?.forEach {
+                tags.add(listOf("a", it.toTag()))
+            }
+
+            val id = generateId(pubKey.toHexKey(), createdAt, kind, tags, content)
+            val sig = Utils.sign(id, privateKey)
+            return BookmarkListEvent(id.toHexKey(), pubKey.toHexKey(), createdAt, tags, content, sig.toHexKey())
+        }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/ChannelCreateEvent.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/ChannelCreateEvent.kt
@@ -0,0 +1,48 @@
+package com.vitorpamplona.amethyst.service.model
+
+import android.util.Log
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.toHexKey
+import nostr.postr.Utils
+import java.util.Date
+
+class ChannelCreateEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
+    fun channelInfo(): ChannelData = try {
+        MetadataEvent.gson.fromJson(content, ChannelData::class.java)
+    } catch (e: Exception) {
+        Log.e("ChannelMetadataEvent", "Can't parse channel info $content", e)
+        ChannelData(null, null, null)
+    }
+
+    companion object {
+        const val kind = 40
+
+        fun create(channelInfo: ChannelData?, privateKey: ByteArray, createdAt: Long = Date().time / 1000): ChannelCreateEvent {
+            val content = try {
+                if (channelInfo != null) {
+                    gson.toJson(channelInfo)
+                } else {
+                    ""
+                }
+            } catch (t: Throwable) {
+                Log.e("ChannelCreateEvent", "Couldn't parse channel information", t)
+                ""
+            }
+
+            val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
+            val tags = emptyList<List<String>>()
+            val id = generateId(pubKey, createdAt, kind, tags, content)
+            val sig = Utils.sign(id, privateKey)
+            return ChannelCreateEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
+        }
+    }
+
+    data class ChannelData(var name: String?, var about: String?, var picture: String?)
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/ChannelHideMessageEvent.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/ChannelHideMessageEvent.kt
@@ -0,0 +1,33 @@
+package com.vitorpamplona.amethyst.service.model
+
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.toHexKey
+import nostr.postr.Utils
+import java.util.Date
+
+class ChannelHideMessageEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
+    fun eventsToHide() = tags.filter { it.firstOrNull() == "e" }.mapNotNull { it.getOrNull(1) }
+
+    companion object {
+        const val kind = 43
+
+        fun create(reason: String, messagesToHide: List<String>?, privateKey: ByteArray, createdAt: Long = Date().time / 1000): ChannelHideMessageEvent {
+            val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
+            val tags =
+                messagesToHide?.map {
+                    listOf("e", it)
+                } ?: emptyList()
+
+            val id = generateId(pubKey, createdAt, kind, tags, reason)
+            val sig = Utils.sign(id, privateKey)
+            return ChannelHideMessageEvent(id.toHexKey(), pubKey, createdAt, tags, reason, sig.toHexKey())
+        }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/ChannelMessageEvent.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/ChannelMessageEvent.kt
@@ -0,0 +1,44 @@
+package com.vitorpamplona.amethyst.service.model
+
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.toHexKey
+import nostr.postr.Utils
+import java.util.Date
+
+class ChannelMessageEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : BaseTextNoteEvent(id, pubKey, createdAt, kind, tags, content, sig) {
+
+    fun channel() = tags.firstOrNull { it[0] == "e" && it.size > 3 && it[3] == "root" }?.getOrNull(1) ?: tags.firstOrNull { it.firstOrNull() == "e" }?.getOrNull(1)
+    override fun replyTos() = tags.filter { it.firstOrNull() == "e" && it.getOrNull(1) != channel() }.mapNotNull { it.getOrNull(1) }
+
+    companion object {
+        const val kind = 42
+
+        fun create(message: String, channel: String, replyTos: List<String>? = null, mentions: List<String>? = null, zapReceiver: String?, privateKey: ByteArray, createdAt: Long = Date().time / 1000): ChannelMessageEvent {
+            val content = message
+            val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
+            val tags = mutableListOf(
+                listOf("e", channel, "", "root")
+            )
+            replyTos?.forEach {
+                tags.add(listOf("e", it))
+            }
+            mentions?.forEach {
+                tags.add(listOf("p", it))
+            }
+            zapReceiver?.let {
+                tags.add(listOf("zap", it))
+            }
+
+            val id = generateId(pubKey, createdAt, kind, tags, content)
+            val sig = Utils.sign(id, privateKey)
+            return ChannelMessageEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
+        }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/ChannelMetadataEvent.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/ChannelMetadataEvent.kt
@@ -0,0 +1,44 @@
+package com.vitorpamplona.amethyst.service.model
+
+import android.util.Log
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.toHexKey
+import nostr.postr.Utils
+import java.util.Date
+
+class ChannelMetadataEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
+    fun channel() = tags.firstOrNull { it.firstOrNull() == "e" }?.getOrNull(1)
+    fun channelInfo() =
+        try {
+            MetadataEvent.gson.fromJson(content, ChannelCreateEvent.ChannelData::class.java)
+        } catch (e: Exception) {
+            Log.e("ChannelMetadataEvent", "Can't parse channel info $content", e)
+            ChannelCreateEvent.ChannelData(null, null, null)
+        }
+
+    companion object {
+        const val kind = 41
+
+        fun create(newChannelInfo: ChannelCreateEvent.ChannelData?, originalChannelIdHex: String, privateKey: ByteArray, createdAt: Long = Date().time / 1000): ChannelMetadataEvent {
+            val content =
+                if (newChannelInfo != null) {
+                    gson.toJson(newChannelInfo)
+                } else {
+                    ""
+                }
+
+            val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
+            val tags = listOf(listOf("e", originalChannelIdHex, "", "root"))
+            val id = generateId(pubKey, createdAt, kind, tags, content)
+            val sig = Utils.sign(id, privateKey)
+            return ChannelMetadataEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
+        }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/ChannelMuteUserEvent.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/ChannelMuteUserEvent.kt
@@ -0,0 +1,35 @@
+package com.vitorpamplona.amethyst.service.model
+
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.toHexKey
+import nostr.postr.Utils
+import java.util.Date
+
+class ChannelMuteUserEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
+
+    fun usersToMute() = tags.filter { it.firstOrNull() == "p" }.mapNotNull { it.getOrNull(1) }
+
+    companion object {
+        const val kind = 44
+
+        fun create(reason: String, usersToMute: List<String>?, privateKey: ByteArray, createdAt: Long = Date().time / 1000): ChannelMuteUserEvent {
+            val content = reason
+            val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
+            val tags =
+                usersToMute?.map {
+                    listOf("p", it)
+                } ?: emptyList()
+
+            val id = generateId(pubKey, createdAt, kind, tags, content)
+            val sig = Utils.sign(id, privateKey)
+            return ChannelMuteUserEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
+        }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/ContactListEvent.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/ContactListEvent.kt
@@ -0,0 +1,98 @@
+package com.vitorpamplona.amethyst.service.model
+
+import android.util.Log
+import com.google.gson.reflect.TypeToken
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.decodePublicKey
+import com.vitorpamplona.amethyst.model.toHexKey
+import nostr.postr.Utils
+import java.util.Date
+
+data class Contact(val pubKeyHex: String, val relayUri: String?)
+
+class ContactListEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
+    // This function is only used by the user logged in
+    // But it is used all the time.
+    val verifiedFollowKeySet: Set<HexKey> by lazy {
+        tags.filter { it[0] == "p" }.mapNotNull {
+            it.getOrNull(1)?.let { unverifiedHex: String ->
+                try {
+                    decodePublicKey(unverifiedHex).toHexKey()
+                } catch (e: Exception) {
+                    Log.w("ContactListEvent", "Can't parse tags as a follows: ${it[1]}", e)
+                    null
+                }
+            }
+        }.toSet()
+    }
+
+    val verifiedFollowTagSet: Set<String> by lazy {
+        unverifiedFollowTagSet().map { it.lowercase() }.toSet()
+    }
+
+    val verifiedFollowKeySetAndMe: Set<HexKey> by lazy {
+        verifiedFollowKeySet + pubKey
+    }
+
+    fun unverifiedFollowKeySet() = tags.filter { it[0] == "p" }.mapNotNull { it.getOrNull(1) }
+    fun unverifiedFollowTagSet() = tags.filter { it[0] == "t" }.mapNotNull { it.getOrNull(1) }
+
+    fun follows() = tags.filter { it[0] == "p" }.mapNotNull {
+        try {
+            Contact(decodePublicKey(it[1]).toHexKey(), it.getOrNull(2))
+        } catch (e: Exception) {
+            Log.w("ContactListEvent", "Can't parse tags as a follows: ${it[1]}", e)
+            null
+        }
+    }
+
+    fun followsTags() = tags.filter { it[0] == "t" }.mapNotNull {
+        it.getOrNull(2)
+    }
+
+    fun relays(): Map<String, ReadWrite>? = try {
+        if (content.isNotEmpty()) {
+            gson.fromJson(content, object : TypeToken<Map<String, ReadWrite>>() {}.type) as Map<String, ReadWrite>
+        } else {
+            null
+        }
+    } catch (e: Exception) {
+        Log.w("ContactListEvent", "Can't parse content as relay lists: $content", e)
+        null
+    }
+
+    companion object {
+        const val kind = 3
+
+        fun create(follows: List<Contact>, followTags: List<String>, relayUse: Map<String, ReadWrite>?, privateKey: ByteArray, createdAt: Long = Date().time / 1000): ContactListEvent {
+            val content = if (relayUse != null) {
+                gson.toJson(relayUse)
+            } else {
+                ""
+            }
+            val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
+            val tags = follows.map {
+                if (it.relayUri != null) {
+                    listOf("p", it.pubKeyHex, it.relayUri)
+                } else {
+                    listOf("p", it.pubKeyHex)
+                }
+            } + followTags.map {
+                listOf("t", it)
+            }
+
+            val id = generateId(pubKey, createdAt, kind, tags, content)
+            val sig = Utils.sign(id, privateKey)
+            return ContactListEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
+        }
+    }
+
+    data class ReadWrite(val read: Boolean, val write: Boolean)
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/DeletionEvent.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/DeletionEvent.kt
@@ -0,0 +1,30 @@
+package com.vitorpamplona.amethyst.service.model
+
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.toHexKey
+import nostr.postr.Utils
+import java.util.Date
+
+class DeletionEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
+    fun deleteEvents() = tags.map { it[1] }
+
+    companion object {
+        const val kind = 5
+
+        fun create(deleteEvents: List<String>, privateKey: ByteArray, createdAt: Long = Date().time / 1000): DeletionEvent {
+            val content = ""
+            val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
+            val tags = deleteEvents.map { listOf("e", it) }
+            val id = generateId(pubKey, createdAt, kind, tags, content)
+            val sig = Utils.sign(id, privateKey)
+            return DeletionEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
+        }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/Event.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/Event.kt
@@ -0,0 +1,274 @@
+package com.vitorpamplona.amethyst.service.model
+
+import com.google.gson.*
+import com.google.gson.annotations.SerializedName
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.toHexKey
+import fr.acinq.secp256k1.Hex
+import fr.acinq.secp256k1.Secp256k1
+import nostr.postr.Utils
+import nostr.postr.toHex
+import java.lang.reflect.Type
+import java.math.BigDecimal
+import java.security.MessageDigest
+import java.util.*
+
+open class Event(
+    val id: HexKey,
+    @SerializedName("pubkey") val pubKey: HexKey,
+    @SerializedName("created_at") val createdAt: Long,
+    val kind: Int,
+    val tags: List<List<String>>,
+    val content: String,
+    val sig: HexKey
+) : EventInterface {
+    override fun id(): HexKey = id
+
+    override fun pubKey(): HexKey = pubKey
+
+    override fun createdAt(): Long = createdAt
+
+    override fun kind(): Int = kind
+
+    override fun tags(): List<List<String>> = tags
+
+    override fun content(): String = content
+
+    override fun sig(): HexKey = sig
+
+    override fun toJson(): String = gson.toJson(this)
+
+    fun taggedUsers() = tags.filter { it.size > 1 && it[0] == "p" }.map { it[1] }
+    fun taggedEvents() = tags.filter { it.size > 1 && it[0] == "e" }.map { it[1] }
+
+    override fun zapAddress() = tags.firstOrNull { it.size > 1 && it[0] == "zap" }?.get(1)
+
+    fun taggedAddresses() = tags.filter { it.size > 1 && it[0] == "a" }.mapNotNull {
+        val aTagValue = it[1]
+        val relay = it.getOrNull(2)
+
+        ATag.parse(aTagValue, relay)
+    }
+
+    override fun hashtags() = tags.filter { it.size > 1 && it[0] == "t" }.map { it[1] }
+
+    override fun isTaggedUser(idHex: String) = tags.any { it.size > 1 && it[0] == "p" && it[1] == idHex }
+
+    override fun isTaggedHash(hashtag: String) = tags.any { it.size > 1 && it[0] == "t" && it[1].equals(hashtag, true) }
+    override fun isTaggedHashes(hashtags: Set<String>) = tags.any { it.size > 1 && it[0] == "t" && it[1].lowercase() in hashtags }
+    override fun firstIsTaggedHashes(hashtags: Set<String>) = tags.firstOrNull { it.size > 1 && it[0] == "t" && it[1].lowercase() in hashtags }?.getOrNull(1)
+
+    override fun getPoWRank(): Int {
+        var rank = 0
+        for (i in 0..id.length) {
+            if (id[i] == '0') {
+                rank += 4
+            } else if (id[i] in '4'..'7') {
+                rank += 1
+                break
+            } else if (id[i] in '2'..'3') {
+                rank += 2
+                break
+            } else if (id[i] == '1') {
+                rank += 3
+                break
+            } else {
+                break
+            }
+        }
+        return rank
+    }
+
+    override fun getReward(): BigDecimal? {
+        return try {
+            tags.filter { it.firstOrNull() == "reward" }.mapNotNull { it.getOrNull(1)?.let { BigDecimal(it) } }.firstOrNull()
+        } catch (e: Exception) {
+            null
+        }
+    }
+
+    /**
+     * Checks if the ID is correct and then if the pubKey's secret key signed the event.
+     */
+    override fun checkSignature() {
+        if (!id.contentEquals(generateId())) {
+            throw Exception(
+                """|Unexpected ID.
+                   |  Event: ${toJson()}
+                   |  Actual ID: $id
+                   |  Generated: ${generateId()}
+                """.trimIndent()
+            )
+        }
+        if (!secp256k1.verifySchnorr(Hex.decode(sig), Hex.decode(id), Hex.decode(pubKey))) {
+            throw Exception("""Bad signature!""")
+        }
+    }
+
+    override fun hasValidSignature(): Boolean {
+        if (!id.contentEquals(generateId())) {
+            return false
+        }
+
+        return secp256k1.verifySchnorr(Hex.decode(sig), Hex.decode(id), Hex.decode(pubKey))
+    }
+
+    private fun generateId(): String {
+        val rawEvent = listOf(0, pubKey, createdAt, kind, tags, content)
+
+        // GSON decided to hardcode these replacements.
+        // They break Nostr's hash check.
+        // These lines revert their code.
+        // https://github.com/google/gson/issues/2295
+        val rawEventJson = gson.toJson(rawEvent)
+            .replace("\\u2028", "\u2028")
+            .replace("\\u2029", "\u2029")
+
+        return sha256.digest(rawEventJson.toByteArray()).toHexKey()
+    }
+
+    private class EventDeserializer : JsonDeserializer<Event> {
+        override fun deserialize(
+            json: JsonElement,
+            typeOfT: Type?,
+            context: JsonDeserializationContext?
+        ): Event {
+            val jsonObject = json.asJsonObject
+            return Event(
+                id = jsonObject.get("id").asString,
+                pubKey = jsonObject.get("pubkey").asString,
+                createdAt = jsonObject.get("created_at").asLong,
+                kind = jsonObject.get("kind").asInt,
+                tags = jsonObject.get("tags").asJsonArray.map {
+                    it.asJsonArray.mapNotNull { s -> if (s.isJsonNull) null else s.asString }
+                },
+                content = jsonObject.get("content").asString,
+                sig = jsonObject.get("sig").asString
+            )
+        }
+    }
+
+    private class EventSerializer : JsonSerializer<Event> {
+        override fun serialize(
+            src: Event,
+            typeOfSrc: Type?,
+            context: JsonSerializationContext?
+        ): JsonElement {
+            return JsonObject().apply {
+                addProperty("id", src.id)
+                addProperty("pubkey", src.pubKey)
+                addProperty("created_at", src.createdAt)
+                addProperty("kind", src.kind)
+                add(
+                    "tags",
+                    JsonArray().also { jsonTags ->
+                        src.tags.forEach { tag ->
+                            jsonTags.add(
+                                JsonArray().also { jsonTagElement ->
+                                    tag.forEach { tagElement ->
+                                        jsonTagElement.add(tagElement)
+                                    }
+                                }
+                            )
+                        }
+                    }
+                )
+                addProperty("content", src.content)
+                addProperty("sig", src.sig)
+            }
+        }
+    }
+
+    private class ByteArrayDeserializer : JsonDeserializer<ByteArray> {
+        override fun deserialize(
+            json: JsonElement,
+            typeOfT: Type?,
+            context: JsonDeserializationContext?
+        ): ByteArray = Hex.decode(json.asString)
+    }
+
+    private class ByteArraySerializer : JsonSerializer<ByteArray> {
+        override fun serialize(
+            src: ByteArray,
+            typeOfSrc: Type?,
+            context: JsonSerializationContext?
+        ) = JsonPrimitive(src.toHex())
+    }
+
+    companion object {
+        private val secp256k1 = Secp256k1.get()
+
+        val sha256: MessageDigest = MessageDigest.getInstance("SHA-256")
+        val gson: Gson = GsonBuilder()
+            .disableHtmlEscaping()
+            .registerTypeAdapter(Event::class.java, EventSerializer())
+            .registerTypeAdapter(Event::class.java, EventDeserializer())
+            .registerTypeAdapter(ByteArray::class.java, ByteArraySerializer())
+            .registerTypeAdapter(ByteArray::class.java, ByteArrayDeserializer())
+            .create()
+
+        fun fromJson(json: String, lenient: Boolean = false): Event = gson.fromJson(json, Event::class.java).getRefinedEvent(lenient)
+
+        fun fromJson(json: JsonElement, lenient: Boolean = false): Event = gson.fromJson(json, Event::class.java).getRefinedEvent(lenient)
+
+        fun Event.getRefinedEvent(lenient: Boolean = false): Event = when (kind) {
+            BadgeAwardEvent.kind -> BadgeAwardEvent(id, pubKey, createdAt, tags, content, sig)
+            BadgeDefinitionEvent.kind -> BadgeDefinitionEvent(id, pubKey, createdAt, tags, content, sig)
+            BadgeProfilesEvent.kind -> BadgeProfilesEvent(id, pubKey, createdAt, tags, content, sig)
+            BookmarkListEvent.kind -> BookmarkListEvent(id, pubKey, createdAt, tags, content, sig)
+            ChannelCreateEvent.kind -> ChannelCreateEvent(id, pubKey, createdAt, tags, content, sig)
+            ChannelHideMessageEvent.kind -> ChannelHideMessageEvent(id, pubKey, createdAt, tags, content, sig)
+            ChannelMessageEvent.kind -> ChannelMessageEvent(id, pubKey, createdAt, tags, content, sig)
+            ChannelMetadataEvent.kind -> ChannelMetadataEvent(id, pubKey, createdAt, tags, content, sig)
+            ChannelMuteUserEvent.kind -> ChannelMuteUserEvent(id, pubKey, createdAt, tags, content, sig)
+            ContactListEvent.kind -> ContactListEvent(id, pubKey, createdAt, tags, content, sig)
+            DeletionEvent.kind -> DeletionEvent(id, pubKey, createdAt, tags, content, sig)
+
+            FileHeaderEvent.kind -> FileHeaderEvent(id, pubKey, createdAt, tags, content, sig)
+            FileStorageEvent.kind -> FileStorageEvent(id, pubKey, createdAt, tags, content, sig)
+            FileStorageHeaderEvent.kind -> FileStorageHeaderEvent(id, pubKey, createdAt, tags, content, sig)
+            LnZapEvent.kind -> LnZapEvent(id, pubKey, createdAt, tags, content, sig)
+            LnZapPaymentRequestEvent.kind -> LnZapPaymentRequestEvent(id, pubKey, createdAt, tags, content, sig)
+            LnZapPaymentResponseEvent.kind -> LnZapPaymentResponseEvent(id, pubKey, createdAt, tags, content, sig)
+            LnZapRequestEvent.kind -> LnZapRequestEvent(id, pubKey, createdAt, tags, content, sig)
+            LongTextNoteEvent.kind -> LongTextNoteEvent(id, pubKey, createdAt, tags, content, sig)
+            MetadataEvent.kind -> MetadataEvent(id, pubKey, createdAt, tags, content, sig)
+            PollNoteEvent.kind -> PollNoteEvent(id, pubKey, createdAt, tags, content, sig)
+            PrivateDmEvent.kind -> PrivateDmEvent(id, pubKey, createdAt, tags, content, sig)
+            ReactionEvent.kind -> ReactionEvent(id, pubKey, createdAt, tags, content, sig)
+            RecommendRelayEvent.kind -> RecommendRelayEvent(id, pubKey, createdAt, tags, content, sig, lenient)
+            ReportEvent.kind -> ReportEvent(id, pubKey, createdAt, tags, content, sig)
+            RepostEvent.kind -> RepostEvent(id, pubKey, createdAt, tags, content, sig)
+            TextNoteEvent.kind -> TextNoteEvent(id, pubKey, createdAt, tags, content, sig)
+            else -> this
+        }
+
+        fun generateId(pubKey: HexKey, createdAt: Long, kind: Int, tags: List<List<String>>, content: String): ByteArray {
+            val rawEvent = listOf(
+                0,
+                pubKey,
+                createdAt,
+                kind,
+                tags,
+                content
+            )
+
+            // GSON decided to hardcode these replacements.
+            // They break Nostr's hash check.
+            // These lines revert their code.
+            // https://github.com/google/gson/issues/2295
+            val rawEventJson = gson.toJson(rawEvent)
+                .replace("\\u2028", "\u2028")
+                .replace("\\u2029", "\u2029")
+
+            return sha256.digest(rawEventJson.toByteArray())
+        }
+
+        fun create(privateKey: ByteArray, kind: Int, tags: List<List<String>> = emptyList(), content: String = "", createdAt: Long = Date().time / 1000): Event {
+            val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
+            val id = Companion.generateId(pubKey, createdAt, kind, tags, content)
+            val sig = Utils.sign(id, privateKey).toHexKey()
+            return Event(id.toHexKey(), pubKey, createdAt, kind, tags, content, sig)
+        }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/EventInterface.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/EventInterface.kt
@@ -0,0 +1,38 @@
+package com.vitorpamplona.amethyst.service.model
+
+import com.vitorpamplona.amethyst.model.HexKey
+import java.math.BigDecimal
+
+interface EventInterface {
+    fun id(): HexKey
+
+    fun pubKey(): HexKey
+
+    fun createdAt(): Long
+
+    fun kind(): Int
+
+    fun tags(): List<List<String>>
+
+    fun content(): String
+
+    fun sig(): HexKey
+
+    fun toJson(): String
+
+    fun checkSignature()
+
+    fun hasValidSignature(): Boolean
+
+    fun isTaggedUser(idHex: String): Boolean
+
+    fun isTaggedHash(hashtag: String): Boolean
+    fun isTaggedHashes(hashtags: Set<String>): Boolean
+    fun firstIsTaggedHashes(hashtags: Set<String>): String?
+    fun hashtags(): List<String>
+
+    fun getReward(): BigDecimal?
+    fun getPoWRank(): Int
+
+    fun zapAddress(): String?
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/FileHeaderEvent.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/FileHeaderEvent.kt
@@ -0,0 +1,71 @@
+package com.vitorpamplona.amethyst.service.model
+
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.toHexKey
+import nostr.postr.Utils
+import java.util.Date
+
+class FileHeaderEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
+
+    fun url() = tags.firstOrNull { it.size > 1 && it[0] == URL }?.get(1)
+    fun encryptionKey() = tags.firstOrNull { it.size > 2 && it[0] == ENCRYPTION_KEY }?.let { AESGCM(it[1], it[2]) }
+    fun mimeType() = tags.firstOrNull { it.size > 1 && it[0] == MIME_TYPE }?.get(1)
+    fun hash() = tags.firstOrNull { it.size > 1 && it[0] == HASH }?.get(1)
+    fun size() = tags.firstOrNull { it.size > 1 && it[0] == FILE_SIZE }?.get(1)
+    fun magnetURI() = tags.firstOrNull { it.size > 1 && it[0] == MAGNET_URI }?.get(1)
+    fun torrentInfoHash() = tags.firstOrNull { it.size > 1 && it[0] == TORRENT_INFOHASH }?.get(1)
+    fun blurhash() = tags.firstOrNull { it.size > 1 && it[0] == BLUR_HASH }?.get(1)
+
+    companion object {
+        const val kind = 1063
+
+        private const val URL = "url"
+        private const val ENCRYPTION_KEY = "aes-256-gcm"
+        private const val MIME_TYPE = "m"
+        private const val FILE_SIZE = "size"
+        private const val HASH = "x"
+        private const val MAGNET_URI = "magnet"
+        private const val TORRENT_INFOHASH = "i"
+        private const val BLUR_HASH = "blurhash"
+
+        fun create(
+            url: String,
+            mimeType: String? = null,
+            description: String? = null,
+            hash: String? = null,
+            size: String? = null,
+            blurhash: String? = null,
+            magnetURI: String? = null,
+            torrentInfoHash: String? = null,
+            encryptionKey: AESGCM? = null,
+            privateKey: ByteArray,
+            createdAt: Long = Date().time / 1000
+        ): FileHeaderEvent {
+            val tags = listOfNotNull(
+                listOf(URL, url),
+                mimeType?.let { listOf(MIME_TYPE, mimeType) },
+                hash?.let { listOf(HASH, it) },
+                size?.let { listOf(FILE_SIZE, it) },
+                blurhash?.let { listOf(BLUR_HASH, it) },
+                magnetURI?.let { listOf(MAGNET_URI, it) },
+                torrentInfoHash?.let { listOf(TORRENT_INFOHASH, it) },
+                encryptionKey?.let { listOf(ENCRYPTION_KEY, it.key, it.nonce) }
+            )
+
+            val content = description ?: ""
+            val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
+            val id = generateId(pubKey, createdAt, kind, tags, content)
+            val sig = Utils.sign(id, privateKey)
+            return FileHeaderEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
+        }
+    }
+}
+
+data class AESGCM(val key: String, val nonce: String)
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/FileStorageEvent.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/FileStorageEvent.kt
@@ -0,0 +1,58 @@
+package com.vitorpamplona.amethyst.service.model
+
+import android.util.Log
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.toHexKey
+import nostr.postr.Utils
+import java.util.Base64
+import java.util.Date
+
+class FileStorageEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
+
+    fun type() = tags.firstOrNull { it.size > 1 && it[0] == TYPE }?.get(1)
+    fun decryptKey() = tags.firstOrNull { it.size > 2 && it[0] == DECRYPT }?.let { AESGCM(it[1], it[2]) }
+
+    fun decode(): ByteArray? {
+        return try {
+            Base64.getDecoder().decode(content)
+        } catch (e: Exception) {
+            Log.e("FileStorageEvent", "Unable to decode base 64 ${e.message} $content")
+            null
+        }
+    }
+
+    companion object {
+        const val kind = 1064
+
+        private const val TYPE = "type"
+        private const val DECRYPT = "decrypt"
+
+        fun encode(bytes: ByteArray): String {
+            return Base64.getEncoder().encodeToString(bytes)
+        }
+
+        fun create(
+            mimeType: String,
+            data: ByteArray,
+            privateKey: ByteArray,
+            createdAt: Long = Date().time / 1000
+        ): FileStorageEvent {
+            val tags = listOfNotNull(
+                listOf(TYPE, mimeType)
+            )
+
+            val content = encode(data)
+            val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
+            val id = generateId(pubKey, createdAt, kind, tags, content)
+            val sig = Utils.sign(id, privateKey)
+            return FileStorageEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
+        }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/FileStorageHeaderEvent.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/FileStorageHeaderEvent.kt
@@ -0,0 +1,69 @@
+package com.vitorpamplona.amethyst.service.model
+
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.toHexKey
+import nostr.postr.Utils
+import java.util.Date
+
+class FileStorageHeaderEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
+
+    fun dataEventId() = tags.firstOrNull { it.size > 1 && it[0] == "e" }?.get(1)
+
+    fun encryptionKey() = tags.firstOrNull { it.size > 2 && it[0] == ENCRYPTION_KEY }?.let { AESGCM(it[1], it[2]) }
+    fun mimeType() = tags.firstOrNull { it.size > 1 && it[0] == MIME_TYPE }?.get(1)
+    fun hash() = tags.firstOrNull { it.size > 1 && it[0] == HASH }?.get(1)
+    fun size() = tags.firstOrNull { it.size > 1 && it[0] == FILE_SIZE }?.get(1)
+    fun magnetURI() = tags.firstOrNull { it.size > 1 && it[0] == MAGNET_URI }?.get(1)
+    fun torrentInfoHash() = tags.firstOrNull { it.size > 1 && it[0] == TORRENT_INFOHASH }?.get(1)
+    fun blurhash() = tags.firstOrNull { it.size > 1 && it[0] == BLUR_HASH }?.get(1)
+
+    companion object {
+        const val kind = 1065
+
+        private const val ENCRYPTION_KEY = "aes-256-gcm"
+        private const val MIME_TYPE = "m"
+        private const val FILE_SIZE = "size"
+        private const val HASH = "x"
+        private const val MAGNET_URI = "magnet"
+        private const val TORRENT_INFOHASH = "i"
+        private const val BLUR_HASH = "blurhash"
+
+        fun create(
+            storageEvent: FileStorageEvent,
+            mimeType: String? = null,
+            description: String? = null,
+            hash: String? = null,
+            size: String? = null,
+            blurhash: String? = null,
+            magnetURI: String? = null,
+            torrentInfoHash: String? = null,
+            encryptionKey: AESGCM? = null,
+            privateKey: ByteArray,
+            createdAt: Long = Date().time / 1000
+        ): FileStorageHeaderEvent {
+            val tags = listOfNotNull(
+                listOf("e", storageEvent.id),
+                mimeType?.let { listOf(MIME_TYPE, mimeType) },
+                hash?.let { listOf(HASH, it) },
+                size?.let { listOf(FILE_SIZE, it) },
+                blurhash?.let { listOf(BLUR_HASH, it) },
+                magnetURI?.let { listOf(MAGNET_URI, it) },
+                torrentInfoHash?.let { listOf(TORRENT_INFOHASH, it) },
+                encryptionKey?.let { listOf(ENCRYPTION_KEY, it.key, it.nonce) }
+            )
+
+            val content = description ?: ""
+            val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
+            val id = generateId(pubKey, createdAt, kind, tags, content)
+            val sig = Utils.sign(id, privateKey)
+            return FileStorageHeaderEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
+        }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/LnZapEvent.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/LnZapEvent.kt
@@ -0,0 +1,74 @@
+package com.vitorpamplona.amethyst.service.model
+
+import android.util.Log
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.service.lnurl.LnInvoiceUtil
+import com.vitorpamplona.amethyst.service.relays.Client
+
+class LnZapEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : LnZapEventInterface, Event(id, pubKey, createdAt, kind, tags, content, sig) {
+    // This event is also kept in LocalCache (same object)
+    @Transient val zapRequest: LnZapRequestEvent?
+
+    override fun containedPost(): LnZapRequestEvent? = try {
+        description()?.ifBlank { null }?.let {
+            fromJson(it, Client.lenient)
+        } as? LnZapRequestEvent
+    } catch (e: Exception) {
+        Log.e("LnZapEvent", "Failed to Parse Contained Post ${description()}", e)
+        null
+    }
+
+    init {
+        zapRequest = containedPost()
+    }
+
+    override fun zappedPost() = tags.filter { it.size > 1 && it[0] == "e" }.map { it[1] }
+
+    override fun zappedAuthor() = tags.filter { it.size > 1 && it[0] == "p" }.map { it[1] }
+
+    override fun zappedPollOption(): Int? = try {
+        zapRequest?.tags?.firstOrNull { it.size > 1 && it[0] == POLL_OPTION }?.get(1)?.toInt()
+    } catch (e: Exception) {
+        Log.e("LnZapEvent", "ZappedPollOption failed to parse", e)
+        null
+    }
+
+    override fun zappedRequestAuthor(): String? = zapRequest?.pubKey()
+
+    override fun amount() = amount
+
+    // Keeps this as a field because it's a heavier function used everywhere.
+    val amount by lazy {
+        try {
+            lnInvoice()?.let { LnInvoiceUtil.getAmountInSats(it) }
+        } catch (e: Exception) {
+            Log.e("LnZapEvent", "Failed to Parse LnInvoice ${description()}", e)
+            null
+        }
+    }
+    override fun content(): String {
+        return content
+    }
+
+    private fun lnInvoice() = tags.firstOrNull { it.size > 1 && it[0] == "bolt11" }?.get(1)
+
+    private fun description() = tags.firstOrNull { it.size > 1 && it[0] == "description" }?.get(1)
+
+    companion object {
+        const val kind = 9735
+    }
+
+    enum class ZapType() {
+        PUBLIC,
+        PRIVATE,
+        ANONYMOUS,
+        NONZAP
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/LnZapEventInterface.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/LnZapEventInterface.kt
@@ -0,0 +1,20 @@
+package com.vitorpamplona.amethyst.service.model
+
+import java.math.BigDecimal
+
+interface LnZapEventInterface : EventInterface {
+
+    fun zappedPost(): List<String>
+
+    fun zappedPollOption(): Int?
+
+    fun zappedAuthor(): List<String>
+
+    fun zappedRequestAuthor(): String?
+
+    fun taggedAddresses(): List<ATag>
+
+    fun amount(): BigDecimal?
+
+    fun containedPost(): Event?
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/LnZapPaymentRequestEvent.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/LnZapPaymentRequestEvent.kt
@@ -0,0 +1,69 @@
+package com.vitorpamplona.amethyst.service.model
+
+import android.util.Log
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.toByteArray
+import com.vitorpamplona.amethyst.model.toHexKey
+import nostr.postr.Utils
+import java.util.Date
+
+class LnZapPaymentRequestEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
+
+    fun walletServicePubKey() = tags.firstOrNull() { it.size > 1 && it[0] == "p" }?.get(1)
+
+    fun lnInvoice(privKey: ByteArray): String? {
+        return try {
+            val sharedSecret = Utils.getSharedSecret(privKey, pubKey.toByteArray())
+
+            return Utils.decrypt(content, sharedSecret)
+        } catch (e: Exception) {
+            Log.w("BookmarkList", "Error decrypting the message ${e.message}")
+            null
+        }
+    }
+
+    companion object {
+        const val kind = 23194
+
+        fun create(
+            lnInvoice: String,
+            walletServicePubkey: String,
+            privateKey: ByteArray,
+            createdAt: Long = Date().time / 1000
+        ): LnZapPaymentRequestEvent {
+            val pubKey = Utils.pubkeyCreate(privateKey)
+            val serializedRequest = gson.toJson(PayInvoiceMethod(lnInvoice))
+
+            val content = Utils.encrypt(
+                serializedRequest,
+                privateKey,
+                walletServicePubkey.toByteArray()
+            )
+
+            val tags = mutableListOf<List<String>>()
+            tags.add(listOf("p", walletServicePubkey))
+
+            val id = generateId(pubKey.toHexKey(), createdAt, kind, tags, content)
+            val sig = Utils.sign(id, privateKey)
+            return LnZapPaymentRequestEvent(id.toHexKey(), pubKey.toHexKey(), createdAt, tags, content, sig.toHexKey())
+        }
+    }
+}
+
+// REQUEST OBJECTS
+
+abstract class Request(val method: String, val params: Params)
+abstract class Params
+
+// PayInvoice Call
+
+class PayInvoiceMethod(bolt11: String) : Request("pay_invoice", PayInvoiceParams(bolt11)) {
+    class PayInvoiceParams(val invoice: String) : Params()
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/LnZapPaymentResponseEvent.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/LnZapPaymentResponseEvent.kt
@@ -0,0 +1,88 @@
+package com.vitorpamplona.amethyst.service.model
+
+import android.util.Log
+import com.google.gson.annotations.SerializedName
+import com.vitorpamplona.amethyst.model.HexKey
+import nostr.postr.Utils
+
+class LnZapPaymentResponseEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
+
+    fun requestAuthor() = tags.firstOrNull() { it.size > 1 && it[0] == "p" }?.get(1)
+    fun requestId() = tags.firstOrNull() { it.size > 1 && it[0] == "e" }?.get(1)
+
+    fun decrypt(privKey: ByteArray, pubKey: ByteArray): String? {
+        return try {
+            val sharedSecret = Utils.getSharedSecret(privKey, pubKey)
+
+            val retVal = Utils.decrypt(content, sharedSecret)
+
+            if (retVal.startsWith(PrivateDmEvent.nip18Advertisement)) {
+                retVal.substring(16)
+            } else {
+                retVal
+            }
+        } catch (e: Exception) {
+            Log.w("PrivateDM", "Error decrypting the message ${e.message}")
+            null
+        }
+    }
+
+    fun response(privKey: ByteArray, pubKey: ByteArray): Response? = try {
+        if (content.isNotEmpty()) {
+            gson.fromJson(decrypt(privKey, pubKey), Response::class.java)
+        } else {
+            null
+        }
+    } catch (e: Exception) {
+        Log.w("LnZapPaymentResponseEvent", "Can't parse content as a payment response: $content", e)
+        null
+    }
+
+    companion object {
+        const val kind = 23195
+    }
+}
+
+// RESPONSE OBJECTS
+abstract class Response(
+    @SerializedName("result_type")
+    val resultType: String
+)
+
+// PayInvoice Call
+
+class PayInvoiceSuccessResponse(val result: PayInvoiceResultParams) :
+    Response("pay_invoice") {
+    class PayInvoiceResultParams(val preimage: String)
+}
+
+class PayInvoiceErrorResponse(val error: PayInvoiceErrorParams? = null) :
+    Response("pay_invoice") {
+    class PayInvoiceErrorParams(val code: ErrorType?, val message: String?)
+
+    enum class ErrorType {
+        @SerializedName(value = "rate_limited", alternate = ["RATE_LIMITED"])
+        RATE_LIMITED, // The client is sending commands too fast. It should retry in a few seconds.
+        @SerializedName(value = "not_implemented", alternate = ["NOT_IMPLEMENTED"])
+        NOT_IMPLEMENTED, // The command is not known or is intentionally not implemented.
+        @SerializedName(value = "insufficient_balance", alternate = ["INSUFFICIENT_BALANCE"])
+        INSUFFICIENT_BALANCE, // The wallet does not have enough funds to cover a fee reserve or the payment amount.
+        @SerializedName(value = "quota_exceeded", alternate = ["QUOTA_EXCEEDED"])
+        QUOTA_EXCEEDED, // The wallet has exceeded its spending quota.
+        @SerializedName(value = "restricted", alternate = ["RESTRICTED"])
+        RESTRICTED, // This public key is not allowed to do this operation.
+        @SerializedName(value = "unauthorized", alternate = ["UNAUTHORIZED"])
+        UNAUTHORIZED, // This public key has no wallet connected.
+        @SerializedName(value = "internal", alternate = ["INTERNAL"])
+        INTERNAL, // An internal error.
+        @SerializedName(value = "other", alternate = ["OTHER"])
+        OTHER // Other error.
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/LnZapRequestEvent.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/LnZapRequestEvent.kt
@@ -0,0 +1,210 @@
+package com.vitorpamplona.amethyst.service.model
+
+import com.vitorpamplona.amethyst.model.*
+import nostr.postr.Bech32
+import nostr.postr.Utils
+import java.nio.charset.Charset
+import java.security.SecureRandom
+import java.util.*
+import javax.crypto.BadPaddingException
+import javax.crypto.Cipher
+import javax.crypto.spec.IvParameterSpec
+import javax.crypto.spec.SecretKeySpec
+
+class LnZapRequestEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
+
+    fun zappedPost() = tags.filter { it.size > 1 && it[0] == "e" }.map { it[1] }
+
+    fun zappedAuthor() = tags.filter { it.size > 1 && it[0] == "p" }.map { it[1] }
+
+    fun isPrivateZap() = tags.any { t -> t.size >= 2 && t[0] == "anon" && t[1].isNotBlank() }
+
+    companion object {
+        const val kind = 9734
+
+        fun create(
+            originalNote: EventInterface,
+            relays: Set<String>,
+            privateKey: ByteArray,
+            pollOption: Int?,
+            message: String,
+            zapType: LnZapEvent.ZapType,
+            createdAt: Long = Date().time / 1000
+        ): LnZapRequestEvent {
+            var content = message
+            var privkey = privateKey
+            var pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
+            var tags = listOf(
+                listOf("e", originalNote.id()),
+                listOf("p", originalNote.pubKey()),
+                listOf("relays") + relays
+            )
+            if (originalNote is LongTextNoteEvent) {
+                tags = tags + listOf(listOf("a", originalNote.address().toTag()))
+            }
+            if (pollOption != null && pollOption >= 0) {
+                tags = tags + listOf(listOf(POLL_OPTION, pollOption.toString()))
+            }
+            if (zapType == LnZapEvent.ZapType.ANONYMOUS) {
+                tags = tags + listOf(listOf("anon", ""))
+                privkey = Utils.privkeyCreate()
+                pubKey = Utils.pubkeyCreate(privkey).toHexKey()
+            } else if (zapType == LnZapEvent.ZapType.PRIVATE) {
+                var encryptionPrivateKey = createEncryptionPrivateKey(privateKey.toHexKey(), originalNote.id(), createdAt)
+                var noteJson = (create(privkey, 9733, listOf(tags[0], tags[1]), message)).toJson()
+                var encryptedContent = encryptPrivateZapMessage(noteJson, encryptionPrivateKey, originalNote.pubKey().toByteArray())
+                tags = tags + listOf(listOf("anon", encryptedContent))
+                content = "" // make sure public content is empty, as the content is encrypted
+                privkey = encryptionPrivateKey // sign event with generated privkey
+                pubKey = Utils.pubkeyCreate(encryptionPrivateKey).toHexKey() // updated event with according pubkey
+            }
+            val id = generateId(pubKey, createdAt, kind, tags, content)
+            val sig = Utils.sign(id, privkey)
+            return LnZapRequestEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
+        }
+
+        fun create(
+            userHex: String,
+            relays: Set<String>,
+            privateKey: ByteArray,
+            message: String,
+            zapType: LnZapEvent.ZapType,
+            createdAt: Long = Date().time / 1000
+        ): LnZapRequestEvent {
+            var content = message
+            var privkey = privateKey
+            var pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
+            var tags = listOf(
+                listOf("p", userHex),
+                listOf("relays") + relays
+            )
+            if (zapType == LnZapEvent.ZapType.ANONYMOUS) {
+                privkey = Utils.privkeyCreate()
+                pubKey = Utils.pubkeyCreate(privkey).toHexKey()
+                tags = tags + listOf(listOf("anon", ""))
+            } else if (zapType == LnZapEvent.ZapType.PRIVATE) {
+                var encryptionPrivateKey = createEncryptionPrivateKey(privateKey.toHexKey(), userHex, createdAt)
+                var noteJson = (create(privkey, 9733, listOf(tags[0], tags[1]), message)).toJson()
+                var encryptedContent = encryptPrivateZapMessage(noteJson, encryptionPrivateKey, userHex.toByteArray())
+                tags = tags + listOf(listOf("anon", encryptedContent))
+                content = ""
+                privkey = encryptionPrivateKey
+                pubKey = Utils.pubkeyCreate(encryptionPrivateKey).toHexKey()
+            }
+            val id = generateId(pubKey, createdAt, kind, tags, content)
+            val sig = Utils.sign(id, privkey)
+            return LnZapRequestEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
+        }
+
+        fun createEncryptionPrivateKey(privkey: String, id: String, createdAt: Long): ByteArray {
+            var str = privkey + id + createdAt.toString()
+            var strbyte = str.toByteArray(Charset.forName("utf-8"))
+            return sha256.digest(strbyte)
+        }
+
+        fun encryptPrivateZapMessage(msg: String, privkey: ByteArray, pubkey: ByteArray): String {
+            var sharedSecret = Utils.getSharedSecret(privkey, pubkey)
+            val iv = ByteArray(16)
+            SecureRandom().nextBytes(iv)
+
+            val keySpec = SecretKeySpec(sharedSecret, "AES")
+            val ivSpec = IvParameterSpec(iv)
+
+            var utf8message = msg.toByteArray(Charset.forName("utf-8"))
+            val cipher = Cipher.getInstance("AES/CBC/PKCS5Padding")
+            cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivSpec)
+            val encryptedMsg = cipher.doFinal(utf8message)
+
+            val encryptedMsgBech32 = Bech32.encode("pzap", Bech32.eight2five(encryptedMsg), Bech32.Encoding.Bech32)
+            val ivBech32 = Bech32.encode("iv", Bech32.eight2five(iv), Bech32.Encoding.Bech32)
+
+            return encryptedMsgBech32 + "_" + ivBech32
+        }
+
+        fun decryptPrivateZapMessage(msg: String, privkey: ByteArray, pubkey: ByteArray): String {
+            var sharedSecret = Utils.getSharedSecret(privkey, pubkey)
+            if (sharedSecret.size != 16 && sharedSecret.size != 32) {
+                throw IllegalArgumentException("Invalid shared secret size")
+            }
+            val parts = msg.split("_")
+            if (parts.size != 2) {
+                throw IllegalArgumentException("Invalid message format")
+            }
+            val iv = parts[1].run { Bech32.decode(this).second }
+            val encryptedMsg = parts.first().run { Bech32.decode(this).second }
+            val encryptedBytes = Bech32.five2eight(encryptedMsg, 0)
+            val cipher = Cipher.getInstance("AES/CBC/PKCS5Padding")
+            cipher.init(Cipher.DECRYPT_MODE, SecretKeySpec(sharedSecret, "AES"), IvParameterSpec(Bech32.five2eight(iv, 0)))
+
+            try {
+                val decryptedMsgBytes = cipher.doFinal(encryptedBytes)
+                return String(decryptedMsgBytes)
+            } catch (ex: BadPaddingException) {
+                throw IllegalArgumentException("Bad padding: ${ex.message}")
+            }
+        }
+
+        fun checkForPrivateZap(zapRequest: LnZapRequestEvent, loggedInUserPrivKey: ByteArray, pubKey: HexKey): Event? {
+            val anonTag = zapRequest.tags.firstOrNull { t -> t.size >= 2 && t[0] == "anon" }
+            if (anonTag != null) {
+                val encnote = anonTag[1]
+                if (encnote.isNotBlank()) {
+                    try {
+                        val note = decryptPrivateZapMessage(encnote, loggedInUserPrivKey, pubKey.toByteArray())
+                        val decryptedEvent = fromJson(note)
+                        if (decryptedEvent.kind == 9733) {
+                            return decryptedEvent
+                        }
+                    } catch (e: Exception) {
+                        e.printStackTrace()
+                    }
+                }
+            }
+            return null
+        }
+    }
+}
+/*
+{
+  "pubkey": "32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245",
+  "content": "",
+  "id": "d9cc14d50fcb8c27539aacf776882942c1a11ea4472f8cdec1dea82fab66279d",
+  "created_at": 1674164539,
+  "sig": "77127f636577e9029276be060332ea565deaf89ff215a494ccff16ae3f757065e2bc59b2e8c113dd407917a010b3abd36c8d7ad84c0e3ab7dab3a0b0caa9835d",
+  "kind": 9734,
+  "tags": [
+  [
+    "e",
+    "3624762a1274dd9636e0c552b53086d70bc88c165bc4dc0f9e836a1eaf86c3b8"
+  ],
+  [
+    "p",
+    "32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245"
+  ],
+  [
+    "relays",
+    "wss://relay.damus.io",
+    "wss://nostr-relay.wlvs.space",
+    "wss://nostr.fmt.wiz.biz",
+    "wss://relay.nostr.bg",
+    "wss://nostr.oxtr.dev",
+    "wss://nostr.v0l.io",
+    "wss://brb.io",
+    "wss://nostr.bitcoiner.social",
+    "ws://monad.jb55.com:8080",
+    "wss://relay.snort.social"
+  ],
+  [
+    "poll_option", "n"
+  ]
+  ],
+  "ots": <base64-encoded OTS file data> // TODO
+}
+*/
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/LongTextNoteEvent.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/LongTextNoteEvent.kt
@@ -0,0 +1,47 @@
+package com.vitorpamplona.amethyst.service.model
+
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.toHexKey
+import nostr.postr.Utils
+import java.util.Date
+
+class LongTextNoteEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : BaseTextNoteEvent(id, pubKey, createdAt, kind, tags, content, sig) {
+    fun dTag() = tags.filter { it.firstOrNull() == "d" }.mapNotNull { it.getOrNull(1) }.firstOrNull() ?: ""
+    fun address() = ATag(kind, pubKey, dTag(), null)
+
+    fun topics() = tags.filter { it.firstOrNull() == "t" }.mapNotNull { it.getOrNull(1) }
+    fun title() = tags.filter { it.firstOrNull() == "title" }.mapNotNull { it.getOrNull(1) }.firstOrNull()
+    fun image() = tags.filter { it.firstOrNull() == "image" }.mapNotNull { it.getOrNull(1) }.firstOrNull()
+    fun summary() = tags.filter { it.firstOrNull() == "summary" }.mapNotNull { it.getOrNull(1) }.firstOrNull()
+
+    fun publishedAt() = try {
+        tags.filter { it.firstOrNull() == "published_at" }.mapNotNull { it.getOrNull(1) }.firstOrNull()?.toLong()
+    } catch (_: Exception) {
+        null
+    }
+
+    companion object {
+        const val kind = 30023
+
+        fun create(msg: String, replyTos: List<String>?, mentions: List<String>?, privateKey: ByteArray, createdAt: Long = Date().time / 1000): LongTextNoteEvent {
+            val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
+            val tags = mutableListOf<List<String>>()
+            replyTos?.forEach {
+                tags.add(listOf("e", it))
+            }
+            mentions?.forEach {
+                tags.add(listOf("p", it))
+            }
+            val id = generateId(pubKey, createdAt, kind, tags, msg)
+            val sig = Utils.sign(id, privateKey)
+            return LongTextNoteEvent(id.toHexKey(), pubKey, createdAt, tags, msg, sig.toHexKey())
+        }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/MetadataEvent.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/MetadataEvent.kt
@@ -0,0 +1,182 @@
+package com.vitorpamplona.amethyst.service.model
+
+import android.util.Log
+import com.google.gson.Gson
+import com.vitorpamplona.amethyst.R
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.toHexKey
+import nostr.postr.Utils
+import java.util.Date
+
+data class ContactMetaData(
+    val name: String,
+    val picture: String,
+    val about: String,
+    val nip05: String?
+)
+
+abstract class IdentityClaim(
+    var identity: String,
+    var proof: String
+) {
+    abstract fun toProofUrl(): String
+    abstract fun toIcon(): Int
+    abstract fun toDescriptor(): Int
+    abstract fun platform(): String
+
+    fun platformIdentity() = "${platform()}:$identity"
+
+    companion object {
+        fun create(platformIdentity: String, proof: String): IdentityClaim? {
+            val (platform, identity) = platformIdentity.split(':')
+
+            return when (platform.lowercase()) {
+                GitHubIdentity.platform -> GitHubIdentity(identity, proof)
+                TwitterIdentity.platform -> TwitterIdentity(identity, proof)
+                TelegramIdentity.platform -> TelegramIdentity(identity, proof)
+                MastodonIdentity.platform -> MastodonIdentity(identity, proof)
+                else -> throw IllegalArgumentException("Platform $platform not supported")
+            }
+        }
+    }
+}
+
+class GitHubIdentity(
+    identity: String,
+    proof: String
+) : IdentityClaim(identity, proof) {
+    override fun toProofUrl() = "https://gist.github.com/$identity/$proof"
+
+    override fun platform() = platform
+    override fun toIcon() = R.drawable.github
+    override fun toDescriptor() = R.string.github
+
+    companion object {
+        val platform = "github"
+
+        fun parseProofUrl(proofUrl: String): GitHubIdentity? {
+            return try {
+                if (proofUrl.isBlank()) return null
+                val path = proofUrl.removePrefix("https://gist.github.com/").split("?")[0].split("/")
+
+                GitHubIdentity(path[0], path[1])
+            } catch (e: Exception) {
+                null
+            }
+        }
+    }
+}
+
+class TwitterIdentity(
+    identity: String,
+    proof: String
+) : IdentityClaim(identity, proof) {
+    override fun toProofUrl() = "https://twitter.com/$identity/status/$proof"
+
+    override fun platform() = platform
+    override fun toIcon() = R.drawable.twitter
+    override fun toDescriptor() = R.string.twitter
+
+    companion object {
+        val platform = "twitter"
+
+        fun parseProofUrl(proofUrl: String): TwitterIdentity? {
+            return try {
+                if (proofUrl.isBlank()) return null
+                val path = proofUrl.removePrefix("https://twitter.com/").split("?")[0].split("/")
+
+                TwitterIdentity(path[0], path[2])
+            } catch (e: Exception) {
+                null
+            }
+        }
+    }
+}
+
+class TelegramIdentity(
+    identity: String,
+    proof: String
+) : IdentityClaim(identity, proof) {
+    override fun toProofUrl() = "https://t.me/$proof"
+
+    override fun platform() = platform
+    override fun toIcon() = R.drawable.telegram
+    override fun toDescriptor() = R.string.telegram
+
+    companion object {
+        val platform = "telegram"
+    }
+}
+
+class MastodonIdentity(
+    identity: String,
+    proof: String
+) : IdentityClaim(identity, proof) {
+    override fun toProofUrl() = "https://$identity/$proof"
+
+    override fun platform() = platform
+    override fun toIcon() = R.drawable.mastodon
+    override fun toDescriptor() = R.string.mastodon
+
+    companion object {
+        val platform = "mastodon"
+
+        fun parseProofUrl(proofUrl: String): MastodonIdentity? {
+            return try {
+                if (proofUrl.isBlank()) return null
+                val path = proofUrl.removePrefix("https://").split("?")[0].split("/")
+
+                return MastodonIdentity("${path[0]}/${path[1]}", path[2])
+            } catch (e: Exception) {
+                null
+            }
+        }
+    }
+}
+
+class MetadataEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
+    fun contactMetaData() = try {
+        gson.fromJson(content, ContactMetaData::class.java)
+    } catch (e: Exception) {
+        Log.e("MetadataEvent", "Can't parse $content", e)
+        null
+    }
+
+    fun identityClaims() = tags.filter { it.firstOrNull() == "i" }.mapNotNull {
+        try {
+            IdentityClaim.create(it.get(1), it.get(2))
+        } catch (e: Exception) {
+            Log.e("MetadataEvent", "Can't parse identity [${it.joinToString { "," }}]", e)
+            null
+        }
+    }
+
+    companion object {
+        const val kind = 0
+        val gson = Gson()
+
+        fun create(contactMetaData: ContactMetaData, identities: List<IdentityClaim>, privateKey: ByteArray, createdAt: Long = Date().time / 1000): MetadataEvent {
+            return create(gson.toJson(contactMetaData), identities, privateKey, createdAt = createdAt)
+        }
+
+        fun create(contactMetaData: String, identities: List<IdentityClaim>, privateKey: ByteArray, createdAt: Long = Date().time / 1000): MetadataEvent {
+            val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
+            val tags = mutableListOf<List<String>>()
+
+            identities.forEach {
+                tags.add(listOf("i", it.platformIdentity(), it.proof))
+            }
+
+            val id = generateId(pubKey, createdAt, kind, tags, contactMetaData)
+            val sig = Utils.sign(id, privateKey)
+            return MetadataEvent(id.toHexKey(), pubKey, createdAt, tags, contactMetaData, sig.toHexKey())
+        }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/MuteListEvent.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/MuteListEvent.kt
@@ -0,0 +1,110 @@
+package com.vitorpamplona.amethyst.service.model
+
+import android.util.Log
+import com.google.gson.reflect.TypeToken
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.toByteArray
+import com.vitorpamplona.amethyst.model.toHexKey
+import nostr.postr.Utils
+import java.util.Date
+
+class MuteListEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
+    fun dTag() = tags.filter { it.firstOrNull() == "d" }.mapNotNull { it.getOrNull(1) }.firstOrNull() ?: ""
+    fun address() = ATag(kind, pubKey, dTag(), null)
+
+    fun plainContent(privKey: ByteArray): String? {
+        return try {
+            val sharedSecret = Utils.getSharedSecret(privKey, pubKey.toByteArray())
+
+            return Utils.decrypt(content, sharedSecret)
+        } catch (e: Exception) {
+            Log.w("BookmarkList", "Error decrypting the message ${e.message}")
+            null
+        }
+    }
+
+    @Transient
+    private var privateTagsCache: List<List<String>>? = null
+
+    fun privateTags(privKey: ByteArray): List<List<String>>? {
+        if (privateTagsCache != null) {
+            return privateTagsCache
+        }
+
+        privateTagsCache = try {
+            gson.fromJson(plainContent(privKey), object : TypeToken<List<List<String>>>() {}.type)
+        } catch (e: Throwable) {
+            Log.w("BookmarkList", "Error parsing the JSON ${e.message}")
+            null
+        }
+        return privateTagsCache
+    }
+
+    fun privateTaggedUsers(privKey: ByteArray) = privateTags(privKey)?.filter { it.firstOrNull() == "p" }?.mapNotNull { it.getOrNull(1) }
+    fun privateTaggedEvents(privKey: ByteArray) = privateTags(privKey)?.filter { it.firstOrNull() == "e" }?.mapNotNull { it.getOrNull(1) }
+    fun privateTaggedAddresses(privKey: ByteArray) = privateTags(privKey)?.filter { it.firstOrNull() == "a" }?.mapNotNull {
+        val aTagValue = it.getOrNull(1)
+        val relay = it.getOrNull(2)
+
+        if (aTagValue != null) ATag.parse(aTagValue, relay) else null
+    }
+
+    companion object {
+        const val kind = 10000
+
+        fun create(
+            events: List<String>? = null,
+            users: List<String>? = null,
+            addresses: List<ATag>? = null,
+
+            privEvents: List<String>? = null,
+            privUsers: List<String>? = null,
+            privAddresses: List<ATag>? = null,
+
+            privateKey: ByteArray,
+            createdAt: Long = Date().time / 1000
+        ): MuteListEvent {
+            val pubKey = Utils.pubkeyCreate(privateKey)
+
+            val privTags = mutableListOf<List<String>>()
+            privEvents?.forEach {
+                privTags.add(listOf("e", it))
+            }
+            privUsers?.forEach {
+                privTags.add(listOf("p", it))
+            }
+            privAddresses?.forEach {
+                privTags.add(listOf("a", it.toTag()))
+            }
+            val msg = gson.toJson(privTags)
+
+            val content = Utils.encrypt(
+                msg,
+                privateKey,
+                pubKey
+            )
+
+            val tags = mutableListOf<List<String>>()
+            events?.forEach {
+                tags.add(listOf("e", it))
+            }
+            users?.forEach {
+                tags.add(listOf("p", it))
+            }
+            addresses?.forEach {
+                tags.add(listOf("a", it.toTag()))
+            }
+
+            val id = generateId(pubKey.toHexKey(), createdAt, kind, tags, content)
+            val sig = Utils.sign(id, privateKey)
+            return MuteListEvent(id.toHexKey(), pubKey.toHexKey(), createdAt, tags, content, sig.toHexKey())
+        }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/PollNoteEvent.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/PollNoteEvent.kt
@@ -0,0 +1,105 @@
+package com.vitorpamplona.amethyst.service.model
+
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.toHexKey
+import nostr.postr.Utils
+import java.util.Date
+
+const val POLL_OPTION = "poll_option"
+const val VALUE_MAXIMUM = "value_maximum"
+const val VALUE_MINIMUM = "value_minimum"
+const val CONSENSUS_THRESHOLD = "consensus_threshold"
+const val CLOSED_AT = "closed_at"
+
+class PollNoteEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    // ots: String?, TODO implement OTS: https://github.com/opentimestamps/java-opentimestamps
+    content: String,
+    sig: HexKey
+) : BaseTextNoteEvent(id, pubKey, createdAt, kind, tags, content, sig) {
+    fun pollOptions() =
+        tags.filter { it.size > 2 && it[0] == POLL_OPTION }
+            .associate { it[1].toInt() to it[2] }
+
+    fun getTagInt(property: String): Int? {
+        val number = tags.firstOrNull() { it.size > 1 && it[0] == property }?.get(1)
+
+        return if (number.isNullOrBlank() || number == "null") {
+            null
+        } else {
+            number.toInt()
+        }
+    }
+
+    companion object {
+        const val kind = 6969
+
+        fun create(
+            msg: String,
+            replyTos: List<String>?,
+            mentions: List<String>?,
+            addresses: List<ATag>?,
+            privateKey: ByteArray,
+            createdAt: Long = Date().time / 1000,
+            pollOptions: Map<Int, String>,
+            valueMaximum: Int?,
+            valueMinimum: Int?,
+            consensusThreshold: Int?,
+            closedAt: Int?,
+            zapReceiver: String?
+        ): PollNoteEvent {
+            val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
+            val tags = mutableListOf<List<String>>()
+            replyTos?.forEach {
+                tags.add(listOf("e", it))
+            }
+            mentions?.forEach {
+                tags.add(listOf("p", it))
+            }
+            addresses?.forEach {
+                tags.add(listOf("a", it.toTag()))
+            }
+            pollOptions.forEach { poll_op ->
+                tags.add(listOf(POLL_OPTION, poll_op.key.toString(), poll_op.value))
+            }
+            tags.add(listOf(VALUE_MAXIMUM, valueMaximum.toString()))
+            tags.add(listOf(VALUE_MINIMUM, valueMinimum.toString()))
+            tags.add(listOf(CONSENSUS_THRESHOLD, consensusThreshold.toString()))
+            tags.add(listOf(CLOSED_AT, closedAt.toString()))
+
+            if (zapReceiver != null) {
+                tags.add(listOf("zap", zapReceiver))
+            }
+
+            val id = generateId(pubKey, createdAt, kind, tags, msg)
+            val sig = Utils.sign(id, privateKey)
+            return PollNoteEvent(id.toHexKey(), pubKey, createdAt, tags, msg, sig.toHexKey())
+        }
+    }
+}
+
+/*
+{
+  "id": <32-bytes lowercase hex-encoded sha256 of the serialized event data>
+  "pubkey": <32-bytes lowercase hex-encoded public key of the event creator>,
+  "created_at": <unix timestamp in seconds>,
+  "kind": 6969,
+  "tags": [
+    ["e", <32-bytes hex of the id of the poll event>, <primary poll host relay URL>],
+    ["p", <32-bytes hex of the key>, <primary poll host relay URL>],
+    ["poll_option", "0", "poll option 0 description string"],
+    ["poll_option", "1", "poll option 1 description string"],
+    ["poll_option", "n", "poll option <n> description string"],
+    ["value_maximum", "maximum satoshi value for inclusion in tally"],
+    ["value_minimum", "minimum satoshi value for inclusion in tally"],
+    ["consensus_threshold", "required percentage to attain consensus <0..100>"],
+    ["closed_at", "unix timestamp in seconds"],
+  ],
+  "ots": <base64-encoded OTS file data>
+  "content": <primary poll description string>,
+  "sig": <64-bytes hex of the signature of the sha256 hash of the serialized event data, which is the same as the "id" field>
+}
+ */
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/PrivateDmEvent.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/PrivateDmEvent.kt
@@ -0,0 +1,91 @@
+package com.vitorpamplona.amethyst.service.model
+
+import android.util.Log
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.toHexKey
+import fr.acinq.secp256k1.Hex
+import nostr.postr.Utils
+import nostr.postr.toHex
+import java.util.Date
+
+class PrivateDmEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
+    /**
+     * This may or may not be the actual recipient's pub key. The event is intended to look like a
+     * nip-04 EncryptedDmEvent but may omit the recipient, too. This value can be queried and used
+     * for initial messages.
+     */
+    fun recipientPubKey() = tags.firstOrNull { it.size > 1 && it[0] == "p" }?.run { Hex.decode(this[1]).toHexKey() } // makes sure its a valid one
+
+    /**
+     * To be fully compatible with nip-04, we read e-tags that are in violation to nip-18.
+     *
+     * Nip-18 messages should refer to other events by inline references in the content like
+     * `[](e/c06f795e1234a9a1aecc731d768d4f3ca73e80031734767067c82d67ce82e506).
+     */
+    fun replyTo() = tags.firstOrNull { it.size > 1 && it[0] == "e" }?.get(1)
+
+    fun plainContent(privKey: ByteArray, pubKey: ByteArray): String? {
+        return try {
+            val sharedSecret = Utils.getSharedSecret(privKey, pubKey)
+
+            val retVal = Utils.decrypt(content, sharedSecret)
+
+            if (retVal.startsWith(nip18Advertisement)) {
+                retVal.substring(16)
+            } else {
+                retVal
+            }
+        } catch (e: Exception) {
+            Log.w("PrivateDM", "Error decrypting the message ${e.message}")
+            null
+        }
+    }
+
+    companion object {
+        const val kind = 4
+
+        const val nip18Advertisement = "[//]: # (nip18)\n"
+
+        fun create(
+            recipientPubKey: ByteArray,
+            msg: String,
+            replyTos: List<String>? = null,
+            mentions: List<String>? = null,
+            zapReceiver: String?,
+            privateKey: ByteArray,
+            createdAt: Long = Date().time / 1000,
+            publishedRecipientPubKey: ByteArray? = null,
+            advertiseNip18: Boolean = true
+        ): PrivateDmEvent {
+            val content = Utils.encrypt(
+                if (advertiseNip18) { nip18Advertisement } else { "" } + msg,
+                privateKey,
+                recipientPubKey
+            )
+            val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
+            val tags = mutableListOf<List<String>>()
+            publishedRecipientPubKey?.let {
+                tags.add(listOf("p", publishedRecipientPubKey.toHex()))
+            }
+            replyTos?.forEach {
+                tags.add(listOf("e", it))
+            }
+            mentions?.forEach {
+                tags.add(listOf("p", it))
+            }
+            zapReceiver?.let {
+                tags.add(listOf("zap", it))
+            }
+            val id = generateId(pubKey, createdAt, kind, tags, content)
+            val sig = Utils.sign(id, privateKey)
+            return PrivateDmEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
+        }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/ReactionEvent.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/ReactionEvent.kt
@@ -1,37 +1,44 @@
 package com.vitorpamplona.amethyst.service.model

-import java.util.Date
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.toHexKey
 import nostr.postr.Utils
-import nostr.postr.events.Event
-import nostr.postr.toHex
+import java.util.Date

-class ReactionEvent (
-  id: ByteArray,
-  pubKey: ByteArray,
-  createdAt: Long,
-  tags: List<List<String>>,
-  content: String,
-  sig: ByteArray
-): Event(id, pubKey, createdAt, kind, tags, content, sig) {
+class ReactionEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig) {

-  @Transient val originalPost: List<String>
-  @Transient val originalAuthor: List<String>
+    fun originalPost() = tags.filter { it.size > 1 && it[0] == "e" }.map { it[1] }
+    fun originalAuthor() = tags.filter { it.size > 1 && it[0] == "p" }.map { it[1] }

-  init {
-    originalPost = tags.filter { it.firstOrNull() == "e" }.mapNotNull { it.getOrNull(1) }
-    originalAuthor = tags.filter { it.firstOrNull() == "p" }.mapNotNull { it.getOrNull(1) }
-  }
+    companion object {
+        const val kind = 7

-  companion object {
-    const val kind = 7
+        fun createWarning(originalNote: EventInterface, privateKey: ByteArray, createdAt: Long = Date().time / 1000): ReactionEvent {
+            return create("\u26A0\uFE0F", originalNote, privateKey, createdAt)
+        }

-    fun create(originalNote: Event, privateKey: ByteArray, createdAt: Long = Date().time / 1000): ReactionEvent {
-      val content = "+"
-      val pubKey = Utils.pubkeyCreate(privateKey)
-      val tags = listOf( listOf("e", originalNote.id.toHex()), listOf("p", originalNote.pubKey.toHex()))
-      val id = generateId(pubKey, createdAt, kind, tags, content)
-      val sig = Utils.sign(id, privateKey)
-      return ReactionEvent(id, pubKey, createdAt, tags, content, sig)
+        fun createLike(originalNote: EventInterface, privateKey: ByteArray, createdAt: Long = Date().time / 1000): ReactionEvent {
+            return create("+", originalNote, privateKey, createdAt)
+        }
+
+        fun create(content: String, originalNote: EventInterface, privateKey: ByteArray, createdAt: Long = Date().time / 1000): ReactionEvent {
+            val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
+
+            var tags = listOf(listOf("e", originalNote.id()), listOf("p", originalNote.pubKey()))
+            if (originalNote is LongTextNoteEvent) {
+                tags = tags + listOf(listOf("a", originalNote.address().toTag()))
+            }
+
+            val id = generateId(pubKey, createdAt, kind, tags, content)
+            val sig = Utils.sign(id, privateKey)
+            return ReactionEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
+        }
    }
-  }
-}
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/RecommendRelayEvent.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/RecommendRelayEvent.kt
@@ -0,0 +1,37 @@
+package com.vitorpamplona.amethyst.service.model
+
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.toHexKey
+import nostr.postr.Utils
+import java.net.URI
+import java.util.Date
+
+class RecommendRelayEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey,
+    val lenient: Boolean = false
+) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
+
+    fun relay() = if (lenient) {
+        URI.create(content.trim())
+    } else {
+        URI.create(content)
+    }
+
+    companion object {
+        const val kind = 2
+
+        fun create(relay: URI, privateKey: ByteArray, createdAt: Long = Date().time / 1000): RecommendRelayEvent {
+            val content = relay.toString()
+            val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
+            val tags = listOf<List<String>>()
+            val id = generateId(pubKey, createdAt, kind, tags, content)
+            val sig = Utils.sign(id, privateKey)
+            return RecommendRelayEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
+        }
+    }
+}
--- a/app/src/main/java/com/vitorpamplona/amethyst/service/model/RelayAuthEvent.kt
+++ b/app/src/main/java/com/vitorpamplona/amethyst/service/model/RelayAuthEvent.kt
@@ -0,0 +1,34 @@
+package com.vitorpamplona.amethyst.service.model
+
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.toHexKey
+import nostr.postr.Utils
+import java.util.Date
+
+class RelayAuthEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
+    fun relay() = tags.firstOrNull() { it.size > 1 && it[0] == "relay" }?.get(1)
+    fun challenge() = tags.firstOrNull() { it.size > 1 && it[0] == "challenge" }?.get(1)
+
+    companion object {
+        const val kind = 22242
+
+        fun create(relay: String, challenge: String, privateKey: ByteArray, createdAt: Long = Date().time / 1000): RelayAuthEvent {
+            val content = ""
+            val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
+            val tags = listOf(
+                listOf("relay", relay),
+                listOf("challenge", challenge)
+            )
+            val id = generateId(pubKey, createdAt, kind, tags, content)
+            val sig = Utils.sign(id, privateKey)
+            return RelayAuthEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
+        }
+    }
+}
--- a/Show More
+++ b/Show More