v0.55.4

Added German translation

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

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

.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
 

.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

.gitignore

@@ -1,5 +1,3 @@
-*.iml
-.gradle
 /local.properties
 /.idea/caches
 /.idea/libraries
@@ -8,12 +6,11 @@
 /.idea/navEditor.xml
 /.idea/assetWizardSettings.xml
 /.idea/androidTestResultsUserPreferences.xml
+/.idea/deploymentTargetDropDown.xml
 .DS_Store
 /build
 /captures
-.externalNativeBuild
 .cxx
-local.properties
 
 
 # Built application files
@@ -36,6 +33,7 @@ out/
 # release/
 
 # Gradle files
+.gradle
 .gradle/
 build/
 
@@ -48,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.

.idea/.name

@@ -0,0 +1 @@
+Amethyst

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

.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" />

.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.21" />
+  </component>
+</project>

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

PRIVACY.md

@@ -1,12 +1,12 @@
 # Amethyst Privacy Policy & Terms of Use
 
-Effective as of Jan 20, 2023.
+Effective as of Jan 20, 2023 for the distributed applications in the Play Store and the F-Droid Catalogue 
 
 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.
+The app may collect a per-device token, your public key and a preferred Relay to connect to and provide push notification services through Google's Firebase Cloud Messaging. Other than that, the 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.
+You cannot use the Amethyst app for Android 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.
 

README.md

@@ -4,31 +4,82 @@
 
 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)
 - [x] Home Feed
 - [x] Notifications Feed
 - [x] Global Feed
-- [x] Reactions (like, boost, reply)
-- [x] Image Preview (gifs, svgs)
-- [x] Url Preview
+- [x] Reactions (likes NIP-25, boost, reply)
+- [x] Image/Video/Url/LnInvoice Previews
 - [x] View Threads
 - [x] Private Messages (NIP-04)
-- [x] User Profiles (follow/unfollow)
+- [x] User Profiles (edit/follow/unfollow - NIP-02)
 - [x] Public Chats (NIP-28)
-- [x] Notification Bubbles
-- [x] Reporting and Hide User capability
-- [x] Profile Edit
-- [x] Relay Edit (separate relay sets for home, dms, public chats, global)
-- [x] Dropdown to Link Users when writing
+- [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
-- [ ] Zaps 
-- [ ] Infinity Scroll 
-- [ ] Identity Verification (NIP-05)
-- [ ] Event Delegation (NIP-09)
+- [x] Zaps (private, public, anon, non-zap) (NIP-57)
+- [x] URI Support (NIP-21)
+- [x] Created_at Limits (NIP-22)
+- [x] Event Deletion (NIP-09)
+- [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)
+- [x] Custom Emoji (NIP-30)
+- [x] Text Note References (NIP-27)
+- [x] Audio Tracks (zapstr.live) (NIP-TBD)
+- [x] Push Notifications (Zaps and Messages)
+- [x] Generic Tags (NIP-12)
+- [x] Sensitive Content (NIP-36)
+- [ ] Marketplace (NIP-15)
+- [ ] Image/Video Capture in the app
+- [ ] Local Database 
+- [ ] View Individual Reactions (Like, Boost, Zaps, Reports) per Post
+- [ ] Bookmarks, Pinned Posts, Muted Events (NIP-51)
+- [ ] Relay Pages (NIP-11)
+- [ ] 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
-- [ ] Message Sent feedback
+- [ ] Mnemonic seed phrase (NIP-06)
+- [ ] Message Sent feedback (NIP-20)
+- [ ] OpenTimestamps Attestations (NIP-03)
+
 
 # Development Overview
 
@@ -54,7 +105,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
 
@@ -77,9 +128,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
@@ -101,10 +165,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

app/build.gradle

@@ -1,6 +1,8 @@
 plugins {
     id 'com.android.application'
     id 'org.jetbrains.kotlin.android'
+    id 'org.jlleitschuh.gradle.ktlint' version "11.3.1"
+    id 'com.google.gms.google-services'
 }
 
 android {
@@ -11,17 +13,19 @@ android {
         applicationId "com.vitorpamplona.amethyst"
         minSdk 26
         targetSdk 33
-        versionCode 45
-        versionName "0.15.2"
+        versionCode 199
+        versionName "0.55.4"
 
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
         vectorDrawables {
             useSupportLibrary true
         }
+        resConfigs("ar", "cs", "eo", "es", "fa", "fr", "hu", "night", "nl", "pt-rBR", "ru", "sv-rSE", "ta", "tr", "uk", "zh", "sh-rHK", "zh-rTW" )
     }
 
     buildTypes {
         release {
+            // TODO: Make sure all of JSON parsers work when activating these.
             //minifyEnabled true
             //proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
             resValue "string", "app_name", "@string/app_name_release"
@@ -32,52 +36,87 @@ android {
             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.4.0'
+        kotlinCompilerExtensionVersion "1.4.7"
     }
+
     packagingOptions {
         resources {
             excludes += '/META-INF/{AL2.0,LGPL2.1}'
         }
     }
+    lint {
+        disable 'MissingTranslation'
+    }
 }
 
 dependencies {
-    implementation 'androidx.core:core-ktx:1.9.0'
-    implementation 'androidx.activity:activity-compose:1.6.1'
+    implementation 'androidx.core:core-ktx:1.10.1'
+    implementation 'androidx.activity:activity-compose:1.7.2'
     implementation "androidx.compose.ui:ui:$compose_ui_version"
     implementation "androidx.compose.ui:ui-tooling-preview:$compose_ui_version"
 
+    // Needs this to open gallery / image upload
+    implementation "androidx.fragment:fragment-ktx:$fragment_version"
+
     // Navigation
     implementation("androidx.navigation:navigation-compose:$nav_version")
 
     // Observe Live data as State
-    implementation 'androidx.compose.runtime:runtime-livedata:1.4.0-alpha04'
+    implementation "androidx.compose.runtime:runtime-livedata:$compose_ui_version"
 
-    implementation 'androidx.compose.material:material:1.4.0-alpha05'
-    implementation "androidx.compose.material:material-icons-extended:1.4.0-alpha05"
+    implementation "androidx.compose.material:material:$compose_ui_version"
+    implementation "androidx.compose.material:material-icons-extended:$compose_ui_version"
 
     // Lifecycle
-    implementation 'androidx.lifecycle:lifecycle-runtime-compose:2.6.0-alpha05'
-    implementation 'androidx.lifecycle:lifecycle-viewmodel-compose:2.6.0-alpha05'
-    implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.6.0-alpha05'
-    implementation 'androidx.lifecycle:lifecycle-livedata:2.6.0-alpha05'
+    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"
 
-    // Swipe Refresh
-    implementation 'com.google.accompanist:accompanist-swiperefresh:0.29.0-alpha'
+    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.1'
+    implementation 'fr.acinq.secp256k1:secp256k1-kmp-jni-android:0.10.0'
 
     // Nostr Base Protocol
     implementation('com.github.vitorpamplona.NostrPostr:nostrpostrlib:master-SNAPSHOT') {
@@ -86,60 +125,113 @@ dependencies {
         exclude module: 'guava-testlib'
     }
 
-    implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
     // Websockets API
     implementation 'com.squareup.okhttp3:okhttp:5.0.0-alpha.11'
 
-    // Json Serialization
-    implementation 'com.fasterxml.jackson.module:jackson-module-kotlin:2.14.2'
-
-    // Robohash for Avatars
-    implementation group: 'com.github.vitorpamplona', name: 'android-robohash', version: 'master-SNAPSHOT', ext: 'aar'
+    // 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.2'
+    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'
+    implementation 'org.jsoup:jsoup:1.16.1'
+    //implementation 'tw.com.oneup.www:Baha-UrlPreview:1.0.1'
+
+    // 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.7'
+    // important for proxy / tor
+    implementation 'com.google.android.exoplayer:extension-okhttp:2.18.7'
 
     // Load images from the web.
-    implementation "io.coil-kt:coil-compose:2.2.2"
+    implementation "io.coil-kt:coil-compose:$coil_version"
     // view gifs
-    implementation "io.coil-kt:coil-gif:2.2.2"
+    implementation "io.coil-kt:coil-gif:$coil_version"
     // view svgs
-    implementation("io.coil-kt:coil-svg:2.2.2")
+    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"
 
-    // tabs for user profiles
-    implementation "com.google.accompanist:accompanist-pager:$accompanist_version" // Pager
-    implementation "com.google.accompanist:accompanist-pager-indicators:$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 "androidx.camera:camera-camera2:1.2.1"
-    implementation 'androidx.camera:camera-lifecycle:1.2.1'
-    implementation 'androidx.camera:camera-view:1.2.1'
+    implementation 'com.journeyapps:zxing-android-embedded:4.3.0'
 
-    // For QR Scanning
-    implementation 'com.google.mlkit:vision-common:17.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 Barcode Scanning model
-    implementation 'com.google.android.gms:play-services-mlkit-barcode-scanning:18.1.0'
+    // Local model for language identification
+    playImplementation 'com.google.mlkit:language-id:17.0.4'
 
-    // Use this dependency to use the translate text
-    implementation 'com.google.mlkit:translate:17.0.1'
-    implementation 'com.google.mlkit:language-id:17.0.4'
-    implementation 'com.google.android.gms:play-services-mlkit-language-id:17.0.0'
+    // Google services model the translate text
+    playImplementation 'com.google.mlkit:translate:17.0.1'
+
+    // PushNotifications
+    playImplementation platform('com.google.firebase:firebase-bom:32.1.0')
+    playImplementation 'com.google.firebase:firebase-messaging-ktx'
+
+    // Charts
+    implementation "com.patrykandpatrick.vico:core:${vico_version}"
+    implementation "com.patrykandpatrick.vico:compose:${vico_version}"
+    implementation "com.patrykandpatrick.vico:views:${vico_version}"
+    implementation "com.patrykandpatrick.vico:compose-m2:${vico_version}"
+
+    // immutable collections to avoid recomposition
+    implementation("org.jetbrains.kotlinx:kotlinx-collections-immutable:0.3.5")
+
+    // Automatic memory leak detection
+    debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.11'
 
     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, "")
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

app/google-services.json

@@ -0,0 +1,68 @@
+{
+  "project_info": {
+    "project_number": "768341258853",
+    "project_id": "amethyst-3057a",
+    "storage_bucket": "amethyst-3057a.appspot.com"
+  },
+  "client": [
+    {
+      "client_info": {
+        "mobilesdk_app_id": "1:768341258853:android:5d07c35a37b24ff36b8c8c",
+        "android_client_info": {
+          "package_name": "com.vitorpamplona.amethyst"
+        }
+      },
+      "oauth_client": [
+        {
+          "client_id": "768341258853-6um8ig59qstvio60gfo60fe5e45lnqqe.apps.googleusercontent.com",
+          "client_type": 3
+        }
+      ],
+      "api_key": [
+        {
+          "current_key": "AIzaSyB7ZxgdpgrN6R223HCFdfv4ulP8Egp7trE"
+        }
+      ],
+      "services": {
+        "appinvite_service": {
+          "other_platform_oauth_client": [
+            {
+              "client_id": "768341258853-6um8ig59qstvio60gfo60fe5e45lnqqe.apps.googleusercontent.com",
+              "client_type": 3
+            }
+          ]
+        }
+      }
+    },
+    {
+      "client_info": {
+        "mobilesdk_app_id": "1:768341258853:android:e0200680f552484d6b8c8c",
+        "android_client_info": {
+          "package_name": "com.vitorpamplona.amethyst.debug"
+        }
+      },
+      "oauth_client": [
+        {
+          "client_id": "768341258853-6um8ig59qstvio60gfo60fe5e45lnqqe.apps.googleusercontent.com",
+          "client_type": 3
+        }
+      ],
+      "api_key": [
+        {
+          "current_key": "AIzaSyB7ZxgdpgrN6R223HCFdfv4ulP8Egp7trE"
+        }
+      ],
+      "services": {
+        "appinvite_service": {
+          "other_platform_oauth_client": [
+            {
+              "client_id": "768341258853-6um8ig59qstvio60gfo60fe5e45lnqqe.apps.googleusercontent.com",
+              "client_type": 3
+            }
+          ]
+        }
+      }
+    }
+  ],
+  "configuration_version": "1"
+}

app/proguard-rules.pro

@@ -25,7 +25,7 @@
 -keep class fr.acinq.secp256k1.jni.** { *; }
 # For the NostrPostr library
 -keep class nostr.postr.** { *; }
--keep class nostr.postr.events.** { *; }
+-keep class com.vitorpamplona.amethyst.service.model.** { *; }
 # Json parsing
 -keep class com.google.gson.reflect.** { *; }
 -keep class * extends com.google.gson.reflect.TypeToken

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

@@ -0,0 +1,89 @@
+package com.vitorpamplona.amethyst
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.vitorpamplona.amethyst.service.model.Event
+import com.vitorpamplona.amethyst.service.model.TextNoteEvent
+import junit.framework.TestCase.assertEquals
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class CitationTests {
+    val json = """
+    {
+  "content": "Astral:\n\nhttps://void.cat/d/A5Fba5B1bcxwEmeyoD9nBs.webp\n\nIris:\n\nhttps://void.cat/d/44hTcVvhRps6xYYs99QsqA.webp\n\nSnort:\n\nhttps://void.cat/d/4nJD5TRePuQChM5tzteYbU.webp\n\nAmethyst agrees with Astral which I suspect are both wrong. nostr:npub13sx6fp3pxq5rl70x0kyfmunyzaa9pzt5utltjm0p8xqyafndv95q3saapa nostr:npub1v0lxxxxutpvrelsksy8cdhgfux9l6a42hsj2qzquu2zk7vc9qnkszrqj49 nostr:npub1g53mukxnjkcmr94fhryzkqutdz2ukq4ks0gvy5af25rgmwsl4ngq43drvk nostr:npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z ",
+  "created_at": 1683596206,
+  "id": "98b574c3527f0ffb30b7271084e3f07480733c7289f8de424d29eae82e36c758",
+  "kind": 1,
+  "pubkey": "46fcbe3065eaf1ae7811465924e48923363ff3f526bd6f73d7c184b16bd8ce4d",
+  "sig": "4aa5264965018fa12a326686ad3d3bd8beae3218dcc83689b19ca1e6baeb791531943c15363aa6707c7c0c8b2d601deca1f20c32078b2872d356cdca03b04cce",
+  "tags": [
+    [
+      "e",
+      "27ac621d7dc4a932e1a79f984308e7d20656dd6fddb2ce9cdfcb6a67b9a7bcc3",
+      "",
+      "root"
+    ],
+    [
+      "e",
+      "be7245af96210a0dd048cab4ad38e52dbd6c09a53ea21a7edb6be8898e5727cc",
+      "",
+      "reply"
+    ],
+    [
+      "p",
+      "22aa81510ee63fe2b16cae16e0921f78e9ba9882e2868e7e63ad6d08ae9b5954"
+    ],
+    [
+      "p",
+      "22aa81510ee63fe2b16cae16e0921f78e9ba9882e2868e7e63ad6d08ae9b5954"
+    ],
+    [
+      "p",
+      "3f770d65d3a764a9c5cb503ae123e62ec7598ad035d836e2a810f3877a745b24"
+    ],
+    [
+      "p",
+      "ec4d241c334311b3a304433ee3442be29d0e88e7ec19b85edf2bba29b93565e2"
+    ],
+    [
+      "p",
+      "0fe0b18b4dbf0e0aa40fcd47209b2a49b3431fc453b460efcf45ca0bd16bd6ac"
+    ],
+    [
+      "p",
+      "8c0da4862130283ff9e67d889df264177a508974e2feb96de139804ea66d6168"
+    ],
+    [
+      "p",
+      "63fe6318dc58583cfe16810f86dd09e18bfd76aabc24a0081ce2856f330504ed"
+    ],
+    [
+      "p",
+      "4523be58d395b1b196a9b8c82b038b6895cb02b683d0c253a955068dba1facd0"
+    ],
+    [
+      "p",
+      "460c25e682fda7832b52d1f22d3d22b3176d972f60dcdc3212ed8c92ef85065c"
+    ]
+  ],
+  "seenOn": [
+    "wss://nostr.wine/"
+  ]
+}
+"""
+
+    @Test
+    fun parseEvent() {
+        val event = Event.fromJson(json, true) as TextNoteEvent
+
+        val expectedCitations = setOf(
+            "8c0da4862130283ff9e67d889df264177a508974e2feb96de139804ea66d6168",
+            "63fe6318dc58583cfe16810f86dd09e18bfd76aabc24a0081ce2856f330504ed",
+            "4523be58d395b1b196a9b8c82b038b6895cb02b683d0c253a955068dba1facd0",
+            "460c25e682fda7832b52d1f22d3d22b3176d972f60dcdc3212ed8c92ef85065c"
+        )
+
+        assertEquals(expectedCitations, event.citedUsers())
+    }
+}

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

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

@@ -0,0 +1,113 @@
+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.NostrFilesDevServer
+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.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 bytes = Base64.getDecoder().decode(image)
+        val inputStream = bytes.inputStream()
+
+        ImageUploader.uploadImage(
+            inputStream,
+            bytes.size.toLong(),
+            "image/gif",
+            ImgurServer(),
+            onSuccess = { url, contentType ->
+                println("Uploaded to $url")
+                assertNotNull(url)
+            },
+            onError = {
+                println("Failed to Upload")
+                fail("${it.message}")
+            }
+        )
+
+        delay(5000)
+    }
+
+    @Test()
+    fun testNostrBuildUpload() = runBlocking {
+        val bytes = Base64.getDecoder().decode(image)
+        val inputStream = bytes.inputStream()
+
+        ImageUploader.uploadImage(
+            inputStream,
+            bytes.size.toLong(),
+            "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 bytes = Base64.getDecoder().decode(image)
+        val inputStream = bytes.inputStream()
+
+        ImageUploader.uploadImage(
+            inputStream,
+            bytes.size.toLong(),
+            "image/gif",
+            NostrImgServer(),
+            onSuccess = { url, contentType ->
+                println("Uploaded to $url")
+                assertNotNull(url)
+            },
+            onError = {
+                println("Failed to Upload")
+                fail("${it.message}")
+            }
+        )
+
+        delay(1000)
+    }
+
+    @Test()
+    fun testNostrFilesDevUpload() = runBlocking {
+        val bytes = Base64.getDecoder().decode(image)
+        val inputStream = bytes.inputStream()
+
+        ImageUploader.uploadImage(
+            inputStream,
+            bytes.size.toLong(),
+            "image/gif",
+            NostrFilesDevServer(),
+            onSuccess = { url, contentType ->
+                println("Uploaded to $url")
+                assertNotNull(url)
+            },
+            onError = {
+                println("Failed to Upload")
+                fail("${it.message}")
+            }
+        )
+
+        delay(5000)
+    }
+}

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

@@ -0,0 +1,138 @@
+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 =
+                privateZapRequest.getPrivateZapEvent(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 = privateZapRequest.getPrivateZapEvent(privateKey, recepientPK)
+
+            println(decodedPrivateZap?.toJson())
+            assertNotNull(decodedPrivateZap)
+        } else {
+            fail("Should not be null")
+        }
+    }
+}

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

@@ -5,10 +5,11 @@ 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.*
+import org.junit.Assert.assertEquals
 import org.junit.Test
 import org.junit.runner.RunWith
 
@@ -18,80 +19,81 @@ import org.junit.runner.RunWith
  * See [testing documentation](http://d.android.com/tools/testing).
  */
 @RunWith(AndroidJUnit4::class)
-class EUrlUserTagTransformationTest {
-  @Test
-  fun useAppContext() {
-    // Context of the app under test.
-    val appContext = InstrumentationRegistry.getInstrumentation().targetContext
-    assertEquals("com.vitorpamplona.amethyst", appContext.packageName.removeSuffix(".debug"))
-  }
+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.displayName = "Vitor Pamplona"
+    @Test
+    fun transformationText() {
+        val user = LocalCache.getOrCreateUser(decodePublicKey("npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z").toHexKey())
+        user.info = UserMetadata()
+        user.info?.displayName = "Vitor Pamplona"
 
-    var transformedText = buildAnnotatedStringWithUrlHighlighting(
-      AnnotatedString("New Hey @npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z"),
-      Color.Red
-    )
+        val transformedText = buildAnnotatedStringWithUrlHighlighting(
+            AnnotatedString("New Hey @npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z"),
+            Color.Red
+        )
 
-    assertEquals("New Hey @Vitor Pamplona", transformedText.text.text)
+        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(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(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(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))
+    }
 
-    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"
 
-  @Test
-  fun transformationTextTwoKeys() {
-    val user = LocalCache.getOrCreateUser(decodePublicKey("npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z").toHexKey())
-    user.info.displayName = "Vitor Pamplona"
+        val transformedText = buildAnnotatedStringWithUrlHighlighting(
+            AnnotatedString("New Hey @npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z and @npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z"),
+            Color.Red
+        )
 
-    var transformedText = buildAnnotatedStringWithUrlHighlighting(
-      AnnotatedString("New Hey @npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z and @npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z"),
-      Color.Red
-    )
+        assertEquals("New Hey @Vitor Pamplona and @Vitor Pamplona", transformedText.text.text)
 
-    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(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(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 @
-  }
-}
+        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 @
+    }
+}

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

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

@@ -0,0 +1,8 @@
+package com.vitorpamplona.amethyst.service.notifications
+
+import com.vitorpamplona.amethyst.AccountInfo
+
+class PushNotificationUtils {
+    fun init(accounts: List<AccountInfo>) {
+    }
+}

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 com.vitorpamplona.amethyst.ui.actions.ImmutableListOfLists
+import com.vitorpamplona.amethyst.ui.screen.loggedIn.AccountViewModel
+
+@Composable
+fun TranslatableRichTextViewer(
+    content: String,
+    canPreview: Boolean,
+    modifier: Modifier = Modifier,
+    tags: ImmutableListOfLists<String>,
+    backgroundColor: Color,
+    accountViewModel: AccountViewModel,
+    nav: (String) -> Unit
+) = ExpandableRichTextViewer(
+    content,
+    canPreview,
+    modifier,
+    tags,
+    backgroundColor,
+    accountViewModel,
+    nav
+)

app/src/main/AndroidManifest.xml

@@ -1,11 +1,17 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools">
+    <queries>
+        <package android:name="org.torproject.android"/>
+    </queries>
+    <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" />
+    <uses-permission android:name="android.permission.NFC" />
 
     <!-- Used for SDK < 29 -->
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"
@@ -13,21 +19,24 @@
 
     <application
         android:allowBackup="false"
+        android:name=".Amethyst"
         android:dataExtractionRules="@xml/data_extraction_rules"
         android:fullBackupContent="@xml/backup_rules"
-        android:icon="@drawable/amethyst"
+        android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
         android:enableOnBackInvokedCallback="true"
         android:supportsRtl="true"
         android:theme="@style/Theme.Amethyst"
         android:largeHeap="true"
         android:usesCleartextTraffic="true"
+        android:hardwareAccelerated="true"
+        android:localeConfig="@xml/locales_config"
         tools:targetApi="33">
         <activity
-            android:label="@string/app_name"
             android:name=".ui.MainActivity"
             android:exported="true"
             android:windowSoftInputMode="adjustResize"
+            android:configChanges="orientation|screenSize|screenLayout"
             android:theme="@style/Theme.Amethyst">
 
             <intent-filter android:label="Amethyst">
@@ -42,14 +51,30 @@
                 <data android:scheme="nostr" />
             </intent-filter>
 
+            <intent-filter android:label="Amethyst">
+                <action android:name="android.nfc.action.NDEF_DISCOVERED"/>
+                <category android:name="android.intent.category.DEFAULT" />
+                <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>
 
-        <meta-data
-            android:name="com.google.mlkit.vision.DEPENDENCIES"
-            android:value="barcode" />
+        <activity
+            android:name="com.journeyapps.barcodescanner.CaptureActivity"
+            android:screenOrientation="fullSensor"
+            tools:replace="screenOrientation" />
+
     </application>
 
 </manifest>

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

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

@@ -1,22 +1,29 @@
 package com.vitorpamplona.amethyst
 
-import android.content.Context
 import androidx.security.crypto.EncryptedSharedPreferences
-import androidx.security.crypto.MasterKeys
+import androidx.security.crypto.MasterKey
 
-class EncryptedStorage {
+object EncryptedStorage {
+    private const val PREFERENCES_NAME = "secret_keeper"
 
-  fun preferences(context: Context): EncryptedSharedPreferences {
-    val secretKey: String = MasterKeys.getOrCreate(MasterKeys.AES256_GCM_SPEC);
-    val preferencesName = "secret_keeper"
+    fun prefsFileName(npub: String? = null): String {
+        return if (npub == null) PREFERENCES_NAME else "${PREFERENCES_NAME}_$npub"
+    }
 
-    return EncryptedSharedPreferences.create(
-      preferencesName,
-      secretKey,
-      context,
-      EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
-      EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
-    ) as EncryptedSharedPreferences
-  }
+    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
+    }
+}

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

@@ -1,82 +1,389 @@
 package com.vitorpamplona.amethyst
 
+import android.annotation.SuppressLint
 import android.content.Context
+import android.content.SharedPreferences
+import androidx.compose.runtime.Immutable
 import com.google.gson.GsonBuilder
 import com.google.gson.reflect.TypeToken
 import com.vitorpamplona.amethyst.model.Account
-import com.vitorpamplona.amethyst.model.toByteArray
+import com.vitorpamplona.amethyst.model.GLOBAL_FOLLOWS
+import com.vitorpamplona.amethyst.model.KIND3_FOLLOWS
 import com.vitorpamplona.amethyst.model.RelaySetupInfo
-import java.util.Locale
+import com.vitorpamplona.amethyst.model.hexToByteArray
+import com.vitorpamplona.amethyst.service.HttpClient
+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
 
-class LocalPreferences(context: Context) {
-  val encryptedPreferences = EncryptedStorage().preferences(context)
-  val gson = GsonBuilder().create()
+// 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"
 
-  fun clearEncryptedStorage() {
-    encryptedPreferences.edit().apply {
-      remove("nostr_privkey")
-      remove("nostr_pubkey")
-      remove("following_channels")
-      remove("hidden_users")
-      remove("relays")
-      remove("dontTranslateFrom")
-      remove("translateTo")
-    }.apply()
-  }
+@Immutable
+data class AccountInfo(
+    val npub: String,
+    val hasPrivKey: Boolean = false
+)
 
-  fun saveToEncryptedStorage(account: Account) {
-    encryptedPreferences.edit().apply {
-      account.loggedIn.privKey?.let { putString("nostr_privkey", it.toHex()) }
-      account.loggedIn.pubKey.let { putString("nostr_pubkey", it.toHex()) }
-      account.followingChannels.let { putStringSet("following_channels", it) }
-      account.hiddenUsers.let { putStringSet("hidden_users", it) }
-      account.localRelays.let { putString("relays", gson.toJson(it)) }
-      account.dontTranslateFrom.let { putStringSet("dontTranslateFrom", it) }
-      account.translateTo.let { putString("translateTo", it) }
-    }.apply()
-  }
+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 DEFAULT_HOME_FOLLOW_LIST = "defaultHomeFollowList"
+    const val DEFAULT_STORIES_FOLLOW_LIST = "defaultStoriesFollowList"
+    const val DEFAULT_NOTIFICATION_FOLLOW_LIST = "defaultNotificationFollowList"
+    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"
+    const val USE_PROXY = "use_proxy"
+    const val PROXY_PORT = "proxy_port"
+    const val SHOW_SENSITIVE_CONTENT = "show_sensitive_content"
+    val LAST_READ: (String) -> String = { route -> "last_read_route_$route" }
+}
 
-  fun loadFromEncryptedStorage(): Account? {
-    encryptedPreferences.apply {
-      val privKey = getString("nostr_privkey", null)
-      val pubKey = getString("nostr_pubkey", null)
-      val followingChannels = getStringSet("following_channels", null) ?: setOf()
-      val hiddenUsers = getStringSet("hidden_users", emptySet()) ?: setOf()
-      val localRelays = gson.fromJson(
-        getString("relays", "[]"),
-        object : TypeToken<Set<RelaySetupInfo>>() {}.type
-      ) ?: setOf<RelaySetupInfo>()
+private val gson = GsonBuilder().create()
 
-      val dontTranslateFrom = getStringSet("dontTranslateFrom", null) ?: setOf()
-      val translateTo = getString("translateTo", null) ?: Locale.getDefault().language
+object LocalPreferences {
+    private const val comma = ","
 
-      if (pubKey != null) {
-        return Account(
-          Persona(privKey = privKey?.toByteArray(), pubKey = pubKey.toByteArray()),
-          followingChannels,
-          hiddenUsers,
-          localRelays,
-          dontTranslateFrom,
-          translateTo
+    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.DEFAULT_HOME_FOLLOW_LIST, account.defaultHomeFollowList)
+            putString(PrefKeys.DEFAULT_STORIES_FOLLOW_LIST, account.defaultStoriesFollowList)
+            putString(PrefKeys.DEFAULT_NOTIFICATION_FOLLOW_LIST, account.defaultNotificationFollowList)
+            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)
+            putBoolean(PrefKeys.USE_PROXY, account.proxy != null)
+            putInt(PrefKeys.PROXY_PORT, account.proxyPort)
+
+            if (account.showSensitiveContent == null) {
+                remove(PrefKeys.SHOW_SENSITIVE_CONTENT)
+            } else {
+                putBoolean(PrefKeys.SHOW_SENSITIVE_CONTENT, account.showSensitiveContent!!)
+            }
+        }.apply()
+    }
+
+    fun loadFromEncryptedStorage(): Account? {
+        val acc = loadFromEncryptedStorage(currentAccount())
+        acc?.registerObservers()
+        return acc
+    }
+
+    fun loadFromEncryptedStorage(npub: String?): Account? {
+        encryptedPreferences(npub).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 defaultHomeFollowList = getString(PrefKeys.DEFAULT_HOME_FOLLOW_LIST, null) ?: KIND3_FOLLOWS
+            val defaultStoriesFollowList = getString(PrefKeys.DEFAULT_STORIES_FOLLOW_LIST, null) ?: GLOBAL_FOLLOWS
+            val defaultNotificationFollowList = getString(PrefKeys.DEFAULT_NOTIFICATION_FOLLOW_LIST, null) ?: GLOBAL_FOLLOWS
+
+            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, "NOSTR_BUILD"),
+                object : TypeToken<ServersAvailable>() {}.type
+            ) ?: ServersAvailable.NOSTR_BUILD
+
+            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 useProxy = getBoolean(PrefKeys.USE_PROXY, false)
+            val proxyPort = getInt(PrefKeys.PROXY_PORT, 9050)
+            val proxy = HttpClient.initProxy(useProxy, "127.0.0.1", proxyPort)
+
+            val showSensitiveContent = if (contains(PrefKeys.SHOW_SENSITIVE_CONTENT)) {
+                getBoolean(PrefKeys.SHOW_SENSITIVE_CONTENT, false)
+            } else {
+                null
+            }
+
+            val a = Account(
+                Persona(privKey = privKey?.hexToByteArray(), pubKey = pubKey.hexToByteArray()),
+                followingChannels,
+                hiddenUsers,
+                localRelays,
+                dontTranslateFrom,
+                languagePreferences,
+                translateTo,
+                zapAmountChoices,
+                defaultZapType,
+                defaultFileServer,
+                defaultHomeFollowList,
+                defaultStoriesFollowList,
+                defaultNotificationFollowList,
+                zapPaymentRequestServer,
+                hideDeleteRequestDialog,
+                hideBlockAlertDialog,
+                latestContactList,
+                proxy,
+                proxyPort,
+                showSensitiveContent
+            )
+
+            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
         )
-      } else {
-        return null
-      }
+
+        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)
     }
-  }
-
-  fun saveLastRead(route: String, timestampInSecs: Long) {
-    encryptedPreferences.edit().apply {
-      putLong("last_read_route_${route}", timestampInSecs)
-    }.apply()
-  }
-
-  fun loadLastRead(route: String): Long {
-    encryptedPreferences.run {
-      return getLong("last_read_route_${route}", 0)
-    }
-  }
-
-}
+}

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

@@ -1,62 +1,53 @@
 package com.vitorpamplona.amethyst
 
-import android.content.Context
 import androidx.lifecycle.LiveData
-import com.vitorpamplona.amethyst.model.Note
+import com.vitorpamplona.amethyst.ui.components.BundledUpdate
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
-import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 
 object NotificationCache {
-  val lastReadByRoute = mutableMapOf<String, Long>()
+    // TODO: This must be account-based
+    val lastReadByRoute = mutableMapOf<String, Long>()
 
-  fun markAsRead(route: String, timestampInSecs: Long, context: Context) {
-    val lastTime = lastReadByRoute[route]
-    if (lastTime == null || timestampInSecs > lastTime) {
-      lastReadByRoute.put(route, timestampInSecs)
+    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(context).saveLastRead(route, timestampInSecs)
-        invalidateData()
-      }
+            val scope = CoroutineScope(Job() + Dispatchers.IO)
+            scope.launch {
+                LocalPreferences.saveLastRead(route, timestampInSecs)
+                live.invalidateData()
+            }
+        }
     }
-  }
 
-  fun load(route: String, context: Context): Long {
-    var lastTime = lastReadByRoute[route]
-    if (lastTime == null) {
-      lastTime = LocalPreferences(context).loadLastRead(route)
-      lastReadByRoute[route] = lastTime
+    fun load(route: String): Long {
+        var lastTime = lastReadByRoute[route]
+        if (lastTime == null) {
+            lastTime = LocalPreferences.loadLastRead(route)
+            lastReadByRoute[route] = lastTime
+        }
+        return lastTime
     }
-    return lastTime
-  }
 
-  // Observers line up here.
-  val live: NotificationLiveData = NotificationLiveData(this)
-
-  // Refreshes observers in batches.
-  var handlerWaiting = false
-  @Synchronized
-  fun invalidateData() {
-    if (handlerWaiting) return
-
-    handlerWaiting = true
-    val scope = CoroutineScope(Job() + Dispatchers.Default)
-    scope.launch {
-      delay(100)
-      live.refresh()
-      handlerWaiting = false
-    }
-  }
+    // Observers line up here.
+    val live: NotificationLiveData = NotificationLiveData(this)
 }
 
-class NotificationLiveData(val cache: NotificationCache): LiveData<NotificationState>(NotificationState(cache)) {
-  fun refresh() {
-    postValue(NotificationState(cache))
-  }
+class NotificationLiveData(val cache: NotificationCache) : LiveData<NotificationState>(NotificationState(cache)) {
+    // Refreshes observers in batches.
+    private val bundler = BundledUpdate(300, Dispatchers.IO)
+
+    fun invalidateData() {
+        bundler.invalidate() {
+            if (hasActiveObservers()) {
+                postValue(NotificationState(cache))
+            }
+        }
+    }
 }
 
-class NotificationState(val cache: NotificationCache)
+class NotificationState(val cache: NotificationCache)

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

@@ -1,23 +0,0 @@
-package com.vitorpamplona.amethyst
-
-import android.content.Context
-import android.graphics.Bitmap
-import android.util.LruCache
-import java.util.UUID
-import name.neuhalfen.projects.android.robohash.RoboHash
-
-object RoboHashCache {
-
-  lateinit var robots: RoboHash
-
-  @Synchronized
-  fun get(context: Context, hash: String): Bitmap {
-    if (!this::robots.isInitialized) {
-      robots = RoboHash(context)
-      robots.useCache(LruCache(100));
-    }
-
-    return robots.imageForHandle(robots.calculateHandleFromUUID(UUID.nameUUIDFromBytes("aaaa".toByteArray())))
-  }
-
-}

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

@@ -1,81 +1,104 @@
 package com.vitorpamplona.amethyst
 
+import android.content.Context
+import android.os.Build
+import coil.Coil
+import coil.ImageLoader
+import coil.decode.GifDecoder
+import coil.decode.ImageDecoderDecoder
+import coil.decode.SvgDecoder
 import com.vitorpamplona.amethyst.model.Account
-import com.vitorpamplona.amethyst.service.relays.Constants
+import com.vitorpamplona.amethyst.model.LocalCache
+import com.vitorpamplona.amethyst.service.HttpClient
 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.NostrNotificationDataSource
 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.NostrUserProfileFollowersDataSource
-import com.vitorpamplona.amethyst.service.NostrUserProfileFollowsDataSource
+import com.vitorpamplona.amethyst.service.NostrVideoDataSource
 import com.vitorpamplona.amethyst.service.relays.Client
 
 object ServiceManager {
-  private var account: Account? = null
+    private var account: Account? = null
 
-  fun start(account: Account) {
-    this.account = account
-    start()
-  }
-
-  fun start() {
-    val myAccount = account
-
-    if (myAccount != null) {
-      Client.connect(myAccount.convertLocalRelays())
-
-      // start services
-      NostrAccountDataSource.account = myAccount
-      NostrHomeDataSource.account = myAccount
-      NostrNotificationDataSource.account = myAccount
-      NostrChatroomListDataSource.account = myAccount
-
-      NostrGlobalDataSource.account = myAccount
-      NostrChannelDataSource.account = myAccount
-
-      NostrUserProfileDataSource.account = myAccount
-      NostrUserProfileFollowsDataSource.account = myAccount
-      NostrUserProfileFollowersDataSource.account = myAccount
-
-      NostrAccountDataSource.start()
-      //NostrGlobalDataSource.start()
-      NostrHomeDataSource.start()
-      NostrNotificationDataSource.start()
-      NostrSingleEventDataSource.start()
-      NostrSingleChannelDataSource.start()
-      NostrSingleUserDataSource.start()
-      //NostrThreadDataSource.start()
-      NostrChatroomListDataSource.start()
-    } else {
-      // if not logged in yet, start a basic service wit default relays
-      Client.connect(Constants.convertDefaultRelays())
+    fun start(account: Account, context: Context) {
+        this.account = account
+        start(context)
     }
-  }
 
-  fun pause() {
-    NostrAccountDataSource.stop()
-    NostrHomeDataSource.stop()
-    NostrChannelDataSource.stop()
-    NostrChatroomListDataSource.stop()
-    NostrUserProfileDataSource.stop()
-    NostrUserProfileFollowersDataSource.stop()
-    NostrUserProfileFollowsDataSource.stop()
+    fun start(context: Context) {
+        val myAccount = account
 
-    NostrGlobalDataSource.stop()
-    NostrNotificationDataSource.stop()
-    NostrSingleChannelDataSource.stop()
-    NostrSingleEventDataSource.stop()
-    NostrSingleUserDataSource.stop()
-    NostrThreadDataSource.stop()
+        // Resets Proxy Use
+        HttpClient.start(account)
+        Coil.setImageLoader {
+            ImageLoader.Builder(context).components {
+                if (Build.VERSION.SDK_INT >= 28) {
+                    add(ImageDecoderDecoder.Factory())
+                } else {
+                    add(GifDecoder.Factory())
+                }
+                add(SvgDecoder.Factory())
+            } // .logger(DebugLogger())
+                .okHttpClient { HttpClient.getHttpClient() }
+                .respectCacheHeaders(false)
+                .build()
+        }
 
-    Client.disconnect()
-  }
+        // Initializes video cache.
+        VideoCache.init(context.applicationContext)
 
-}
+        if (myAccount != null) {
+            Client.connect(myAccount.activeRelays() ?: myAccount.convertLocalRelays())
+
+            // start services
+            NostrAccountDataSource.account = myAccount
+            NostrHomeDataSource.account = myAccount
+            NostrChatroomListDataSource.account = myAccount
+            NostrVideoDataSource.account = myAccount
+
+            // Notification Elements
+            NostrHomeDataSource.start()
+            NostrAccountDataSource.start()
+            NostrChatroomListDataSource.start()
+
+            // More Info Data Sources
+            NostrSingleEventDataSource.start()
+            NostrSingleChannelDataSource.start()
+            NostrSingleUserDataSource.start()
+        }
+    }
+
+    fun pause() {
+        NostrAccountDataSource.stop()
+        NostrHomeDataSource.stop()
+        NostrChannelDataSource.stop()
+        NostrChatroomListDataSource.stop()
+
+        NostrGlobalDataSource.stop()
+        NostrSingleChannelDataSource.stop()
+        NostrSingleEventDataSource.stop()
+        NostrSingleUserDataSource.stop()
+        NostrThreadDataSource.stop()
+        NostrUserProfileDataSource.stop()
+        NostrVideoDataSource.stop()
+
+        Client.disconnect()
+    }
+
+    fun cleanUp() {
+        LocalCache.cleanObservers()
+
+        account?.let {
+            LocalCache.pruneOldAndHiddenMessages(it)
+            LocalCache.pruneHiddenMessages(it)
+            LocalCache.pruneContactLists(it)
+            // LocalCache.pruneNonFollows(it)
+        }
+    }
+}

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

@@ -2,40 +2,50 @@ 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.ext.okhttp.OkHttpDataSource
 import com.google.android.exoplayer2.upstream.cache.CacheDataSource
 import com.google.android.exoplayer2.upstream.cache.LeastRecentlyUsedCacheEvictor
 import com.google.android.exoplayer2.upstream.cache.SimpleCache
+import com.vitorpamplona.amethyst.service.HttpClient
 
 object VideoCache {
 
-  var exoPlayerCacheSize: Long = 90 * 1024 * 1024 // 90MB
+    var exoPlayerCacheSize: Long = 90 * 1024 * 1024 // 90MB
 
-  var leastRecentlyUsedCacheEvictor = LeastRecentlyUsedCacheEvictor(exoPlayerCacheSize)
+    var leastRecentlyUsedCacheEvictor = LeastRecentlyUsedCacheEvictor(exoPlayerCacheSize)
 
-  lateinit var exoDatabaseProvider: StandaloneDatabaseProvider
-  lateinit var simpleCache: SimpleCache
+    lateinit var exoDatabaseProvider: StandaloneDatabaseProvider
+    lateinit var simpleCache: SimpleCache
 
-  lateinit var cacheDataSourceFactory: CacheDataSource.Factory
+    lateinit var cacheDataSourceFactory: CacheDataSource.Factory
 
-  fun get(context: Context): CacheDataSource.Factory {
-    if (!this::simpleCache.isInitialized) {
-      exoDatabaseProvider = StandaloneDatabaseProvider(context)
+    fun init(context: Context) {
+        if (!this::simpleCache.isInitialized) {
+            exoDatabaseProvider = StandaloneDatabaseProvider(context)
 
-      simpleCache = SimpleCache(
-        context.cacheDir,
-        leastRecentlyUsedCacheEvictor,
-        exoDatabaseProvider
-      )
+            simpleCache = SimpleCache(
+                context.cacheDir,
+                leastRecentlyUsedCacheEvictor,
+                exoDatabaseProvider
+            )
 
-      cacheDataSourceFactory = CacheDataSource.Factory()
-        .setCache(simpleCache)
-        .setUpstreamDataSourceFactory(
-          DefaultHttpDataSource.Factory().setAllowCrossProtocolRedirects(true)
-        )
-        .setFlags(CacheDataSource.FLAG_IGNORE_CACHE_ON_ERROR)
+            cacheDataSourceFactory = CacheDataSource.Factory()
+                .setCache(simpleCache)
+                .setUpstreamDataSourceFactory(
+                    OkHttpDataSource.Factory(HttpClient.getHttpClient())
+                )
+                .setFlags(CacheDataSource.FLAG_IGNORE_CACHE_ON_ERROR)
+        } else {
+            cacheDataSourceFactory = CacheDataSource.Factory()
+                .setCache(simpleCache)
+                .setUpstreamDataSourceFactory(
+                    OkHttpDataSource.Factory(HttpClient.getHttpClient())
+                )
+                .setFlags(CacheDataSource.FLAG_IGNORE_CACHE_ON_ERROR)
+        }
     }
 
-    return cacheDataSourceFactory
-  }
-}
+    fun get(): CacheDataSource.Factory {
+        return cacheDataSourceFactory
+    }
+}

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

@@ -1,148 +0,0 @@
-package com.vitorpamplona.amethyst.lnurl
-
-import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
-import java.net.URLEncoder
-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
-
-class LightningAddressResolver {
-  val client = OkHttpClient.Builder().build()
-
-  fun assembleUrl(lnaddress: String): String? {
-    val parts = lnaddress.split("@")
-
-    if (parts.size != 2) {
-      return null
-    }
-
-    return "https://${parts[1]}/.well-known/lnurlp/${parts[0]}"
-  }
-
-  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().url(url).build()
-
-      client.newCall(request).enqueue(object : Callback {
-        override fun onResponse(call: Call, response: Response) {
-          response.use {
-            onSuccess(response.body.string())
-          }
-        }
-
-        override fun onFailure(call: Call, e: java.io.IOException) {
-          onError("Could not resolve User's LNURL address from ${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().url(url).build()
-
-      client.newCall(request).enqueue(object : Callback {
-        override fun onResponse(call: Call, response: Response) {
-          response.use {
-            onSuccess(response.body.string())
-          }
-        }
-
-        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) {
-    val mapper = jacksonObjectMapper()
-
-    fetchLightningAddressJson(lnaddress,
-      onSuccess = {
-        val lnurlp = try {
-          mapper.readTree(it)
-        } 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 { callback ->
-          fetchLightningInvoice(callback, milliSats, message, if (allowsNostr) nostrRequest else null,
-            onSuccess = {
-              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 ->
-                onSuccess(pr)
-              }
-            },
-            onError = onError
-          )
-        }
-      },
-      onError = onError
-    )
-  }
-}

app/src/main/java/com/vitorpamplona/amethyst/lnurl/LnInvoiceUtil.kt

@@ -1,157 +0,0 @@
-package com.vitorpamplona.amethyst.lnurl
-
-import androidx.compose.ui.text.toLowerCase
-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.toLowerCase()) {
-      "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
-  }
-}

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

@@ -0,0 +1,74 @@
+package com.vitorpamplona.amethyst.model
+
+import android.util.Log
+import android.util.LruCache
+import androidx.lifecycle.LiveData
+import com.vitorpamplona.amethyst.service.checkNotInMainThread
+import com.vitorpamplona.amethyst.service.model.Event
+import com.vitorpamplona.amethyst.service.nip19.Nip19
+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 {
+        checkNotInMainThread()
+
+        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 for sharing", "${Nip19.createNEvent(event.id, event.pubKey, event.kind, 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.IO)
+
+    fun invalidateData() {
+        bundler.invalidate() {
+            if (hasActiveObservers()) {
+                postValue(AntiSpamState(cache))
+            }
+        }
+    }
+}
+
+class AntiSpamState(val cache: AntiSpamFilter)

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

@@ -1,37 +1,50 @@
 package com.vitorpamplona.amethyst.model
 
+import androidx.compose.runtime.Stable
 import androidx.lifecycle.LiveData
-import com.vitorpamplona.amethyst.service.NostrSingleEventDataSource
+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 id: ByteArray) {
-    val idHex = id.toHexKey()
-    val idDisplayHex = id.toShortenHex()
-
+@Stable
+class Channel(val idHex: String) {
     var creator: User? = null
     var info = ChannelCreateEvent.ChannelData(null, null, null)
 
-    var updatedMetadataAt: Long = 0;
+    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 ?: idDisplayHex
+        return info.name ?: idDisplayNote()
     }
 
-    @Synchronized
     fun addNote(note: Note) {
         notes[note.idHex] = note
     }
 
+    fun removeNote(note: Note) {
+        notes.remove(note.idHex)
+    }
+
+    fun removeNote(noteHex: String) {
+        notes.remove(noteHex)
+    }
+
     fun updateChannelInfo(creator: User, channelInfo: ChannelCreateEvent.ChannelData, updatedAt: Long) {
         this.creator = creator
         this.info = channelInfo
         this.updatedMetadataAt = updatedAt
 
-        live.refresh()
+        live.invalidateData()
     }
 
     fun profilePicture(): String? {
@@ -47,25 +60,44 @@ class Channel(val id: ByteArray) {
     // Observers line up here.
     val live: ChannelLiveData = ChannelLiveData(this)
 
-    private fun refreshObservers() {
-        live.refresh()
+    fun pruneOldAndHiddenMessages(account: Account): Set<Note> {
+        val important = notes.values
+            .filter { it.author?.let { it1 -> account.isHidden(it1) } == false }
+            .sortedWith(compareBy({ it.createdAt() }, { it.idHex }))
+            .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.IO)
 
-class ChannelLiveData(val channel: Channel): LiveData<ChannelState>(ChannelState(channel)) {
-    fun refresh() {
-        postValue(ChannelState(channel))
+    fun invalidateData() {
+        bundler.invalidate() {
+            if (hasActiveObservers()) {
+                postValue(ChannelState(channel))
+            }
+        }
     }
 
     override fun onActive() {
         super.onActive()
-        NostrSingleEventDataSource.add(channel.idHex)
+        NostrSingleChannelDataSource.add(channel.idHex)
     }
 
     override fun onInactive() {
         super.onInactive()
-        NostrSingleEventDataSource.remove(channel.idHex)
+        NostrSingleChannelDataSource.remove(channel.idHex)
     }
 }
 

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", "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
+)

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

@@ -1,12 +1,13 @@
 package com.vitorpamplona.amethyst.model
 
+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
@@ -15,34 +16,104 @@ typealias NPubKey = String
 typealias NoteId = String
 
 fun NPubKey.toDisplayKey(): String {
-  return this.toShortenHex()
+    return this.toShortenHex()
 }
 
 fun NoteId.toDisplayId(): String {
-  return this.toShortenHex()
+    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)
+fun HexKey.hexToByteArray(): ByteArray {
+    return Hex.decode(this)
 }
 
 fun HexKey.toDisplayHexKey(): String {
-  return this.toShortenHex()
+    return this.toShortenHex()
 }
 
 fun decodePublicKey(key: String): ByteArray {
-  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)
-  }
-}
+    val parsed = Nip19.uriToRoute(key)
+    val pubKeyParsed = parsed?.hex?.hexToByteArray()
+
+    return if (key.startsWith("nsec")) {
+        Persona(privKey = key.bechToBytes()).pubKey
+    } else if (pubKeyParsed != null) {
+        pubKeyParsed
+    } else {
+        Hex.decode(key)
+    }
+}
+
+fun decodePublicKeyAsHexOrNull(key: String): HexKey? {
+    return try {
+        val parsed = Nip19.uriToRoute(key)
+        val pubKeyParsed = parsed?.hex
+
+        if (key.startsWith("nsec")) {
+            Persona(privKey = key.bechToBytes()).pubKey.toHexKey()
+        } else if (pubKeyParsed != null) {
+            pubKeyParsed
+        } else {
+            Hex.decode(key).toHexKey()
+        }
+    } catch (e: Exception) {
+        null
+    }
+}
+
+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
+}

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

@@ -1,43 +1,43 @@
 package com.vitorpamplona.amethyst.model
 
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.Stable
 import androidx.lifecycle.LiveData
-import com.vitorpamplona.amethyst.lnurl.LnInvoiceUtil
 import com.vitorpamplona.amethyst.service.NostrSingleEventDataSource
-import com.vitorpamplona.amethyst.service.model.LnZapEvent
-import com.vitorpamplona.amethyst.service.model.ReactionEvent
-import com.vitorpamplona.amethyst.service.model.RepostEvent
+import com.vitorpamplona.amethyst.service.checkNotInMainThread
+import com.vitorpamplona.amethyst.service.lnurl.LnInvoiceUtil
+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 kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
-import com.vitorpamplona.amethyst.service.relays.Relay
-import java.math.BigDecimal
 import java.util.Date
-import java.util.concurrent.atomic.AtomicBoolean
-import java.util.regex.Matcher
 import java.util.regex.Pattern
-import nostr.postr.events.Event
 
 val tagSearch = Pattern.compile("(?:\\s|\\A)\\#\\[([0-9]+)\\]")
 
-class Note(val idHex: String) {
-    // These fields are always available.
-    // They are immutable
-    val id = Hex.decode(idHex)
-    val idDisplayNote = id.toNote().toShortenHex()
+@Stable
+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()
+}
 
+@Stable
+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: List<Note>? = null
 
     // These fields are updated every time an event related to this note is received.
@@ -51,21 +51,39 @@ class Note(val idHex: String) {
         private set
     var zaps = mapOf<Note, Note?>()
         private set
+    var zapPayments = mapOf<Note, Note?>()
+        private set
 
     var relays = setOf<String>()
         private set
 
-    var channel: Channel? = null
+    var lastReactionsDownloadTime: Map<String, EOSETime> = emptyMap()
 
-    var lastReactionsDownloadTime: Long? = null
+    fun id() = Hex.decode(idHex)
+    open fun idNote() = id().toNote()
 
-    fun loadEvent(event: Event, author: User, mentions: List<User>, replyTo: List<Note>) {
+    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
+    }
+
+    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
 
-        live.invalidateData()
+        liveSet?.metadata?.invalidateData()
     }
 
     fun formattedDateTime(timestamp: Long): String {
@@ -73,56 +91,121 @@ 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 (note !in replies) {
             replies = replies + note
-            liveReplies.invalidateData()
+            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 removeZapPayment(note: Note) {
+        if (zapPayments[note] != null) {
+            zapPayments = zapPayments.minus(note)
+            liveSet?.zaps?.invalidateData()
+        } else if (zapPayments.containsValue(note)) {
+            val toRemove = zapPayments.filterValues { it == note }
+            zapPayments = zapPayments.minus(toRemove.keys)
+            liveSet?.zaps?.invalidateData()
         }
     }
 
     fun addBoost(note: Note) {
         if (note !in boosts) {
             boosts = boosts + note
-            liveBoosts.invalidateData()
+            liveSet?.boosts?.invalidateData()
         }
     }
 
+    @Synchronized
     fun addZap(zapRequest: Note, zap: Note?) {
+        checkNotInMainThread()
         if (zapRequest !in zaps.keys) {
             zaps = zaps + Pair(zapRequest, zap)
-            liveZaps.invalidateData()
+            liveSet?.zaps?.invalidateData()
         } else if (zapRequest in zaps.keys && zaps[zapRequest] == null) {
             zaps = zaps + Pair(zapRequest, zap)
-            liveZaps.invalidateData()
+            liveSet?.zaps?.invalidateData()
+        }
+    }
+
+    @Synchronized
+    fun addZapPayment(zapPaymentRequest: Note, zapPayment: Note?) {
+        checkNotInMainThread()
+        if (zapPaymentRequest !in zapPayments.keys) {
+            zapPayments = zapPayments + Pair(zapPaymentRequest, zapPayment)
+            liveSet?.zaps?.invalidateData()
+        } else if (zapPaymentRequest in zapPayments.keys && zapPayments[zapPaymentRequest] == null) {
+            zapPayments = zapPayments + Pair(zapPaymentRequest, zapPayment)
+            liveSet?.zaps?.invalidateData()
         }
     }
 
     fun addReaction(note: Note) {
         if (note !in reactions) {
             reactions = reactions + note
-            liveReactions.invalidateData()
+            liveSet?.reactions?.invalidateData()
         }
     }
 
@@ -131,84 +214,138 @@ class Note(val idHex: String) {
 
         if (author !in reports.keys) {
             reports = reports + Pair(author, setOf(note))
-            liveReports.invalidateData()
-        } else {
+            liveSet?.reports?.invalidateData()
+        } else if (reports[author]?.contains(note) == false) {
             reports = reports + Pair(author, (reports[author] ?: emptySet()) + note)
-            liveReports.invalidateData()
+            liveSet?.reports?.invalidateData()
         }
     }
 
     fun addRelay(relay: Relay) {
         if (relay.url !in relays) {
             relays = relays + relay.url
-            liveRelays.invalidateData()
+            liveSet?.relays?.invalidateData()
         }
     }
 
-    fun isZappedBy(user: User): Boolean {
+    fun isZappedBy(user: User, account: Account): Boolean {
         // Zaps who the requester was the user
-        return zaps.any { it.key.author == user }
+        return zaps.any {
+            it.key.author?.pubkeyHex == user.pubkeyHex || account.decryptZapContentAuthor(it.key)?.pubKey == user.pubkeyHex
+        } || zapPayments.any {
+            val zapResponseEvent = it.value?.event as? LnZapPaymentResponseEvent
+            val response = if (zapResponseEvent != null) {
+                account.decryptZapPaymentResponseEvent(zapResponseEvent)
+            } else {
+                null
+            }
+            response is PayInvoiceSuccessResponse && account.isNIP47Author(zapResponseEvent?.requestAuthor())
+        }
     }
 
     fun isReactedBy(user: User): Boolean {
-        return reactions.any { it.author == user }
+        return reactions.any { it.author?.pubkeyHex == user.pubkeyHex }
     }
 
     fun isBoostedBy(user: User): Boolean {
-        return boosts.any { it.author == user }
+        return boosts.any { it.author?.pubkeyHex == user.pubkeyHex }
     }
 
     fun reportsBy(user: User): Set<Note> {
         return reports[user] ?: emptySet()
     }
 
-    fun reportAuthorsBy(users: Set<User>): List<User> {
-        return reports.keys.filter { it in users }
+    fun reportAuthorsBy(users: Set<HexKey>): List<User> {
+        return reports.keys.filter { it.pubkeyHex in users }
     }
 
-    fun reportsBy(users: Set<User>): List<Note> {
+    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 }
+    fun zappedAmount(privKey: ByteArray?, walletServicePubkey: ByteArray?): BigDecimal {
+        // Regular Zap Receipts
+        val completedZaps = zaps.asSequence()
+            .mapNotNull { it.value?.event }
             .filterIsInstance<LnZapEvent>()
+            .filter { it.amount != null }
+            .associate {
+                it.lnInvoice() to it.amount
+            }
+            .toMap()
+
+        val completedPayments = if (privKey != null && walletServicePubkey != null) {
+            // Payments confirmed by the User's Wallet
+            zapPayments
+                .asSequence()
+                .filter {
+                    val response = (it.value?.event as? LnZapPaymentResponseEvent)?.response(privKey, walletServicePubkey)
+                    response is PayInvoiceSuccessResponse
+                }
+                .associate {
+                    val lnInvoice = (it.key.event as? LnZapPaymentRequestEvent)?.lnInvoice(privKey, walletServicePubkey)
+                    val amount = try {
+                        if (lnInvoice == null) {
+                            null
+                        } else {
+                            LnInvoiceUtil.getAmountInSats(lnInvoice)
+                        }
+                    } catch (e: java.lang.Exception) {
+                        null
+                    }
+                    lnInvoice to amount
+                }
+                .toMap()
+        } else {
+            emptyMap()
+        }
+
+        return (completedZaps + completedPayments).values.filterNotNull().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 {
-                it.amount
-            }.sumOf { it }
+                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
+        val dayAgo = Date().time / 1000 - 24 * 60 * 60
         return reports.isNotEmpty() ||
-          (author?.reports?.values?.filter {
-              it.firstOrNull { it.event?.createdAt ?: 0 > dayAgo } != null
-          }?.isNotEmpty() ?: false)
-    }
-
-    fun directlyCiteUsers(): Set<User> {
-        val matcher = tagSearch.matcher(event?.content ?: "")
-        val returningList = mutableSetOf<User>()
-        while (matcher.find()) {
-            try {
-                val tag = matcher.group(1)?.let { event?.tags?.get(it.toInt()) }
-                if (tag != null && tag[0] == "p") {
-                    returningList.add(LocalCache.getOrCreateUser(tag[1]))
-                }
-            } catch (e: Exception) {
-
-            }
-        }
-        return returningList
-    }
-
-    fun directlyCites(userProfile: User): Boolean {
-        return author == userProfile
-          || (userProfile in directlyCiteUsers())
-          || (event is ReactionEvent && replyTo?.lastOrNull()?.directlyCites(userProfile) == true)
-          || (event is RepostEvent && replyTo?.lastOrNull()?.directlyCites(userProfile) == true)
+            (
+                author?.reports?.values?.any {
+                    it.firstOrNull { (it.createdAt() ?: 0) > dayAgo } != null
+                } ?: false
+                )
     }
 
     fun isNewThread(): Boolean {
@@ -220,56 +357,90 @@ class Note(val idHex: String) {
     }
 
     fun hasReacted(loggedIn: User, content: String): Boolean {
-        return reactions.firstOrNull { it.author == loggedIn && it.event?.content == content } != null
+        return reactedBy(loggedIn, content).isNotEmpty()
     }
 
-    fun hasBoosted(loggedIn: User): Boolean {
+    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.event?.createdAt ?: 0) > currentTime - (60 * 5)} != null // 5 minute protection
+        return boosts.firstOrNull { it.author == loggedIn && (it.createdAt() ?: 0) > currentTime - (60 * 5) } != null // 5 minute protection
     }
 
-    // Observers line up here.
-    val live: NoteLiveData = NoteLiveData(this)
+    fun boostedBy(loggedIn: User): List<Note> {
+        return boosts.filter { it.author == loggedIn }
+    }
 
-    val liveReactions: NoteLiveData = NoteLiveData(this)
-    val liveBoosts: NoteLiveData = NoteLiveData(this)
-    val liveReplies: NoteLiveData = NoteLiveData(this)
-    val liveReports: NoteLiveData = NoteLiveData(this)
-    val liveRelays: NoteLiveData = NoteLiveData(this)
-    val liveZaps: NoteLiveData = NoteLiveData(this)
-}
+    var liveSet: NoteLiveSet? = null
 
-class NoteLiveData(val note: Note): LiveData<NoteState>(NoteState(note)) {
-    // Refreshes observers in batches.
-    var handlerWaiting = AtomicBoolean()
+    fun live(): NoteLiveSet {
+        if (liveSet == null) {
+            liveSet = NoteLiveSet(this)
+        }
+        return liveSet!!
+    }
 
-    @Synchronized
-    fun invalidateData() {
-        if (!hasActiveObservers()) return
-        if (handlerWaiting.getAndSet(true)) return
-
-        handlerWaiting.set(true)
-        val scope = CoroutineScope(Job() + Dispatchers.Main)
-        scope.launch {
-            delay(100)
-            refresh()
-            handlerWaiting.set(false)
+    fun clearLive() {
+        if (liveSet != null && liveSet?.isInUse() == false) {
+            liveSet = null
         }
     }
+}
 
-    fun refresh() {
-        postValue(NoteState(note))
+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.IO)
+
+    fun invalidateData() {
+        bundler.invalidate() {
+            // if (hasObservers()) {
+            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)
+        }
     }
 }
 
+@Immutable
 class NoteState(val note: Note)

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

@@ -1,13 +1,16 @@
 package com.vitorpamplona.amethyst.model
 
+import androidx.compose.runtime.Immutable
 import com.vitorpamplona.amethyst.service.relays.FeedType
 
+@Immutable
 data class RelaySetupInfo(
     val url: String,
     val read: Boolean,
     val write: Boolean,
     val errorCount: Int = 0,
-    val downloadCount: Int = 0,
-    val uploadCount: Int = 0,
+    val downloadCountInBytes: Int = 0,
+    val uploadCountInBytes: Int = 0,
+    val spamCount: Int = 0,
     val feedTypes: Set<FeedType>
-)
+)

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

@@ -0,0 +1,85 @@
+package com.vitorpamplona.amethyst.model
+
+import com.vitorpamplona.amethyst.service.checkNotInMainThread
+import com.vitorpamplona.amethyst.service.model.ATag
+import kotlin.time.ExperimentalTime
+import kotlin.time.measureTimedValue
+
+class ThreadAssembler {
+
+    private 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> {
+        checkNotInMainThread()
+
+        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)
+            }
+        }
+    }
+}

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

@@ -1,73 +1,42 @@
 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
+import com.vitorpamplona.amethyst.service.checkNotInMainThread
+import com.vitorpamplona.amethyst.service.previews.BahaUrlPreview
+import com.vitorpamplona.amethyst.service.previews.IUrlPreviewCallback
+import com.vitorpamplona.amethyst.service.previews.UrlInfoItem
 
 object UrlCachedPreviewer {
-  var cache = mapOf<String, UrlInfoItem>()
-    private set
-  var failures = mapOf<String, Throwable>()
-    private set
+    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
-    }
+    fun previewInfo(url: String, callback: IUrlPreviewCallback? = null) {
+        checkNotInMainThread()
 
-    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)
+        cache[url]?.let {
+            callback?.onComplete(it)
+            return
         }
 
-        override fun onFailed(throwable: Throwable) {
-          failures = failures + Pair(url, throwable)
-          callback?.onFailed(throwable)
+        failures[url]?.let {
+            callback?.onFailed(it)
+            return
         }
-      }).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()
-  }
+        BahaUrlPreview(
+            url,
+            object : IUrlPreviewCallback {
+                override fun onComplete(urlInfo: UrlInfoItem) {
+                    cache = cache + Pair(url, urlInfo)
+                    callback?.onComplete(urlInfo)
+                }
 
-  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 if (isValidURL(removedParamsFromUrl)) {
-          previewInfo(it)
-        } else {
-          previewInfo("https://${it}")
-        }
-      }
+                override fun onFailed(throwable: Throwable) {
+                    failures = failures + Pair(url, throwable)
+                    callback?.onFailed(throwable)
+                }
+            }
+        ).fetchUrlPreview()
     }
-  }
-}
+}

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

@@ -1,182 +1,160 @@
 package com.vitorpamplona.amethyst.model
 
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.Stable
 import androidx.lifecycle.LiveData
-import com.vitorpamplona.amethyst.lnurl.LnInvoiceUtil
 import com.vitorpamplona.amethyst.service.NostrSingleUserDataSource
+import com.vitorpamplona.amethyst.service.checkNotInMainThread
+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.Client
-import com.vitorpamplona.amethyst.service.relays.FeedType
+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 java.math.BigDecimal
-import java.util.Collections
-import java.util.concurrent.ConcurrentHashMap
-import java.util.concurrent.atomic.AtomicBoolean
-import kotlin.time.ExperimentalTime
-import kotlin.time.measureTimedValue
-import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
-import nostr.postr.events.ContactListEvent
-import nostr.postr.events.Event
-import nostr.postr.events.MetadataEvent
+import nostr.postr.Bech32
 import nostr.postr.toNpub
+import java.math.BigDecimal
+import java.util.regex.Pattern
 
+val lnurlpPattern = Pattern.compile("(?i:http|https):\\/\\/((.+)\\/)*\\.well-known\\/lnurlp\\/(.*)")
+
+@Stable
 class User(val pubkeyHex: String) {
-    val pubkey = Hex.decode(pubkeyHex)
-    val pubkeyDisplayHex = pubkey.toNpub().toShortenHex()
-
-    var info = UserMetadata()
-
-    var updatedMetadataAt: Long = 0;
-    var updatedFollowsAt: Long = 0;
+    var info: UserMetadata? = null
 
     var latestContactList: ContactListEvent? = null
-    var latestMetadata: MetadataEvent? = null
-
-    var follows = setOf<User>()
-        private set
-    var followers = setOf<User>()
-        private set
+    var latestBookmarkList: BookmarkListEvent? = null
 
     var notes = setOf<Note>()
         private set
-    var taggedPosts = setOf<Note>()
-        private set
 
     var reports = mapOf<User, Set<Note>>()
         private set
 
-    var zaps = mapOf<Note, Note?>()
-        private set
+    var latestEOSEs: Map<String, EOSETime> = emptyMap()
 
-    var relays: Map<String, ContactListEvent.ReadWrite>? = null
+    var zaps = mapOf<Note, Note?>()
         private set
 
     var relaysBeingUsed = mapOf<String, RelayInfo>()
         private set
 
-    var messages = mapOf<User, Set<Note>>()
+    var privateChatrooms = mapOf<User, Chatroom>()
         private set
 
-    var latestMetadataRequestEOSE: Long? = null
-    var latestReportRequestEOSE: Long? = null
+    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 nip05(): String? {
+        return info?.nip05?.ifBlank { null }
     }
 
     fun profilePicture(): String? {
-        if (info.picture.isNullOrBlank()) info.picture = null
-        return info.picture
+        if (info?.picture.isNullOrBlank()) info?.picture = null
+        return info?.picture
     }
 
-    fun follow(user: User, followedAt: Long) {
-        follows = follows + user
-        user.followers = user.followers + this
+    fun updateBookmark(event: BookmarkListEvent) {
+        if (event.id == latestBookmarkList?.id) return
 
-        liveFollows.invalidateData()
-        user.liveFollows.invalidateData()
-
-        updateSubscribers {
-            it.onFollowsChange()
-        }
-
-        user.updateSubscribers {
-            it.onFollowsChange()
-        }
-    }
-    fun unfollow(user: User) {
-        follows = follows - user
-        user.followers = user.followers - this
-
-        liveFollows.invalidateData()
-        user.liveFollows.invalidateData()
-
-        updateSubscribers {
-            it.onFollowsChange()
-        }
-
-        user.updateSubscribers {
-            it.onFollowsChange()
-        }
+        latestBookmarkList = event
+        liveSet?.bookmarks?.invalidateData()
     }
 
-    fun follow(users: Set<User>, followedAt: Long) {
-        follows = follows + users
-        users.forEach {
-            it.followers = it.followers + this
-            it.liveFollows.invalidateData()
-            it.updateSubscribers {
-                it.onFollowsChange()
-            }
+    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()
         }
 
-        liveFollows.invalidateData()
-        updateSubscribers {
-            it.onFollowsChange()
-        }
-    }
-    fun unfollow(users: Set<User>) {
-        follows = follows - users
-        users.forEach {
-            it.followers = it.followers - this
-            it.liveFollows.invalidateData()
-            it.updateSubscribers {
-                it.onFollowsChange()
-            }
-        }
-        liveFollows.invalidateData()
-        updateSubscribers {
-            it.onFollowsChange()
-        }
-    }
-
-    fun addTaggedPost(note: Note) {
-        if (note !in taggedPosts) {
-            taggedPosts = taggedPosts + note
-            updateSubscribers { it.onNewTaggedPosts() }
-        }
+        liveSet?.relays?.invalidateData()
     }
 
     fun addNote(note: Note) {
         if (note !in notes) {
             notes = notes + note
-            updateSubscribers { it.onNewNotes() }
+            // 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))
-            liveReports.invalidateData()
-        } else {
+            liveSet?.reports?.invalidateData()
+        } else if (reports[author]?.contains(note) == false) {
             reports = reports + Pair(author, (reports[author] ?: emptySet()) + note)
-            liveReports.invalidateData()
+            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)
-            liveZaps.invalidateData()
+            liveSet?.zaps?.invalidateData()
         } else if (zapRequest in zaps.keys && zaps[zapRequest] == null) {
             zaps = zaps + Pair(zapRequest, zap)
-            liveZaps.invalidateData()
+            liveSet?.zaps?.invalidateData()
         }
     }
 
@@ -192,41 +170,54 @@ class User(val pubkeyHex: String) {
         return reports[user] ?: emptySet()
     }
 
-    fun reportAuthorsBy(users: Set<User>): List<User> {
-        return reports.keys.filter { it in users }
+    fun reportAuthorsBy(users: Set<HexKey>): List<User> {
+        return reports.keys.filter { it.pubkeyHex in users }
     }
 
-    fun reportsBy(users: Set<User>): List<Note> {
+    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 getOrCreateChannel(user: User): Set<Note> {
-        return messages[user] ?: run {
-            val channel = setOf<Note>()
-            messages = messages + Pair(user, channel)
-            channel
+    private fun getOrCreatePrivateChatroom(user: User): Chatroom {
+        checkNotInMainThread()
+
+        return privateChatrooms[user] ?: run {
+            val privateChatroom = Chatroom(setOf<Note>())
+            privateChatrooms = privateChatrooms + Pair(user, privateChatroom)
+            privateChatroom
         }
     }
 
+    @Synchronized
     fun addMessage(user: User, msg: Note) {
-        val channel = getOrCreateChannel(user)
-        if (msg !in channel) {
-            messages = messages + Pair(user, channel + msg)
-            liveMessages.invalidateData()
-            updateSubscribers { it.onNewMessage() }
+        checkNotInMainThread()
+
+        val privateChatroom = getOrCreatePrivateChatroom(user)
+        if (msg !in privateChatroom.roomMessages) {
+            privateChatroom.roomMessages = privateChatroom.roomMessages + msg
+            liveSet?.messages?.invalidateData()
         }
     }
 
-    data class RelayInfo (
-        val url: String,
-        var lastEvent: Long,
-        var counter: Long
-    )
+    @Synchronized
+    fun removeMessage(user: User, msg: Note) {
+        checkNotInMainThread()
 
-    fun addRelay(relay: Relay, eventTime: Long) {
+        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))
@@ -237,105 +228,150 @@ class User(val pubkeyHex: String) {
             here.counter++
         }
 
-        updateSubscribers { it.onNewRelayInfo() }
-        liveRelayInfo.invalidateData()
-    }
-    
-    fun updateFollows(newFollows: Set<User>, updateAt: Long) {
-        val toBeAdded = newFollows - follows
-        val toBeRemoved = follows - newFollows
-
-        follow(toBeAdded, updateAt)
-        unfollow(toBeRemoved)
-
-        updatedFollowsAt = updateAt
+        liveSet?.relayInfo?.invalidateData()
     }
 
-    data class RelayMetadata(val read: Boolean, val write: Boolean, val activeTypes: Set<FeedType>)
+    fun updateUserInfo(newUserInfo: UserMetadata, latestMetadata: MetadataEvent) {
+        info = newUserInfo
+        info?.latestMetadata = latestMetadata
+        info?.updatedMetadataAt = latestMetadata.createdAt
 
-    fun updateRelays(relayUse: Map<String, ContactListEvent.ReadWrite>) {
-        if (relays != relayUse) {
-            relays = relayUse
-            listeners.forEach {
-                it.onRelayChange()
+        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.
             }
         }
 
-        liveRelays.invalidateData()
-    }
-
-    fun updateUserInfo(newUserInfo: UserMetadata, updateAt: Long) {
-        info = newUserInfo
-        updatedMetadataAt = updateAt
-
-        liveMetadata.invalidateData()
+        liveSet?.metadata?.invalidateData()
     }
 
     fun isFollowing(user: User): Boolean {
-        return follows.contains(user)
+        return latestContactList?.isTaggedUser(user.pubkeyHex) ?: false
+    }
+
+    fun isFollowingHashtag(tag: String): Boolean {
+        return latestContactList?.isTaggedHash(tag) ?: 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 isFollowingCached(userHex: String): Boolean {
+        return latestContactList?.verifiedFollowKeySet?.let {
+            return userHex in it
+        } ?: false
+    }
+
+    fun transientFollowCount(): Int? {
+        return latestContactList?.unverifiedFollowKeySet()?.size
+    }
+
+    suspend 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
+    }
+
+    suspend fun cachedFollowerCount(): Int {
+        return LocalCache.users.values.count { it.latestContactList?.isTaggedUser(pubkeyHex) ?: false }
     }
 
     fun hasSentMessagesTo(user: User?): Boolean {
-        val messagesToUser = messages[user] ?: return false
+        val messagesToUser = privateChatrooms[user] ?: return false
 
-        return messagesToUser.firstOrNull { this == it.author } != null
+        return messagesToUser.roomMessages.any { this.pubkeyHex == it.author?.pubkeyHex }
     }
 
     fun hasReport(loggedIn: User, type: ReportEvent.ReportType): Boolean {
         return reports[loggedIn]?.firstOrNull() {
-              it.event is ReportEvent && (it.event as ReportEvent).reportType.contains(type)
+            it.event is ReportEvent && (it.event as ReportEvent).reportedAuthor().any { it.reportType == type }
         } != null
     }
 
-    // Model Observers
-    private var listeners = setOf<Listener>()
-
-    fun subscribe(listener: Listener) {
-        listeners = listeners.plus(listener)
+    fun anyNameStartsWith(username: String): Boolean {
+        return info?.anyNameStartsWith(username) ?: false
     }
 
-    fun unsubscribe(listener: Listener) {
-        listeners = listeners.minus(listener)
+    var liveSet: UserLiveSet? = null
+
+    fun live(): UserLiveSet {
+        if (liveSet == null) {
+            liveSet = UserLiveSet(this)
+        }
+        return liveSet!!
     }
 
-    abstract class Listener {
-        open fun onRelayChange() = Unit
-        open fun onFollowsChange() = Unit
-        open fun onNewTaggedPosts() = Unit
-        open fun onNewNotes() = Unit
-        open fun onNewMessage() = Unit
-        open fun onNewRelayInfo() = Unit
-        open fun onNewReports() = Unit
-    }
-
-    // Refreshes observers in batches.
-    var modelHandlerWaiting = AtomicBoolean()
-
-    @Synchronized
-    fun updateSubscribers(on: (Listener) -> Unit) {
-        if (modelHandlerWaiting.getAndSet(true)) return
-
-        modelHandlerWaiting.set(true)
-        val scope = CoroutineScope(Job() + Dispatchers.Default)
-        scope.launch {
-            delay(100)
-            listeners.forEach {
-                on(it)
-            }
-            modelHandlerWaiting.set(false)
+    fun clearLive() {
+        if (liveSet != null && liveSet?.isInUse() == false) {
+            liveSet = null
         }
     }
-
-    // UI Observers line up here.
-    val liveFollows: UserLiveData = UserLiveData(this)
-    val liveReports: UserLiveData = UserLiveData(this)
-    val liveMessages: UserLiveData = UserLiveData(this)
-    val liveRelays: UserLiveData = UserLiveData(this)
-    val liveRelayInfo: UserLiveData = UserLiveData(this)
-    val liveMetadata: UserLiveData = UserLiveData(this)
-    val liveZaps: UserLiveData = UserLiveData(this)
 }
 
+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()
+    }
+}
+
+@Immutable
+data class RelayInfo(
+    val url: String,
+    var lastEvent: Long,
+    var counter: Long
+)
+
+data class Chatroom(var roomMessages: Set<Note>)
+
+@Stable
 class UserMetadata {
     var name: String? = null
     var username: String? = null
@@ -345,7 +381,11 @@ class UserMetadata {
     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
@@ -355,44 +395,45 @@ class UserMetadata {
     var main_relay: String? = null
     var twitter: String? = null
 
+    var updatedMetadataAt: Long = 0
+    var latestMetadata: MetadataEvent? = null
+
+    fun anyName(): String? {
+        return display_name ?: displayName ?: name ?: username
+    }
+
     fun anyNameStartsWith(prefix: String): Boolean {
         return listOfNotNull(name, username, display_name, displayName, nip05, lud06, lud16)
-              .filter { it.startsWith(prefix, true) }.isNotEmpty()
+            .any { it.contains(prefix, true) }
+    }
+
+    fun lnAddress(): String? {
+        return (lud16?.trim() ?: lud06?.trim())?.ifBlank { null }
     }
 }
 
-class UserLiveData(val user: User): LiveData<UserState>(UserState(user)) {
-
+class UserLiveData(val user: User) : LiveData<UserState>(UserState(user)) {
     // Refreshes observers in batches.
-    var handlerWaiting = AtomicBoolean()
+    private val bundler = BundledUpdate(300, Dispatchers.IO)
 
-    @Synchronized
     fun invalidateData() {
-        if (!hasActiveObservers()) return
-        if (handlerWaiting.getAndSet(true)) return
-
-        handlerWaiting.set(true)
-        val scope = CoroutineScope(Job() + Dispatchers.Main)
-        scope.launch {
-            delay(100)
-            refresh()
-            handlerWaiting.set(false)
+        bundler.invalidate() {
+            if (hasActiveObservers()) {
+                postValue(UserState(user))
+            }
         }
     }
 
-    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)
     }
 }
 
+@Immutable
 class UserState(val user: User)

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

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

@@ -0,0 +1,66 @@
+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 {
+        checkNotInMainThread()
+
+        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)
+            .build()
+    }
+}

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

@@ -0,0 +1,89 @@
+package com.vitorpamplona.amethyst.service
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.util.Log
+import com.vitorpamplona.amethyst.model.toHexKey
+import com.vitorpamplona.amethyst.ui.actions.ImageDownloader
+import io.trbl.blurhash.BlurHash
+import java.security.MessageDigest
+import kotlin.math.roundToInt
+
+class FileHeader(
+    val url: String,
+    val mimeType: String?,
+    val hash: String,
+    val size: Int,
+    val dim: String?,
+    val blurHash: String?,
+    val description: String? = null
+) {
+    companion object {
+        suspend fun prepare(fileUrl: String, mimeType: String?, description: String?, onReady: (FileHeader) -> Unit, onError: () -> Unit) {
+            try {
+                val imageData: ByteArray? = ImageDownloader().waitAndGetImage(fileUrl)
+
+                if (imageData != null) {
+                    prepare(imageData, fileUrl, mimeType, description, onReady, onError)
+                } else {
+                    onError()
+                }
+            } catch (e: Exception) {
+                Log.e("ImageDownload", "Couldn't download image from server: ${e.message}")
+                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, dim) = 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 dim = "${mBitmap.width}x${mBitmap.height}"
+
+                    val aspectRatio = (mBitmap.width).toFloat() / (mBitmap.height).toFloat()
+
+                    if (aspectRatio > 1) {
+                        Pair(BlurHash.encode(intArray, mBitmap.width, mBitmap.height, 9, (9 * (1 / aspectRatio)).roundToInt()), dim)
+                    } else if (aspectRatio < 1) {
+                        Pair(BlurHash.encode(intArray, mBitmap.width, mBitmap.height, (9 * aspectRatio).roundToInt(), 9), dim)
+                    } else {
+                        Pair(BlurHash.encode(intArray, mBitmap.width, mBitmap.height, 4, 4), dim)
+                    }
+                } else {
+                    Pair(null, null)
+                }
+
+                onReady(FileHeader(fileUrl, mimeType, hash, size, dim, blurHash, description))
+            } catch (e: Exception) {
+                Log.e("ImageDownload", "Couldn't convert image in to File Header: ${e.message}")
+                onError()
+            }
+        }
+    }
+}

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

@@ -0,0 +1,34 @@
+package com.vitorpamplona.amethyst.service
+
+import com.vitorpamplona.amethyst.model.Account
+import okhttp3.OkHttpClient
+import java.net.InetSocketAddress
+import java.net.Proxy
+import java.time.Duration
+
+object HttpClient {
+    private var proxy: Proxy? = null
+
+    fun start(account: Account?) {
+        this.proxy = account?.proxy
+    }
+
+    fun getHttpClient(): OkHttpClient {
+        val seconds = if (proxy != null) 20L else 10L
+        val duration = Duration.ofSeconds(seconds)
+        return OkHttpClient.Builder()
+            .proxy(proxy)
+            .readTimeout(duration)
+            .connectTimeout(duration)
+            .writeTimeout(duration)
+            .build()
+    }
+
+    fun getProxy(): Proxy? {
+        return proxy
+    }
+
+    fun initProxy(useProxy: Boolean, hostname: String, port: Int): Proxy? {
+        return if (useProxy) Proxy(Proxy.Type.SOCKS, InetSocketAddress(hostname, port)) else null
+    }
+}

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

@@ -0,0 +1,12 @@
+package com.vitorpamplona.amethyst.service
+
+import android.os.Looper
+import com.vitorpamplona.amethyst.BuildConfig
+
+fun checkNotInMainThread() {
+    if (BuildConfig.DEBUG && isMainThread()) throw OnMainThreadException("It should not be in the MainThread")
+}
+
+fun isMainThread() = Looper.myLooper() == Looper.getMainLooper()
+
+class OnMainThreadException(str: String) : RuntimeException(str)

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

@@ -0,0 +1,32 @@
+package com.vitorpamplona.amethyst.service
+
+import java.util.regex.Pattern
+
+class NIP30Parser {
+    val customEmojiPattern: Pattern = Pattern.compile("\\:([A-Za-z0-9_\\-]+)\\:", Pattern.CASE_INSENSITIVE)
+
+    fun buildArray(input: String): List<String> {
+        val matcher = customEmojiPattern.matcher(input)
+        val list = mutableListOf<String>()
+        while (matcher.find()) {
+            list.add(matcher.group())
+        }
+
+        if (list.isEmpty()) {
+            return listOf(input)
+        }
+
+        val regularChars = input.split(customEmojiPattern.toRegex())
+
+        var finalList = mutableListOf<String>()
+        var index = 0
+        for (e in regularChars) {
+            finalList.add(e)
+            if (index < list.size) {
+                finalList.add(list[index])
+            }
+            index++
+        }
+        return finalList
+    }
+}

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

@@ -0,0 +1,106 @@
+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.Request
+import okhttp3.Response
+
+class Nip05Verifier() {
+    val client = HttpClient.getHttpClient()
+
+    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) {
+        // checkNotInMainThread()
+
+        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) {
+        // check fails on tests
+        // checkNotInMainThread()
+
+        val mapper = jacksonObjectMapper()
+
+        fetchNip05Json(
+            nip05,
+            onSuccess = {
+                // NIP05 usernames are case insensitive, but JSON properties are not
+                // converts the json to lowercase and then tries to access the username via a
+                // lowercase version of the username.
+                val nip05url = try {
+                    mapper.readTree(it.lowercase())
+                } catch (t: Throwable) {
+                    onError("Error Parsing JSON from Lightning Address. Check the user's lightning setup")
+                    null
+                }
+
+                val user = nip05.split("@")[0].lowercase()
+
+                val hexKey = nip05url?.get("names")?.get(user)?.asText()
+
+                if (hexKey == null) {
+                    onError("Username not found in the NIP05 JSON")
+                } else {
+                    onSuccess(hexKey)
+                }
+            },
+            onError = onError
+        )
+    }
+}

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

@@ -1,63 +0,0 @@
-package com.vitorpamplona.amethyst.service
-
-import com.vitorpamplona.amethyst.model.toHexKey
-import nostr.postr.bechToBytes
-
-class Nip19 {
-
-  enum class Type {
-    USER, NOTE
-  }
-  data class Return(val type: Type, val hex: String)
-
-  fun uriToRoute(uri: String?): Return? {
-    try {
-      val key = uri?.removePrefix("nostr:")
-
-      if (key != null) {
-        val bytes = key.bechToBytes()
-        if (key.startsWith("npub")) {
-          return Return(Type.USER, bytes.toHexKey())
-        }
-        if (key.startsWith("note")) {
-          return Return(Type.NOTE, bytes.toHexKey())
-        }
-        if (key.startsWith("nprofile")) {
-          val tlv = parseTLV(bytes)
-          val hex = tlv.get(0)?.get(0)?.toHexKey()
-          if (hex != null)
-            return Return(Type.USER, hex)
-        }
-        if (key.startsWith("nevent")) {
-          val tlv = parseTLV(bytes)
-          val hex = tlv.get(0)?.get(0)?.toHexKey()
-          if (hex != null)
-            return Return(Type.USER, hex)
-        }
-      }
-    } catch (e: Throwable) {
-      println("Trying to Decode NIP19: ${uri}")
-      e.printStackTrace()
-    }
-
-    return null
-  }
-
-  fun parseTLV(data: ByteArray): Map<Byte, List<ByteArray>> {
-    var result = mutableMapOf<Byte, MutableList<ByteArray>>()
-    var rest = data
-    while (rest.isNotEmpty()) {
-      val t = rest[0]
-      val l = rest[1]
-      val v = rest.sliceArray(IntRange(2, (2 + l) - 1))
-      rest = rest.sliceArray(IntRange(2 + l, rest.size-1))
-      if (v.size < l) continue
-
-      if (!result.containsKey(t)) {
-        result.put(t, mutableListOf())
-      }
-      result.get(t)?.add(v)
-    }
-    return result
-  }
-}

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

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

@@ -1,84 +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.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 com.vitorpamplona.amethyst.service.relays.FeedType
+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
-import nostr.postr.JsonFilter
-import nostr.postr.events.ContactListEvent
-import nostr.postr.events.MetadataEvent
-import nostr.postr.events.TextNoteEvent
 
-object NostrAccountDataSource: NostrDataSource<Note>("AccountData") {
-  lateinit var account: Account
+object NostrAccountDataSource : NostrDataSource("AccountData") {
+    lateinit var account: Account
 
-  fun createAccountContactListFilter(): TypedFilter {
-    return TypedFilter(
-      types = FeedType.values().toSet(),
-      filter = JsonFilter(
-        kinds = listOf(ContactListEvent.kind),
-        authors = listOf(account.userProfile().pubkeyHex),
-        limit = 1
-      )
+    val latestEOSEs = EOSEAccount()
+
+    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, PeopleListEvent.kind),
+                authors = listOf(account.userProfile().pubkeyHex),
+                limit = 100
+            )
+        )
+    }
+
+    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()]?.followList?.get(account.defaultNotificationFollowList)?.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 = 4000,
+            since = latestEOSEs.users[account.userProfile()]?.followList?.get(account.defaultNotificationFollowList)?.relayList
+        )
     )
-  }
 
-  fun createAccountMetadataFilter(): TypedFilter {
-    return TypedFilter(
-      types = FeedType.values().toSet(),
-      filter = JsonFilter(
-        kinds = listOf(MetadataEvent.kind),
-        authors = listOf(account.userProfile().pubkeyHex),
-        limit = 1
-      )
-    )
-  }
+    val accountChannel = requestNewChannel { time, relayUrl ->
+        latestEOSEs.addOrUpdate(account.userProfile(), account.defaultNotificationFollowList, relayUrl, time)
+    }
 
-  fun createAccountReportsFilter(): TypedFilter {
-    return TypedFilter(
-      types = FeedType.values().toSet(),
-      filter = JsonFilter(
-        kinds = listOf(ReportEvent.kind),
-        authors = listOf(account.userProfile().pubkeyHex)
-      )
-    )
-  }
+    override fun updateChannelFilters() {
+        // gets everthing about the user logged in
+        accountChannel.typedFilters = listOf(
+            createAccountMetadataFilter(),
+            createAccountContactListFilter(),
+            createNotificationFilter(),
+            createAccountReportsFilter(),
+            createAccountAcceptedAwardsFilter(),
+            createAccountBookmarkListFilter()
+        ).ifEmpty { null }
+    }
 
-  fun createNotificationFilter() = TypedFilter(
-    types = FeedType.values().toSet(),
-    filter = JsonFilter(
-      kinds = listOf(
-        TextNoteEvent.kind, ReactionEvent.kind, RepostEvent.kind, ReportEvent.kind, LnZapEvent.kind, ChannelMessageEvent.kind
-      ),
-      tags = mapOf("p" to listOf(account.userProfile().pubkeyHex)),
-      limit = 200
-    )
-  )
+    override fun auth(relay: Relay, challenge: String) {
+        super.auth(relay, challenge)
 
-  val accountChannel = requestNewChannel()
+        if (this::account.isInitialized) {
+            val event = account.createAuthEvent(relay, challenge)
 
-  override fun feed(): List<Note> {
-    val user = account.userProfile()
-
-    return LocalCache.notes.values
-      .filter { (it.event is TextNoteEvent || it.event is RepostEvent) && it.author in user.follows }
-      .sortedBy { it.event?.createdAt }
-      .reversed()
-  }
-
-  override fun updateChannelFilters() {
-    // gets everthing about the user logged in
-    accountChannel.typedFilters = listOf(
-      createAccountMetadataFilter(),
-      createAccountContactListFilter(),
-      createNotificationFilter(),
-      createAccountReportsFilter()
-    ).ifEmpty { null }
-  }
-}
+            if (event != null) {
+                Client.send(
+                    event,
+                    relay.url
+                )
+            }
+        }
+    }
+}

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

@@ -1,44 +1,66 @@
 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.Channel
 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
-import nostr.postr.JsonFilter
 
-object NostrChannelDataSource: NostrDataSource<Note>("ChatroomFeed") {
-  lateinit var account: Account
-  var channel: com.vitorpamplona.amethyst.model.Channel? = null
+object NostrChannelDataSource : NostrDataSource("ChatroomFeed") {
+    var account: Account? = null
+    var channel: Channel? = null
 
-  fun loadMessagesBetween(channelId: String) {
-    channel = LocalCache.getOrCreateChannel(channelId)
-    resetFilters()
-  }
-
-  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
-        )
-      )
+    fun loadMessagesBetween(account: Account, channel: Channel) {
+        this.account = account
+        this.channel = channel
+        resetFilters()
     }
-    return null
-  }
 
-  val messagesChannel = requestNewChannel()
+    fun clear() {
+        account = null
+        channel = null
+    }
 
-  // returns the last Note of each user.
-  override fun feed(): List<Note> {
-    return channel?.notes?.values?.filter { account.isAcceptable(it) }?.sortedBy { it.event?.createdAt }?.reversed() ?: emptyList()
-  }
+    fun createMessagesByMeToChannelFilter(): TypedFilter? {
+        val myAccount = account ?: return null
 
-  override fun updateChannelFilters() {
-    messagesChannel.typedFilters = listOfNotNull(createMessagesToChannelFilter()).ifEmpty { 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 }
+    }
+}

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

@@ -1,67 +0,0 @@
-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.User
-import com.vitorpamplona.amethyst.service.relays.FeedType
-import com.vitorpamplona.amethyst.service.relays.TypedFilter
-import nostr.postr.JsonFilter
-import nostr.postr.events.PrivateDmEvent
-
-object NostrChatRoomDataSource: NostrDataSource<Note>("ChatroomFeed") {
-  lateinit var account: Account
-  var withUser: User? = null
-
-  fun loadMessagesBetween(accountIn: Account, userId: String) {
-    account = accountIn
-    withUser = LocalCache.users[userId]
-  }
-
-  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.PUBLIC_CHATS),
-        filter = JsonFilter(
-          kinds = listOf(PrivateDmEvent.kind),
-          authors = listOf(account.userProfile().pubkeyHex),
-          tags = mapOf("p" to listOf(myPeer.pubkeyHex))
-        )
-      )
-    } else {
-      null
-    }
-  }
-
-  val inandoutChannel = requestNewChannel()
-
-  // returns the last Note of each user.
-  override fun feed(): List<Note> {
-    val messages = account.userProfile().messages[withUser] ?: return emptyList()
-
-    return messages.filter { account.isAcceptable(it) }.sortedBy { it.event?.createdAt }.reversed()
-  }
-
-  override fun updateChannelFilters() {
-    inandoutChannel.typedFilters = listOfNotNull(createMessagesToMeFilter(), createMessagesFromMeFilter()).ifEmpty { null }
-  }
-}

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

@@ -0,0 +1,59 @@
+package com.vitorpamplona.amethyst.service
+
+import com.vitorpamplona.amethyst.model.Account
+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, user: User) {
+        account = accountIn
+        withUser = user
+        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 }
+    }
+}

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

@@ -1,105 +1,100 @@
 package com.vitorpamplona.amethyst.service
 
 import com.vitorpamplona.amethyst.model.Account
-import com.vitorpamplona.amethyst.model.Note
 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
-import nostr.postr.JsonFilter
-import nostr.postr.events.PrivateDmEvent
 
-object NostrChatroomListDataSource: NostrDataSource<Note>("MailBoxFeed") {
-  lateinit var account: Account
+object NostrChatroomListDataSource : NostrDataSource("MailBoxFeed") {
+    lateinit var account: Account
 
-  fun createMessagesToMeFilter() = TypedFilter(
-    types = setOf(FeedType.PRIVATE_DMS),
-      filter = JsonFilter(
-      kinds = listOf(PrivateDmEvent.kind),
-      tags = mapOf("p" to listOf(account.userProfile().pubkeyHex))
+    val latestEOSEs = EOSEAccount()
+    val chatRoomList = "ChatroomList"
+
+    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()]?.followList?.get(chatRoomList)?.relayList
+        )
     )
-  )
 
-  fun createMessagesFromMeFilter() = TypedFilter(
-    types = setOf(FeedType.PRIVATE_DMS),
-      filter = JsonFilter(
-      kinds = listOf(PrivateDmEvent.kind),
-      authors = listOf(account.userProfile().pubkeyHex)
+    fun createMessagesFromMeFilter() = TypedFilter(
+        types = setOf(FeedType.PRIVATE_DMS),
+        filter = JsonFilter(
+            kinds = listOf(PrivateDmEvent.kind),
+            authors = listOf(account.userProfile().pubkeyHex),
+            since = latestEOSEs.users[account.userProfile()]?.followList?.get(chatRoomList)?.relayList
+        )
     )
-  )
 
-  fun createChannelsCreatedbyMeFilter() = TypedFilter(
-    types = setOf(FeedType.PUBLIC_CHATS),
-      filter = JsonFilter(
-      kinds = listOf(ChannelCreateEvent.kind, ChannelMetadataEvent.kind),
-      authors = listOf(account.userProfile().pubkeyHex)
-    )
-  )
-
-  fun createMyChannelsFilter() = TypedFilter(
-    types = setOf(FeedType.PUBLIC_CHATS),
-      filter = JsonFilter(
-      kinds = listOf(ChannelCreateEvent.kind),
-      ids = account.followingChannels.toList()
-    )
-  )
-
-  fun createLastChannelInfoFilter(): List<TypedFilter> {
-    return account.followingChannels.map {
-      TypedFilter(
+    fun createChannelsCreatedbyMeFilter() = TypedFilter(
         types = setOf(FeedType.PUBLIC_CHATS),
         filter = JsonFilter(
-          kinds = listOf(ChannelMetadataEvent.kind),
-          tags = mapOf("e" to listOf(it)),
-          limit = 1
+            kinds = listOf(ChannelCreateEvent.kind, ChannelMetadataEvent.kind),
+            authors = listOf(account.userProfile().pubkeyHex),
+            since = latestEOSEs.users[account.userProfile()]?.followList?.get(chatRoomList)?.relayList
         )
-      )
-    }
-  }
-
-  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)),
-          limit = 1
-        )
-      )
-    }
-  }
-
-  val chatroomListChannel = requestNewChannel()
-
-  // returns the last Note of each user.
-  override fun feed(): List<Note> {
-    val messages = account.userProfile().messages
-    val messagingWith = messages.keys.filter { account.isAcceptable(it) }
-
-    val privateMessages = messagingWith.mapNotNull {
-      messages[it]?.sortedBy { it.event?.createdAt }?.lastOrNull { it.event != null }
-    }
-
-    val publicChannels = account.followingChannels().map {
-      it.notes.values.filter { account.isAcceptable(it) }.sortedBy { it.event?.createdAt }.lastOrNull { it.event != null }
-    }
-
-    return (privateMessages + publicChannels).filterNotNull().sortedBy { it.event?.createdAt }.reversed()
-  }
-
-  override fun updateChannelFilters() {
-    val list = listOf(
-      createMessagesToMeFilter(),
-      createMessagesFromMeFilter(),
-      createMyChannelsFilter()
     )
 
-    chatroomListChannel.typedFilters = listOfNotNull(
-      list,
-      createLastChannelInfoFilter(),
-      createLastMessageOfEachChannelFilter()
-    ).flatten().ifEmpty { null }
-  }
-}
+    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()]?.followList?.get(chatRoomList)?.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()]?.followList?.get(chatRoomList)?.relayList,
+                    limit = 25 // Remember to consider spam that is being removed from the UI
+                )
+            )
+        }
+    }
+
+    val chatroomListChannel = requestNewChannel { time, relayUrl ->
+        latestEOSEs.addOrUpdate(account.userProfile(), chatRoomList, relayUrl, time)
+    }
+
+    override fun updateChannelFilters() {
+        val list = listOf(
+            createMessagesToMeFilter(),
+            createMessagesFromMeFilter(),
+            createMyChannelsFilter()
+        )
+
+        chatroomListChannel.typedFilters = listOfNotNull(
+            list,
+            createLastChannelInfoFilter(),
+            createLastMessageOfEachChannelFilter()
+        ).flatten().ifEmpty { null }
+    }
+}

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

@@ -1,228 +1,168 @@
 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.model.UrlCachedPreviewer
-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.LnZapEvent
-import com.vitorpamplona.amethyst.service.model.LnZapRequestEvent
-import com.vitorpamplona.amethyst.service.model.ReactionEvent
-import com.vitorpamplona.amethyst.service.model.ReportEvent
-import com.vitorpamplona.amethyst.service.model.RepostEvent
+import com.vitorpamplona.amethyst.service.model.*
+import com.vitorpamplona.amethyst.service.model.Event
 import com.vitorpamplona.amethyst.service.relays.Client
 import com.vitorpamplona.amethyst.service.relays.Relay
 import com.vitorpamplona.amethyst.service.relays.Subscription
-import java.util.Date
-import java.util.UUID
+import com.vitorpamplona.amethyst.ui.components.BundledUpdate
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
-import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
-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 java.util.Date
+import java.util.UUID
+import kotlin.Error
 
-abstract class NostrDataSource<T>(val debugName: String) {
-  private var subscriptions = mapOf<String, Subscription>()
-  private var eventCounter = mapOf<String, Int>()
+abstract class NostrDataSource(val debugName: String) {
+    private var subscriptions = mapOf<String, Subscription>()
+    data class Counter(var counter: Int)
 
-  fun printCounter() {
-    eventCounter.forEach {
-      println("AAA Count ${it.key}: ${it.value}")
-    }
-  }
+    private var eventCounter = mapOf<String, Counter>()
 
-  private val clientListener = object : Client.Listener() {
-    override fun onEvent(event: Event, subscriptionId: String, relay: Relay) {
-      if (subscriptionId in subscriptions.keys) {
-        val key = "${debugName} ${subscriptionId} ${event.kind}"
-        val keyValue = eventCounter.get(key)
-        if (keyValue != null) {
-          eventCounter = eventCounter + Pair(key, keyValue + 1)
-        } else {
-          eventCounter = eventCounter + Pair(key, 1)
+    fun printCounter() {
+        eventCounter.forEach {
+            Log.d("STATE DUMP", "Received Events ${it.key}: ${it.value.counter}")
         }
+    }
 
-        try {
-          when (event) {
-            is MetadataEvent -> LocalCache.consume(event)
-            is TextNoteEvent -> LocalCache.consume(event, relay)
-            is RecommendRelayEvent -> LocalCache.consume(event)
-            is ContactListEvent -> LocalCache.consume(event)
-            is PrivateDmEvent -> LocalCache.consume(event, relay)
-            is DeletionEvent -> LocalCache.consume(event)
-            else -> when (event.kind) {
-              RepostEvent.kind -> {
-                val repostEvent = RepostEvent(event.id, event.pubKey, event.createdAt, event.tags, event.content, event.sig)
+    private val clientListener = object : Client.Listener() {
+        override fun onEvent(event: Event, subscriptionId: String, relay: Relay) {
+            if (subscriptionId in subscriptions.keys) {
+                val key = "$debugName $subscriptionId ${event.kind}"
+                val keyValue = eventCounter.get(key)
+                if (keyValue != null) {
+                    keyValue.counter++
+                } else {
+                    eventCounter = eventCounter + Pair(key, Counter(1))
+                }
 
-                repostEvent.containedPost?.let { onEvent(it, subscriptionId, relay) }
-                LocalCache.consume(repostEvent)
-              }
-              ReactionEvent.kind -> LocalCache.consume(ReactionEvent(event.id, event.pubKey, event.createdAt, event.tags, event.content, event.sig))
-              ReportEvent.kind -> LocalCache.consume(ReportEvent(event.id, event.pubKey, event.createdAt, event.tags, event.content, event.sig))
-
-              LnZapEvent.kind -> {
-                val zapEvent = LnZapEvent(event.id, event.pubKey, event.createdAt, event.tags, event.content, event.sig)
-
-                zapEvent.containedPost?.let { onEvent(it, subscriptionId, relay) }
-                LocalCache.consume(zapEvent)
-              }
-              LnZapRequestEvent.kind -> LocalCache.consume(LnZapRequestEvent(event.id, event.pubKey, event.createdAt, event.tags, event.content, event.sig))
-
-              ChannelCreateEvent.kind -> LocalCache.consume(ChannelCreateEvent(event.id, event.pubKey, event.createdAt, event.tags, event.content, event.sig))
-              ChannelMetadataEvent.kind -> LocalCache.consume(ChannelMetadataEvent(event.id, event.pubKey, event.createdAt, event.tags, event.content, event.sig))
-              ChannelMessageEvent.kind -> LocalCache.consume(ChannelMessageEvent(event.id, event.pubKey, event.createdAt, event.tags, event.content, event.sig), relay)
-              ChannelHideMessageEvent.kind -> LocalCache.consume(ChannelHideMessageEvent(event.id, event.pubKey, event.createdAt, event.tags, event.content, event.sig))
-              ChannelMuteUserEvent.kind -> LocalCache.consume(ChannelMuteUserEvent(event.id, event.pubKey, event.createdAt, event.tags, event.content, event.sig))
+                LocalCache.verifyAndConsume(event, relay)
             }
-          }
-        } 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)
-      }
-    }
-
-    override fun onSendResponse(eventId: String, success: Boolean, message: String, relay: Relay) {
-
-    }
-  }
-
-  init {
-    Client.subscribe(clientListener)
-  }
-
-  open fun start() {
-    resetFilters()
-  }
-
-  open fun stop() {
-    subscriptions.values.forEach { channel ->
-      if (channel.typedFilters != null) {// if it is active, close
-        Client.close(channel.id)
-        channel.typedFilters = null
-      }
-    }
-  }
-
-  fun loadTop(): List<T> {
-    val returningList = feed().take(100)
-
-    // prepare previews
-    val scope = CoroutineScope(Job() + Dispatchers.IO)
-    scope.launch {
-      loadPreviews(returningList)
-    }
-
-    return returningList
-  }
-
-  fun loadPreviews(list: List<T>) {
-    list.forEach {
-      if (it is Note) {
-        UrlCachedPreviewer.preloadPreviewsFor(it)
-      }
-    }
-  }
-
-  fun requestNewChannel(onEOSE: ((Long) -> 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)
-  }
-
-  var handlerWaiting = false
-  @Synchronized
-  fun invalidateFilters() {
-    if (handlerWaiting) return
-
-    handlerWaiting = true
-    val scope = CoroutineScope(Job() + Dispatchers.IO)
-    scope.launch {
-      delay(200)
-      resetFiltersSuspend()
-      handlerWaiting = false
-    }
-  }
-
-  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)
-          }
+        override fun onError(error: Error, subscriptionId: String, relay: Relay) {
+            // Log.e("ERROR", "Relay ${relay.url}: ${error.message}")
         }
-      } 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()
-  abstract fun feed(): List<T>
-}
+        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)
+        }
+    }
+
+    init {
+        Client.subscribe(clientListener)
+    }
+
+    fun destroy() {
+        stop()
+        Client.unsubscribe(clientListener)
+    }
+
+    open fun start() {
+        println("DataSource: ${this.javaClass.simpleName} Start")
+        resetFilters()
+    }
+
+    open fun stop() {
+        println("DataSource: ${this.javaClass.simpleName} Stop")
+        subscriptions.values.forEach { channel ->
+            Client.close(channel.id)
+            channel.typedFilters = null
+        }
+    }
+
+    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(300, Dispatchers.IO)
+
+    fun invalidateFilters() {
+        bundler.invalidate() {
+            // 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 resetFilters() {
+        val scope = CoroutineScope(Job() + Dispatchers.IO)
+        scope.launch {
+            resetFiltersSuspend()
+        }
+    }
+
+    fun resetFiltersSuspend() {
+        checkNotInMainThread()
+
+        // 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
+}

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

@@ -1,36 +1,28 @@
 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.service.model.AudioTrackEvent
 import com.vitorpamplona.amethyst.service.model.ChannelMessageEvent
+import com.vitorpamplona.amethyst.service.model.HighlightEvent
+import com.vitorpamplona.amethyst.service.model.LongTextNoteEvent
+import com.vitorpamplona.amethyst.service.model.PinListEvent
+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
-import nostr.postr.JsonFilter
-import nostr.postr.events.TextNoteEvent
 
-object NostrGlobalDataSource: NostrDataSource<Note>("GlobalFeed") {
-  lateinit var account: Account
-  fun createGlobalFilter() = TypedFilter(
-    types = setOf(FeedType.GLOBAL),
-    filter = JsonFilter(
-      kinds = listOf(TextNoteEvent.kind, ChannelMessageEvent.kind),
-      limit = 200
+object NostrGlobalDataSource : NostrDataSource("GlobalFeed") {
+    fun createGlobalFilter() = TypedFilter(
+        types = setOf(FeedType.GLOBAL),
+        filter = JsonFilter(
+            kinds = listOf(TextNoteEvent.kind, PollNoteEvent.kind, ChannelMessageEvent.kind, AudioTrackEvent.kind, PinListEvent.kind, LongTextNoteEvent.kind, HighlightEvent.kind),
+            limit = 200
+        )
     )
-  )
 
-  val globalFeedChannel = requestNewChannel()
+    val globalFeedChannel = requestNewChannel()
 
-  override fun feed() = LocalCache.notes.values
-    .filter { account.isAcceptable(it) }
-    .filter {
-      (it.event is TextNoteEvent && (it.event as TextNoteEvent).replyTos.isEmpty()) ||
-      (it.event is ChannelMessageEvent && (it.event as ChannelMessageEvent).replyTos.isEmpty())
+    override fun updateChannelFilters() {
+        globalFeedChannel.typedFilters = listOf(createGlobalFilter()).ifEmpty { null }
     }
-    .sortedBy { it.event?.createdAt }
-    .reversed()
-
-  override fun updateChannelFilters() {
-    globalFeedChannel.typedFilters = listOf(createGlobalFilter()).ifEmpty { null }
-  }
-}
+}

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

@@ -0,0 +1,46 @@
+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.PollNoteEvent
+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, LongTextNoteEvent.kind, PollNoteEvent.kind),
+                limit = 200
+            )
+        )
+    }
+
+    val loadHashtagChannel = requestNewChannel()
+
+    override fun updateChannelFilters() {
+        loadHashtagChannel.typedFilters = listOfNotNull(createLoadHashtagFilter()).ifEmpty { null }
+    }
+
+    fun loadHashtag(tag: String?) {
+        hashtagToWatch = tag
+
+        invalidateFilters()
+    }
+}

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

@@ -1,16 +0,0 @@
-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.User
-import nostr.postr.JsonFilter
-import nostr.postr.events.TextNoteEvent
-
-object NostrHiddenAccountsDataSource: NostrDataSource<User>("HiddenAccounts") {
-  lateinit var account: Account
-
-  override fun feed() = account.hiddenUsers()
-
-  override fun updateChannelFilters() {}
-}

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

@@ -1,69 +1,96 @@
 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.User
-import com.vitorpamplona.amethyst.service.model.RepostEvent
+import com.vitorpamplona.amethyst.model.UserState
+import com.vitorpamplona.amethyst.service.model.AudioTrackEvent
+import com.vitorpamplona.amethyst.service.model.HighlightEvent
+import com.vitorpamplona.amethyst.service.model.LongTextNoteEvent
+import com.vitorpamplona.amethyst.service.model.PinListEvent
+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 nostr.postr.JsonFilter
-import nostr.postr.events.TextNoteEvent
-import nostr.postr.toHex
+import kotlinx.coroutines.DelicateCoroutinesApi
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
 
-object NostrHomeDataSource: NostrDataSource<Note>("HomeFeed") {
-  lateinit var account: Account
+object NostrHomeDataSource : NostrDataSource("HomeFeed") {
+    lateinit var account: Account
 
-  object cacheListener: User.Listener() {
-    override fun onFollowsChange() {
-      resetFilters()
-    }
-  }
+    val latestEOSEs = EOSEAccount()
 
-  override fun start() {
-    if (this::account.isInitialized)
-      account.userProfile().subscribe(cacheListener)
-    super.start()
-  }
-
-  override fun stop() {
-    super.stop()
-    if (this::account.isInitialized)
-      account.userProfile().unsubscribe(cacheListener)
-  }
-
-  fun createFollowAccountsFilter(): TypedFilter {
-    val follows = account.userProfile().follows
-
-    val followKeys = follows.map {
-      it.pubkey.toHex().substring(0, 6)
+    private val cacheListener: (UserState) -> Unit = {
+        invalidateFilters()
     }
 
-    val followSet = followKeys.plus(account.userProfile().pubkeyHex.substring(0, 6))
+    @OptIn(DelicateCoroutinesApi::class)
+    override fun start() {
+        if (this::account.isInitialized) {
+            GlobalScope.launch(Dispatchers.Main) {
+                account.userProfile().live().follows.observeForever(cacheListener)
+            }
+        }
+        super.start()
+    }
 
-    return TypedFilter(
-      types = setOf(FeedType.FOLLOWS),
-      filter = JsonFilter(
-        kinds = listOf(TextNoteEvent.kind, RepostEvent.kind),
-        authors = followSet,
-        limit = 400
-      )
-    )
-  }
+    @OptIn(DelicateCoroutinesApi::class)
+    override fun stop() {
+        super.stop()
+        if (this::account.isInitialized) {
+            GlobalScope.launch(Dispatchers.Main) {
+                account.userProfile().live().follows.removeObserver(cacheListener)
+            }
+        }
+    }
 
-  val followAccountChannel = requestNewChannel()
+    fun createFollowAccountsFilter(): TypedFilter {
+        val follows = account.selectedUsersFollowList(account.defaultHomeFollowList) ?: emptySet()
 
-  override fun feed(): List<Note> {
-    val user = account.userProfile()
+        val followKeys = follows.map {
+            it.substring(0, 6)
+        }
 
-    return LocalCache.notes.values
-      .filter { (it.event is TextNoteEvent || it.event is RepostEvent) && it.author in user.follows }
-      .filter { account.isAcceptable(it) }
-      .sortedBy { it.event?.createdAt }
-      .reversed()
-  }
+        val followSet = followKeys.plus(account.userProfile().pubkeyHex.substring(0, 6))
 
-  override fun updateChannelFilters() {
-    followAccountChannel.typedFilters = listOf(createFollowAccountsFilter()).ifEmpty { null }
-  }
-}
+        return TypedFilter(
+            types = setOf(FeedType.FOLLOWS),
+            filter = JsonFilter(
+                kinds = listOf(TextNoteEvent.kind, LongTextNoteEvent.kind, PollNoteEvent.kind, HighlightEvent.kind, AudioTrackEvent.kind, PinListEvent.kind),
+                authors = followSet,
+                limit = 400,
+                since = latestEOSEs.users[account.userProfile()]?.followList?.get(account.defaultHomeFollowList)?.relayList
+            )
+        )
+    }
+
+    fun createFollowTagsFilter(): TypedFilter? {
+        val hashToLoad = account.selectedTagsFollowList(account.defaultHomeFollowList) ?: emptySet()
+
+        if (hashToLoad.isEmpty()) return null
+
+        return TypedFilter(
+            types = setOf(FeedType.FOLLOWS),
+            filter = JsonFilter(
+                kinds = listOf(TextNoteEvent.kind, LongTextNoteEvent.kind, HighlightEvent.kind, AudioTrackEvent.kind, PinListEvent.kind),
+                tags = mapOf(
+                    "t" to hashToLoad.map {
+                        listOf(it, it.lowercase(), it.uppercase(), it.capitalize())
+                    }.flatten()
+                ),
+                limit = 100,
+                since = latestEOSEs.users[account.userProfile()]?.followList?.get(account.defaultHomeFollowList)?.relayList
+            )
+        )
+    }
+
+    val followAccountChannel = requestNewChannel { time, relayUrl ->
+        latestEOSEs.addOrUpdate(account.userProfile(), account.defaultHomeFollowList, relayUrl, time)
+    }
+
+    override fun updateChannelFilters() {
+        followAccountChannel.typedFilters = listOfNotNull(createFollowAccountsFilter(), createFollowTagsFilter()).ifEmpty { null }
+    }
+}

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

@@ -0,0 +1,53 @@
+package com.vitorpamplona.amethyst.service
+
+import com.vitorpamplona.amethyst.service.model.LnZapPaymentResponseEvent
+import com.vitorpamplona.amethyst.service.model.RelayAuthEvent
+import com.vitorpamplona.amethyst.service.relays.Client
+import com.vitorpamplona.amethyst.service.relays.FeedType
+import com.vitorpamplona.amethyst.service.relays.JsonFilter
+import com.vitorpamplona.amethyst.service.relays.Relay
+import com.vitorpamplona.amethyst.service.relays.TypedFilter
+
+class NostrLnZapPaymentResponseDataSource(
+    private val fromServiceHex: String,
+    private val toUserHex: String,
+    private val replyingToHex: String,
+    private val authSigningKey: ByteArray
+) : 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 }
+    }
+
+    override fun auth(relay: Relay, challenge: String) {
+        super.auth(relay, challenge)
+
+        val event = RelayAuthEvent.create(relay.url, challenge, authSigningKey)
+        Client.send(
+            event,
+            relay.url
+        )
+    }
+}

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

@@ -1,30 +0,0 @@
-package com.vitorpamplona.amethyst.service
-
-import com.vitorpamplona.amethyst.model.Account
-import com.vitorpamplona.amethyst.model.Note
-import com.vitorpamplona.amethyst.model.User
-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.LnZapRequestEvent
-import com.vitorpamplona.amethyst.service.model.RepostEvent
-import nostr.postr.JsonFilter
-
-object NostrNotificationDataSource: NostrDataSource<Note>("NotificationFeed") {
-  lateinit var account: Account
-
-  override fun feed(): List<Note> {
-    return account.userProfile().taggedPosts
-      .filter { it.event != null }
-      .filter { account.isAcceptable(it) }
-      .filter {
-           it.event !is ChannelCreateEvent
-        && it.event !is ChannelMetadataEvent
-        && it.event !is LnZapRequestEvent
-      }
-      .sortedBy { it.event?.createdAt }
-      .reversed()
-  }
-
-  override fun updateChannelFilters() {}
-}

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

@@ -1,69 +1,78 @@
 package com.vitorpamplona.amethyst.service
 
-import com.vitorpamplona.amethyst.model.Note
-import com.vitorpamplona.amethyst.model.decodePublicKey
-import com.vitorpamplona.amethyst.service.model.ChannelMessageEvent
+import com.vitorpamplona.amethyst.model.toHexKey
+import com.vitorpamplona.amethyst.service.model.*
+import com.vitorpamplona.amethyst.service.nip19.Nip19
+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
-import nostr.postr.JsonFilter
-import nostr.postr.bechToBytes
-import nostr.postr.events.MetadataEvent
-import nostr.postr.events.TextNoteEvent
-import nostr.postr.toHex
+import fr.acinq.secp256k1.Hex
 
-object NostrSearchEventOrUserDataSource: NostrDataSource<Note>("SingleEventFeed") {
-  private var hexToWatch: String? = null
+object NostrSearchEventOrUserDataSource : NostrDataSource("SingleEventFeed") {
+    private var searchString: String? = null
 
-  private fun createAnythingWithIDFilter(): List<TypedFilter>? {
-    if (hexToWatch == null) {
-      return null
+    private fun createAnythingWithIDFilter(): List<TypedFilter>? {
+        val mySearchString = searchString
+        if (mySearchString.isNullOrBlank()) {
+            return null
+        }
+
+        val hexToWatch = try {
+            Nip19.uriToRoute(mySearchString)?.hex ?: Hex.decode(mySearchString).toHexKey()
+        } catch (e: Exception) {
+            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 = setOf(FeedType.SEARCH),
+                filter = JsonFilter(
+                    kinds = listOf(MetadataEvent.kind),
+                    search = mySearchString,
+                    limit = 100
+                )
+            ),
+            TypedFilter(
+                types = setOf(FeedType.SEARCH),
+                filter = JsonFilter(
+                    search = mySearchString,
+                    limit = 100
+                )
+            )
+        )
     }
 
-    // downloads all the reactions to a given event.
-    return listOf(
-      TypedFilter(
-        types = FeedType.values().toSet(),
-        filter = JsonFilter(
-          ids = listOfNotNull(hexToWatch)
-        )
-      ),
-      TypedFilter(
-        types = FeedType.values().toSet(),
-        filter = JsonFilter(
-          kinds = listOf(MetadataEvent.kind),
-          authors = listOfNotNull(hexToWatch)
-        )
-      )
-    )
-  }
+    val searchChannel = requestNewChannel()
 
-  val searchChannel = requestNewChannel()
-
-  override fun feed(): List<Note> {
-    return emptyList<Note>()
-  }
-
-  override fun updateChannelFilters() {
-    searchChannel.typedFilters = createAnythingWithIDFilter()
-  }
-
-  fun search(eventId: String) {
-    try {
-      val hex = if (eventId.startsWith("npub") || eventId.startsWith("nsec")) {
-        decodePublicKey(eventId).toHex()
-      } else if (eventId.startsWith("note")) {
-        eventId.bechToBytes().toHex()
-      } else {
-        eventId
-      }
-      hexToWatch = hex
-      invalidateFilters()
-    } catch (e: Exception) {
-      // Usually when people add an incomplete npub or note.
+    override fun updateChannelFilters() {
+        searchChannel.typedFilters = createAnythingWithIDFilter()
     }
-  }
 
-  fun clear() {
-    hexToWatch = null
-  }
-}
+    fun search(searchString: String) {
+        this.searchString = searchString
+        invalidateFilters()
+    }
+
+    fun clear() {
+        searchString = null
+    }
+}

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

@@ -1,74 +1,70 @@
 package com.vitorpamplona.amethyst.service
 
 import com.vitorpamplona.amethyst.model.LocalCache
-import com.vitorpamplona.amethyst.model.Note
 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
-import nostr.postr.JsonFilter
 
-object NostrSingleChannelDataSource: NostrDataSource<Note>("SingleChannelFeed") {
-  private var channelsToWatch = setOf<String>()
+object NostrSingleChannelDataSource : NostrDataSource("SingleChannelFeed") {
+    private var channelsToWatch = setOf<String>()
 
-  private fun createRepliesAndReactionsFilter(): TypedFilter? {
-    val reactionsToWatch = channelsToWatch.map { it }
+    private fun createRepliesAndReactionsFilter(): TypedFilter? {
+        val reactionsToWatch = channelsToWatch.map { it }
 
-    if (reactionsToWatch.isEmpty()) {
-      return null
+        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)
+            )
+        )
     }
 
-    // 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() }
 
-  fun createLoadEventsIfNotLoadedFilter(): TypedFilter? {
-    val directEventsToLoad = channelsToWatch
-      .map { LocalCache.getOrCreateChannel(it) }
-      .filter { it.notes.isEmpty() }
+        val interestedEvents = (directEventsToLoad).map { it.idHex }.toSet()
 
-    val interestedEvents = (directEventsToLoad).map { it.idHex }.toSet()
+        if (interestedEvents.isEmpty()) {
+            return null
+        }
 
-    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()
+            )
+        )
     }
 
-    // downloads linked events to this event.
-    return TypedFilter(
-      types = FeedType.values().toSet(),
-      filter = JsonFilter(
-        kinds = listOf(ChannelCreateEvent.kind),
-        ids = interestedEvents.toList()
-      )
-    )
-  }
+    val singleChannelChannel = requestNewChannel()
 
-  val singleChannelChannel = requestNewChannel()
+    override fun updateChannelFilters() {
+        val reactions = createRepliesAndReactionsFilter()
+        val missing = createLoadEventsIfNotLoadedFilter()
 
-  override fun feed(): List<Note> {
-    return emptyList()
-  }
+        singleChannelChannel.typedFilters = listOfNotNull(reactions, missing).ifEmpty { null }
+    }
 
-  override fun updateChannelFilters() {
-    val reactions = createRepliesAndReactionsFilter()
-    val missing = createLoadEventsIfNotLoadedFilter()
+    fun add(eventId: String) {
+        channelsToWatch = channelsToWatch.plus(eventId)
+        invalidateFilters()
+    }
 
-    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()
-  }
-}
+    fun remove(eventId: String) {
+        channelsToWatch = channelsToWatch.minus(eventId)
+        invalidateFilters()
+    }
+}

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

@@ -1,114 +1,174 @@
 package com.vitorpamplona.amethyst.service
 
-import com.vitorpamplona.amethyst.model.LocalCache
+import com.vitorpamplona.amethyst.model.AddressableNote
 import com.vitorpamplona.amethyst.model.Note
-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.LnZapEvent
-import com.vitorpamplona.amethyst.service.model.ReactionEvent
-import com.vitorpamplona.amethyst.service.model.ReportEvent
-import com.vitorpamplona.amethyst.service.model.RepostEvent
-import com.vitorpamplona.amethyst.service.relays.FeedType
+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
-import java.util.Date
-import nostr.postr.JsonFilter
-import nostr.postr.events.TextNoteEvent
 
-object NostrSingleEventDataSource: NostrDataSource<Note>("SingleEventFeed") {
-  private var eventsToWatch = setOf<String>()
+object NostrSingleEventDataSource : NostrDataSource("SingleEventFeed") {
+    private var eventsToWatch = setOf<Note>()
+    private var addressesToWatch = setOf<Note>()
 
-  private fun createRepliesAndReactionsFilter(): List<TypedFilter>? {
-    val reactionsToWatch = eventsToWatch.map { LocalCache.getOrCreateNote(it) }
+    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, AudioTrackEvent.kind, PinListEvent.kind,
+                            PeopleListEvent.kind, BookmarkListEvent.kind
+                        ),
+                        tags = mapOf("a" to listOf(aTag.toTag())),
+                        since = it.lastReactionsDownloadTime
+                    )
+                )
+            }
+        }
     }
 
-    val now = Date().time / 1000
+    private fun createAddressFilter(): List<TypedFilter>? {
+        val addressesToWatch = addressesToWatch.filter { it.event == null }
 
-    return reactionsToWatch.filter {
-      val lastTime = it.lastReactionsDownloadTime;
-      lastTime == null || lastTime < (now - 10)
-    }.map {
-      TypedFilter(
-        types = FeedType.values().toSet(),
-        filter = JsonFilter(
-          kinds = listOf(
-            TextNoteEvent.kind, ReactionEvent.kind, RepostEvent.kind, ReportEvent.kind, LnZapEvent.kind
-          ),
-          tags = mapOf("e" to listOf(it.idHex)),
-          since = it.lastReactionsDownloadTime
+        if (addressesToWatch.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))
+                    )
+                )
+            }
+        }
+    }
+
+    private fun createRepliesAndReactionsFilter(): List<TypedFilter>? {
+        val reactionsToWatch = eventsToWatch
+
+        if (reactionsToWatch.isEmpty()) {
+            return null
+        }
+
+        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,
+                        HighlightEvent.kind,
+                        AudioTrackEvent.kind,
+                        PinListEvent.kind
+                    ),
+                    tags = mapOf("e" to listOf(it.idHex)),
+                    since = it.lastReactionsDownloadTime
+                )
+            )
+        }
+    }
+
+    fun createLoadEventsIfNotLoadedFilter(): List<TypedFilter>? {
+        val directEventsToLoad = eventsToWatch
+            .filter { it.event == null }
+
+        val threadingEventsToLoad = eventsToWatch
+            .mapNotNull { it.replyTo }
+            .flatten()
+            .filter { it !is AddressableNote && it.event == null }
+
+        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(
+                    ids = interestedEvents.toList()
+                )
+            )
         )
-      )
-    }
-  }
-
-  fun createLoadEventsIfNotLoadedFilter(): List<TypedFilter>? {
-    val directEventsToLoad = eventsToWatch
-      .map { LocalCache.getOrCreateNote(it) }
-      .filter { it.event == null }
-
-    val threadingEventsToLoad = eventsToWatch
-      .map { LocalCache.getOrCreateNote(it) }
-      .mapNotNull { it.replyTo }
-      .flatten()
-      .filter { it.event == null }
-
-    val interestedEvents =
-      (directEventsToLoad + threadingEventsToLoad)
-      .map { it.idHex }.toSet()
-
-    if (interestedEvents.isEmpty()) {
-      return null
     }
 
-    // downloads linked events to this event.
-    return listOf(
-      TypedFilter(
-        types = FeedType.values().toSet(),
-        filter = JsonFilter(
-          kinds = listOf(
-            TextNoteEvent.kind, ReactionEvent.kind, RepostEvent.kind, LnZapEvent.kind,
-            ChannelMessageEvent.kind, ChannelCreateEvent.kind, ChannelMetadataEvent.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
+            }
+        }
 
-  val singleEventChannel = requestNewChannel() { time ->
-    eventsToWatch.forEach {
-      LocalCache.getOrCreateNote(it).lastReactionsDownloadTime = time
+        // Many relays operate with limits in the amount of filters.
+        // As information comes, the filters will be rotated to get more data.
+        invalidateFilters()
     }
-    // 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 feed(): List<Note> {
-    return synchronized(eventsToWatch) {
-      eventsToWatch.map {
-        LocalCache.notes[it]
-      }.filterNotNull()
+    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 }
     }
-  }
 
-  override fun updateChannelFilters() {
-    val reactions = createRepliesAndReactionsFilter()
-    val missing = createLoadEventsIfNotLoadedFilter()
+    fun add(eventId: Note) {
+        if (!eventsToWatch.contains(eventId)) {
+            eventsToWatch = eventsToWatch.plus(eventId)
+            invalidateFilters()
+        }
+    }
 
-    singleEventChannel.typedFilters = listOfNotNull(reactions, missing).flatten().ifEmpty { null }
-  }
+    fun remove(eventId: Note) {
+        if (eventsToWatch.contains(eventId)) {
+            eventsToWatch = eventsToWatch.minus(eventId)
+            invalidateFilters()
+        }
+    }
 
-  fun add(eventId: String) {
-    eventsToWatch = eventsToWatch.plus(eventId)
-    invalidateFilters()
-  }
+    fun addAddress(aTag: Note) {
+        if (!addressesToWatch.contains(aTag)) {
+            addressesToWatch = addressesToWatch.plus(aTag)
+            invalidateFilters()
+        }
+    }
 
-  fun remove(eventId: String) {
-    eventsToWatch = eventsToWatch.minus(eventId)
-    invalidateFilters()
-  }
-}
+    fun removeAddress(aTag: Note) {
+        if (addressesToWatch.contains(aTag)) {
+            addressesToWatch = addressesToWatch.minus(aTag)
+            invalidateFilters()
+        }
+    }
+}

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

@@ -1,70 +1,79 @@
 package com.vitorpamplona.amethyst.service
 
-import com.vitorpamplona.amethyst.model.LocalCache
 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.FeedType
+import com.vitorpamplona.amethyst.service.relays.COMMON_FEED_TYPES
+import com.vitorpamplona.amethyst.service.relays.EOSETime
+import com.vitorpamplona.amethyst.service.relays.JsonFilter
 import com.vitorpamplona.amethyst.service.relays.TypedFilter
-import nostr.postr.JsonFilter
-import nostr.postr.events.MetadataEvent
 
-object NostrSingleUserDataSource: NostrDataSource<User>("SingleUserFeed") {
-  var usersToWatch = setOf<String>()
+object NostrSingleUserDataSource : NostrDataSource("SingleUserFeed") {
+    var usersToWatch = setOf<User>()
 
-  fun createUserFilter(): List<TypedFilter>? {
-    if (usersToWatch.isEmpty()) return null
+    fun createUserFilter(): List<TypedFilter>? {
+        if (usersToWatch.isEmpty()) return null
 
-    return usersToWatch.filter { LocalCache.getOrCreateUser(it).latestMetadata == null }.map {
-      TypedFilter(
-        types = FeedType.values().toSet(),
-        filter = JsonFilter(
-          kinds = listOf(MetadataEvent.kind),
-          authors = listOf(it),
-          limit = 1
-        )
-      )
+        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
+                )
+            )
+        }
     }
-  }
 
-  fun createUserReportFilter(): List<TypedFilter>? {
-    if (usersToWatch.isEmpty()) return null
+    fun createUserReportFilter(): List<TypedFilter>? {
+        if (usersToWatch.isEmpty()) return null
 
-    return usersToWatch.map {
-      TypedFilter(
-        types = FeedType.values().toSet(),
-        filter = JsonFilter(
-          kinds = listOf(ReportEvent.kind),
-          tags = mapOf("p" to listOf(it))
-        )
-      )
+        return usersToWatch.map {
+            TypedFilter(
+                types = COMMON_FEED_TYPES,
+                filter = JsonFilter(
+                    kinds = listOf(ReportEvent.kind),
+                    tags = mapOf("p" to listOf(it.pubkeyHex)),
+                    since = it.latestEOSEs
+                )
+            )
+        }
     }
-  }
 
-  val userChannel = requestNewChannel(){
-    // Many relays operate with limits in the amount of filters.
-    // As information comes, the filters will be rotated to get more data.
-    invalidateFilters()
-  }
+    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
+            }
+        }
 
-  override fun feed(): List<User> {
-    return synchronized(usersToWatch) {
-      usersToWatch.map {
-        LocalCache.users[it]
-      }.filterNotNull()
+        // 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() {
-    userChannel.typedFilters = listOfNotNull(createUserFilter(), createUserReportFilter()).flatten()
-  }
+    val userChannelOnce = requestNewChannel()
 
-  fun add(userId: String) {
-    usersToWatch = usersToWatch.plus(userId)
-    invalidateFilters()
-  }
+    override fun updateChannelFilters() {
+        userChannel.typedFilters = listOfNotNull(createUserFilter()).flatten().ifEmpty { null }
+        userChannelOnce.typedFilters = listOfNotNull(createUserReportFilter()).flatten().ifEmpty { null }
+    }
 
-  fun remove(userId: String) {
-    usersToWatch = usersToWatch.minus(userId)
-    invalidateFilters()
-  }
-}
+    fun add(user: User) {
+        if (!usersToWatch.contains(user)) {
+            usersToWatch = usersToWatch.plus(user)
+            invalidateFilters()
+        }
+    }
+
+    fun remove(user: User) {
+        if (usersToWatch.contains(user)) {
+            usersToWatch = usersToWatch.minus(user)
+            invalidateFilters()
+        }
+    }
+}

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

@@ -1,118 +1,43 @@
 package com.vitorpamplona.amethyst.service
 
-import com.vitorpamplona.amethyst.model.LocalCache
-import com.vitorpamplona.amethyst.model.Note
-import com.vitorpamplona.amethyst.service.model.ReactionEvent
-import com.vitorpamplona.amethyst.service.model.RepostEvent
-import com.vitorpamplona.amethyst.service.relays.FeedType
+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
-import nostr.postr.JsonFilter
-import nostr.postr.events.TextNoteEvent
 
-object NostrThreadDataSource: NostrDataSource<Note>("SingleThreadFeed") {
-  private var eventsToWatch = setOf<String>()
+object NostrThreadDataSource : NostrDataSource("SingleThreadFeed") {
+    private var eventToWatch: String? = null
 
-  fun createRepliesAndReactionsFilter(): TypedFilter? {
-    if (eventsToWatch.isEmpty()) {
-      return null
+    fun createLoadEventsIfNotLoadedFilter(): TypedFilter? {
+        val threadToLoad = eventToWatch ?: 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 TypedFilter(
-      types = FeedType.values().toSet(),
-      filter = JsonFilter(
-        kinds = listOf(TextNoteEvent.kind, ReactionEvent.kind, RepostEvent.kind),
-        tags = mapOf("e" to eventsToWatch.toList())
-      )
-    )
-  }
-
-  fun createLoadEventsIfNotLoadedFilter(): TypedFilter? {
-    val nodes = eventsToWatch.map { LocalCache.getOrCreateNote(it) }
-
-    val eventsToLoad = nodes
-      .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 TypedFilter(
-      types = FeedType.values().toSet(),
-      filter = JsonFilter(
-        ids = eventsToLoad
-      )
-    )
-  }
-
-  val loadEventsChannel = requestNewChannel()
-
-  override fun feed(): List<Note> {
-    // Currently orders by date of each event, descending, at each level of the reply stack
-    val order = compareByDescending<Note> { it.replyLevelSignature() }
-
-    return eventsToWatch.map {
-      LocalCache.getOrCreateNote(it)
-    }.sortedWith(order)
-  }
-
-  override fun updateChannelFilters() {
-    loadEventsChannel.typedFilters = listOfNotNull(createLoadEventsIfNotLoadedFilter(), createRepliesAndReactionsFilter()).ifEmpty { null }
-  }
-
-  fun searchRoot(note: Note, testedNotes: MutableSet<Note> = mutableSetOf()): Note? {
-    if (note.replyTo == null || note.replyTo?.isEmpty() == true) return note
-
-    val markedAsRoot = note.event?.tags?.firstOrNull { it[0] == "e" && it.size > 3 && it[3] == "root" }?.getOrNull(1)
-    if (markedAsRoot != null) return LocalCache.getOrCreateNote(markedAsRoot)
-
-    val hasNoReplyTo = note.replyTo?.firstOrNull { it.replyTo?.isEmpty() == true }
-    if (hasNoReplyTo != null) return hasNoReplyTo
-
-    testedNotes.add(note)
-
-    // recursive
-    val roots = note.replyTo?.map {
-      if (it !in testedNotes)
-        searchRoot(it, testedNotes)
-      else
-        null
-    }?.filterNotNull()
-
-    if (roots != null && roots.isNotEmpty()) {
-      return roots[0]
+    override fun updateChannelFilters() {
+        loadEventsChannel.typedFilters = listOfNotNull(createLoadEventsIfNotLoadedFilter()).ifEmpty { null }
     }
 
-    return null
-  }
+    fun loadThread(noteId: String?) {
+        eventToWatch = noteId
 
-  fun loadThread(noteId: String) {
-    val note = LocalCache.getOrCreateNote(noteId)
-
-    if (note.event != null) {
-      val thread = mutableListOf<Note>()
-      val threadSet = mutableSetOf<Note>()
-
-      val threadRoot = searchRoot(note) ?: note
-
-      loadDown(threadRoot, thread, threadSet)
-
-      eventsToWatch = thread.map { it.idHex }.toSet()
-    } else {
-      eventsToWatch = setOf(noteId)
+        invalidateFilters()
     }
-
-    invalidateFilters()
-  }
-
-  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)
-      }
-    }
-  }
-}
+}

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

@@ -1,95 +1,116 @@
 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.User
-import com.vitorpamplona.amethyst.service.model.LnZapEvent
-import com.vitorpamplona.amethyst.service.relays.FeedType
+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.JsonFilter
-import nostr.postr.events.ContactListEvent
-import nostr.postr.events.MetadataEvent
-import nostr.postr.events.TextNoteEvent
 
-object NostrUserProfileDataSource: NostrDataSource<Note>("UserProfileFeed") {
-  lateinit var account: Account
-  var user: User? = null
+object NostrUserProfileDataSource : NostrDataSource("UserProfileFeed") {
+    var user: User? = null
 
-  fun loadUserProfile(userId: String) {
-    user = LocalCache.getOrCreateUser(userId)
-    resetFilters()
-  }
+    fun loadUserProfile(user: User?) {
+        this.user = user
+    }
 
-  fun createUserInfoFilter(): TypedFilter {
-    return TypedFilter(
-      types = FeedType.values().toSet(),
-      filter = JsonFilter(
-        kinds = listOf(MetadataEvent.kind),
-        authors = listOf(user!!.pubkeyHex),
-        limit = 1
-      )
-    )
-  }
+    fun createUserInfoFilter() = user?.let {
+        TypedFilter(
+            types = COMMON_FEED_TYPES,
+            filter = JsonFilter(
+                kinds = listOf(MetadataEvent.kind),
+                authors = listOf(it.pubkeyHex),
+                limit = 1
+            )
+        )
+    }
 
-  fun createUserPostsFilter(): TypedFilter {
-    return TypedFilter(
-      types = FeedType.values().toSet(),
-      filter = JsonFilter(
-        kinds = listOf(TextNoteEvent.kind),
-        authors = listOf(user!!.pubkeyHex),
-        limit = 100
-      )
-    )
-  }
+    fun createUserPostsFilter() = user?.let {
+        TypedFilter(
+            types = COMMON_FEED_TYPES,
+            filter = JsonFilter(
+                kinds = listOf(TextNoteEvent.kind, RepostEvent.kind, LongTextNoteEvent.kind, AudioTrackEvent.kind, PinListEvent.kind, PollNoteEvent.kind, HighlightEvent.kind),
+                authors = listOf(it.pubkeyHex),
+                limit = 200
+            )
+        )
+    }
 
-  fun createUserReceivedZapsFilter(): TypedFilter {
-    return TypedFilter(
-      types = FeedType.values().toSet(),
-      filter = JsonFilter(
-        kinds = listOf(LnZapEvent.kind),
-        tags = mapOf("e" to listOf(user!!.pubkeyHex)),
-        limit = 100
-      )
-    )
-  }
+    fun createUserReceivedZapsFilter() = user?.let {
+        TypedFilter(
+            types = COMMON_FEED_TYPES,
+            filter = JsonFilter(
+                kinds = listOf(LnZapEvent.kind),
+                tags = mapOf("p" to listOf(it.pubkeyHex))
+            )
+        )
+    }
 
-  fun createFollowFilter(): TypedFilter {
-    return TypedFilter(
-      types = FeedType.values().toSet(),
-      filter = JsonFilter(
-        kinds = listOf(ContactListEvent.kind),
-        authors = listOf(user!!.pubkeyHex),
-        limit = 1
-      )
-    )
-  }
+    fun createFollowFilter() = user?.let {
+        TypedFilter(
+            types = COMMON_FEED_TYPES,
+            filter = JsonFilter(
+                kinds = listOf(ContactListEvent.kind),
+                authors = listOf(it.pubkeyHex),
+                limit = 1
+            )
+        )
+    }
 
-  fun createFollowersFilter() = TypedFilter(
-    types = FeedType.values().toSet(),
-    filter = JsonFilter(
-      kinds = listOf(ContactListEvent.kind),
-      tags = mapOf("p" to listOf(user!!.pubkeyHex))
-    )
-  )
+    fun createFollowersFilter() = user?.let {
+        TypedFilter(
+            types = COMMON_FEED_TYPES,
+            filter = JsonFilter(
+                kinds = listOf(ContactListEvent.kind),
+                tags = mapOf("p" to listOf(it.pubkeyHex))
+            )
+        )
+    }
 
-  val userInfoChannel = requestNewChannel()
+    fun createAcceptedAwardsFilter() = user?.let {
+        TypedFilter(
+            types = COMMON_FEED_TYPES,
+            filter = JsonFilter(
+                kinds = listOf(BadgeProfilesEvent.kind),
+                authors = listOf(it.pubkeyHex),
+                limit = 1
+            )
+        )
+    }
 
-  override fun feed(): List<Note> {
-    return user?.notes
-      ?.filter { account.isAcceptable(it) }
-      ?.sortedBy { it.event?.createdAt }
-      ?.reversed()
-      ?: emptyList()
-  }
+    fun createBookmarksFilter() = user?.let {
+        TypedFilter(
+            types = COMMON_FEED_TYPES,
+            filter = JsonFilter(
+                kinds = listOf(BookmarkListEvent.kind, PeopleListEvent.kind, AppRecommendationEvent.kind),
+                authors = listOf(it.pubkeyHex),
+                limit = 100
+            )
+        )
+    }
 
-  override fun updateChannelFilters() {
-    userInfoChannel.typedFilters = listOf(
-      createUserInfoFilter(),
-      createUserPostsFilter(),
-      createFollowFilter(),
-      createFollowersFilter(),
-      createUserReceivedZapsFilter()
-    ).ifEmpty { null }
-  }
-}
+    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 }
+    }
+}

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

@@ -1,23 +0,0 @@
-package com.vitorpamplona.amethyst.service
-
-import com.vitorpamplona.amethyst.model.Account
-import com.vitorpamplona.amethyst.model.LocalCache
-import com.vitorpamplona.amethyst.model.User
-import nostr.postr.JsonFilter
-import nostr.postr.events.ContactListEvent
-
-object NostrUserProfileFollowersDataSource: NostrDataSource<User>("UserProfileFollowerFeed") {
-  lateinit var account: Account
-  var user: User? = null
-
-  fun loadUserProfile(userId: String) {
-    user = LocalCache.users[userId]
-    resetFilters()
-  }
-
-  override fun feed(): List<User> {
-    return user?.followers?.filter { account.isAcceptable(it) } ?: emptyList()
-  }
-
-  override fun updateChannelFilters() {}
-}

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

@@ -1,23 +0,0 @@
-package com.vitorpamplona.amethyst.service
-
-import com.vitorpamplona.amethyst.model.Account
-import com.vitorpamplona.amethyst.model.LocalCache
-import com.vitorpamplona.amethyst.model.User
-import nostr.postr.JsonFilter
-import nostr.postr.events.ContactListEvent
-
-object NostrUserProfileFollowsDataSource: NostrDataSource<User>("UserProfileFollowsFeed") {
-  lateinit var account: Account
-  var user: User? = null
-
-  fun loadUserProfile(userId: String) {
-    user = LocalCache.users[userId]
-    resetFilters()
-  }
-
-  override fun feed(): List<User> {
-    return user?.follows?.filter { account.isAcceptable(it) } ?: emptyList()
-  }
-
-  override fun updateChannelFilters() {}
-}

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

@@ -1,25 +0,0 @@
-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.User
-import com.vitorpamplona.amethyst.service.model.LnZapEvent
-import nostr.postr.JsonFilter
-import nostr.postr.events.ContactListEvent
-
-object NostrUserProfileZapsDataSource: NostrDataSource<Pair<Note,Note>>("UserProfileZapsFeed") {
-  lateinit var account: Account
-  var user: User? = null
-
-  fun loadUserProfile(userId: String) {
-    user = LocalCache.users[userId]
-    resetFilters()
-  }
-
-  override fun feed(): List<Pair<Note,Note>> {
-    return (user?.zaps?.filter { it.value != null }?.toList()?.sortedBy { (it.second?.event as? LnZapEvent)?.amount }?.reversed() ?: emptyList()) as List<Pair<Note, Note>>
-  }
-
-  override fun updateChannelFilters() {}
-}

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

@@ -0,0 +1,54 @@
+package com.vitorpamplona.amethyst.service
+
+import com.vitorpamplona.amethyst.model.Account
+import com.vitorpamplona.amethyst.service.model.FileHeaderEvent
+import com.vitorpamplona.amethyst.service.model.FileStorageHeaderEvent
+import com.vitorpamplona.amethyst.service.relays.FeedType
+import com.vitorpamplona.amethyst.service.relays.JsonFilter
+import com.vitorpamplona.amethyst.service.relays.TypedFilter
+
+object NostrVideoDataSource : NostrDataSource("VideoFeed") {
+    lateinit var account: Account
+
+    fun createContextualFilter(): TypedFilter? {
+        val follows = account.selectedUsersFollowList(account.defaultStoriesFollowList)
+
+        val followKeys = follows?.map {
+            it.substring(0, 6)
+        }
+
+        return TypedFilter(
+            types = setOf(FeedType.GLOBAL),
+            filter = JsonFilter(
+                authors = followKeys,
+                kinds = listOf(FileHeaderEvent.kind, FileStorageHeaderEvent.kind),
+                limit = 200
+            )
+        )
+    }
+
+    fun createFollowTagsFilter(): TypedFilter? {
+        val hashToLoad = account.selectedTagsFollowList(account.defaultStoriesFollowList)
+
+        if (hashToLoad.isNullOrEmpty()) return null
+
+        return TypedFilter(
+            types = setOf(FeedType.GLOBAL),
+            filter = JsonFilter(
+                kinds = listOf(FileHeaderEvent.kind, FileStorageHeaderEvent.kind),
+                tags = mapOf(
+                    "t" to hashToLoad.map {
+                        listOf(it, it.lowercase(), it.uppercase(), it.capitalize())
+                    }.flatten()
+                ),
+                limit = 100
+            )
+        )
+    }
+
+    val videoFeedChannel = requestNewChannel()
+
+    override fun updateChannelFilters() {
+        videoFeedChannel.typedFilters = listOfNotNull(createContextualFilter(), createFollowTagsFilter()).ifEmpty { null }
+    }
+}

app/src/main/java/com/vitorpamplona/amethyst/service/lang/LanguageTranslatorService.kt

@@ -1,84 +0,0 @@
-package com.vitorpamplona.amethyst.service.lang
-
-import android.util.LruCache
-import com.google.android.gms.tasks.Task
-import com.google.android.gms.tasks.Tasks
-import com.google.mlkit.nl.languageid.LanguageIdentification
-import com.google.mlkit.nl.translate.TranslateLanguage
-import com.google.mlkit.nl.translate.Translation
-import com.google.mlkit.nl.translate.Translator
-import com.google.mlkit.nl.translate.TranslatorOptions
-import java.util.ArrayList
-
-class ResultOrError(
-  var result: String?,
-  var sourceLang: String?,
-  var targetLang: String?,
-  var error: Exception?
-)
-
-object LanguageTranslatorService {
-  private val languageIdentification = LanguageIdentification.getClient()
-
-  private val translators =
-    object : LruCache<TranslatorOptions, Translator>(10) {
-      override fun create(options: TranslatorOptions): Translator {
-        return Translation.getClient(options)
-      }
-
-      override fun entryRemoved(
-        evicted: Boolean,
-        key: TranslatorOptions,
-        oldValue: Translator,
-        newValue: Translator?
-      ) {
-        oldValue.close()
-      }
-    }
-
-  fun identifyLanguage(text: String): Task<String> {
-    return languageIdentification.identifyLanguage(text)
-  }
-
-  fun translate(text: String, source: String, target: String): Task<ResultOrError> {
-    val sourceLangCode = TranslateLanguage.fromLanguageTag(source)
-    val targetLangCode = TranslateLanguage.fromLanguageTag(target)
-    if (sourceLangCode == null || targetLangCode == null) {
-      return Tasks.forCanceled()
-    }
-
-    val options = TranslatorOptions.Builder()
-      .setSourceLanguage(sourceLangCode)
-      .setTargetLanguage(targetLangCode)
-      .build()
-
-    val translator = translators[options]
-
-    return translator.downloadModelIfNeeded().onSuccessTask {
-      val tasks = mutableListOf<Task<String>>()
-      for (paragraph in text.split("\n")) {
-        tasks.add(translator.translate(paragraph))
-      }
-
-      Tasks.whenAll(tasks).continueWith {
-        val results: MutableList<String> = ArrayList()
-        for (task in tasks) {
-          results.add(task.result)
-        }
-        ResultOrError(results.joinToString("\n"), source, target, null)
-      }
-    }
-  }
-
-  fun autoTranslate(text: String, dontTranslateFrom: Set<String>, translateTo: String): Task<ResultOrError> {
-    return identifyLanguage(text).onSuccessTask {
-      if (it == translateTo) {
-        Tasks.forCanceled()
-      } else if (it != "und" && !dontTranslateFrom.contains(it)) {
-        translate(text, it, translateTo)
-      } else {
-        Tasks.forCanceled()
-      }
-    }
-  }
-}

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

@@ -0,0 +1,193 @@
+package com.vitorpamplona.amethyst.service.lnurl
+
+import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import com.vitorpamplona.amethyst.BuildConfig
+import com.vitorpamplona.amethyst.service.HttpClient
+import com.vitorpamplona.amethyst.service.checkNotInMainThread
+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.Request
+import okhttp3.Response
+import java.math.BigDecimal
+import java.net.URLEncoder
+
+class LightningAddressResolver() {
+    val client = HttpClient.getHttpClient()
+
+    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) {
+        checkNotInMainThread()
+
+        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
+        )
+    }
+}

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

@@ -0,0 +1,176 @@
+package com.vitorpamplona.amethyst.service.lnurl
+
+import com.vitorpamplona.amethyst.service.checkNotInMainThread
+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
+     */
+    private 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 {
+        checkNotInMainThread()
+
+        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)
+        }
+    }
+}

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

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

@@ -0,0 +1,83 @@
+package com.vitorpamplona.amethyst.service.model
+
+import android.util.Log
+import androidx.compose.runtime.Immutable
+import com.vitorpamplona.amethyst.model.hexToByteArray
+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
+
+@Immutable
+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.hexToByteArray()
+        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
+        }
+    }
+}

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

@@ -0,0 +1,41 @@
+package com.vitorpamplona.amethyst.service.model
+
+import android.util.Log
+import androidx.compose.runtime.Immutable
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.UserMetadata
+import java.io.ByteArrayInputStream
+
+@Immutable
+class AppDefinitionEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig), AddressableEvent {
+    override fun dTag() = tags.firstOrNull { it.size > 1 && it[0] == "d" }?.get(1) ?: ""
+    override fun address() = ATag(kind, pubKey, dTag(), null)
+
+    fun appMetaData() = try {
+        MetadataEvent.metadataParser.readValue(
+            ByteArrayInputStream(content.toByteArray(Charsets.UTF_8)),
+            UserMetadata::class.java
+        )
+    } catch (e: Exception) {
+        e.printStackTrace()
+        Log.w("MT", "Content Parse Error ${e.localizedMessage} $content")
+        null
+    }
+
+    fun supportedKinds() = tags.filter { it.size > 1 && it[0] == "k" }.mapNotNull {
+        runCatching { it[1].toInt() }.getOrNull()
+    }
+
+    fun publishedAt() = tags.firstOrNull { it.size > 1 && it[0] == "published_at" }?.get(1)
+
+    companion object {
+        const val kind = 31990
+    }
+}

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

@@ -0,0 +1,27 @@
+package com.vitorpamplona.amethyst.service.model
+
+import androidx.compose.runtime.Immutable
+import com.vitorpamplona.amethyst.model.HexKey
+
+@Immutable
+class AppRecommendationEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig), AddressableEvent {
+    fun recommendations() = tags.filter { it.size > 1 && it[0] == "a" }.mapNotNull {
+        ATag.parse(it[1], it.getOrNull(2))
+    }
+
+    fun forKind() = runCatching { dTag().toInt() }.getOrNull()
+
+    override fun dTag() = tags.firstOrNull { it.size > 1 && it[0] == "d" }?.get(1) ?: ""
+    override fun address() = ATag(kind, pubKey, dTag(), null)
+
+    companion object {
+        const val kind = 31989
+    }
+}

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

@@ -0,0 +1,63 @@
+package com.vitorpamplona.amethyst.service.model
+
+import androidx.compose.runtime.Immutable
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.toHexKey
+import nostr.postr.Utils
+import java.util.Date
+
+@Immutable
+class AudioTrackEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig), AddressableEvent {
+
+    override fun dTag() = tags.firstOrNull { it.size > 1 && it[0] == "d" }?.get(1) ?: ""
+    override fun address() = ATag(kind, pubKey, dTag(), null)
+
+    fun participants() = tags.filter { it.size > 1 && it[0] == "p" }.map { Participant(it[1], it.getOrNull(2)) }
+    fun type() = tags.firstOrNull { it.size > 1 && it[0] == TYPE }?.get(1)
+    fun price() = tags.firstOrNull { it.size > 1 && it[0] == PRICE }?.get(1)
+    fun cover() = tags.firstOrNull { it.size > 1 && it[0] == COVER }?.get(1)
+    fun subject() = tags.firstOrNull { it.size > 1 && it[0] == SUBJECT }?.get(1)
+    fun media() = tags.firstOrNull { it.size > 1 && it[0] == MEDIA }?.get(1)
+
+    companion object {
+        const val kind = 31337
+
+        private const val TYPE = "c"
+        private const val PRICE = "price"
+        private const val COVER = "cover"
+        private const val SUBJECT = "subject"
+        private const val MEDIA = "media"
+
+        fun create(
+            type: String,
+            media: String,
+            price: String? = null,
+            cover: String? = null,
+            subject: String? = null,
+            privateKey: ByteArray,
+            createdAt: Long = Date().time / 1000
+        ): AudioTrackEvent {
+            val tags = listOfNotNull(
+                listOf(MEDIA, media),
+                listOf(TYPE, type),
+                price?.let { listOf(PRICE, it) },
+                cover?.let { listOf(COVER, it) },
+                subject?.let { listOf(SUBJECT, it) }
+            )
+
+            val pubKey = Utils.pubkeyCreate(privateKey).toHexKey()
+            val id = generateId(pubKey, createdAt, kind, tags, "")
+            val sig = Utils.sign(id, privateKey)
+            return AudioTrackEvent(id.toHexKey(), pubKey, createdAt, tags, "", sig.toHexKey())
+        }
+    }
+}
+
+data class Participant(val key: String, val role: String?)

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

@@ -0,0 +1,22 @@
+package com.vitorpamplona.amethyst.service.model
+
+import androidx.compose.runtime.Immutable
+import com.vitorpamplona.amethyst.model.HexKey
+
+@Immutable
+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() = taggedUsers()
+
+    fun awardDefinition() = taggedAddresses()
+
+    companion object {
+        const val kind = 8
+    }
+}

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

@@ -0,0 +1,26 @@
+package com.vitorpamplona.amethyst.service.model
+
+import androidx.compose.runtime.Immutable
+import com.vitorpamplona.amethyst.model.HexKey
+
+@Immutable
+class BadgeDefinitionEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig), AddressableEvent {
+    override fun dTag() = tags.firstOrNull { it.size > 1 && it[0] == "d" }?.get(1) ?: ""
+    override fun address() = ATag(kind, pubKey, dTag(), null)
+
+    fun name() = tags.firstOrNull { it.size > 1 && it[0] == "name" }?.get(1)
+    fun thumb() = tags.firstOrNull { it.size > 1 && it[0] == "thumb" }?.get(1)
+    fun image() = tags.firstOrNull { it.size > 1 && it[0] == "image" }?.get(1)
+    fun description() = tags.firstOrNull { it.size > 1 && it[0] == "description" }?.get(1)
+
+    companion object {
+        const val kind = 30009
+    }
+}

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

@@ -0,0 +1,29 @@
+package com.vitorpamplona.amethyst.service.model
+
+import androidx.compose.runtime.Immutable
+import com.vitorpamplona.amethyst.model.HexKey
+
+@Immutable
+class BadgeProfilesEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig), AddressableEvent {
+    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
+    }
+
+    override fun dTag() = tags.filter { it.firstOrNull() == "d" }.mapNotNull { it.getOrNull(1) }.firstOrNull() ?: ""
+    override fun address() = ATag(kind, pubKey, dTag(), null)
+
+    companion object {
+        const val kind = 30008
+    }
+}

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

@@ -0,0 +1,127 @@
+package com.vitorpamplona.amethyst.service.model
+
+import android.util.Log
+import androidx.compose.runtime.Immutable
+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
+
+@Immutable
+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
+    private var citedNotesCache: 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
+
+            try {
+                val parsed = Nip19.parseComponents(uriScheme, type, key, additionalChars)
+
+                if (parsed != null) {
+                    val tag = tags.firstOrNull { it.size > 1 && it[1] == parsed.hex }
+
+                    if (tag != null && tag[0] == "p") {
+                        returningList.add(tag[1])
+                    }
+                }
+            } catch (e: Exception) {
+                Log.w("Unable to parse cited users that matched a NIP19 regex", e)
+            }
+        }
+
+        citedUsersCache = returningList
+        return returningList
+    }
+
+    fun findCitations(): Set<HexKey> {
+        citedNotesCache?.let { return it }
+
+        val citations = mutableSetOf<HexKey>()
+        // 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) {
+                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) {
+                }
+            }
+        }
+
+        citedNotesCache = citations
+        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 }
+        }
+    }
+}

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

@@ -0,0 +1,56 @@
+package com.vitorpamplona.amethyst.service.model
+
+import androidx.compose.runtime.Immutable
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.toHexKey
+import nostr.postr.Utils
+import java.util.Date
+
+@Immutable
+class BookmarkListEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : GeneralListEvent(id, pubKey, createdAt, kind, tags, content, sig) {
+    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 content = createPrivateTags(privEvents, privUsers, privAddresses, 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())
+        }
+    }
+}

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

@@ -1,44 +1,50 @@
 package com.vitorpamplona.amethyst.service.model
 
-import java.util.Date
+import android.util.Log
+import androidx.compose.runtime.Immutable
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.toHexKey
 import nostr.postr.Utils
-import nostr.postr.events.Event
-import nostr.postr.events.MetadataEvent
+import java.util.Date
 
-class ChannelCreateEvent (
-  id: ByteArray,
-  pubKey: ByteArray,
-  createdAt: Long,
-  tags: List<List<String>>,
-  content: String,
-  sig: ByteArray
-): Event(id, pubKey, createdAt, kind, tags, content, sig) {
-  @Transient val channelInfo: ChannelData
-
-  init {
-    try {
-      channelInfo = MetadataEvent.gson.fromJson(content, ChannelData::class.java)
+@Immutable
+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) {
-      throw Error("can't parse $content", e)
+        Log.e("ChannelMetadataEvent", "Can't parse channel info $content", e)
+        ChannelData(null, null, null)
     }
-  }
 
-  companion object {
-    const val kind = 40
+    companion object {
+        const val kind = 40
 
-    fun create(channelInfo: ChannelData?, privateKey: ByteArray, createdAt: Long = Date().time / 1000): ChannelCreateEvent {
-      val content = if (channelInfo != null)
-        gson.toJson(channelInfo)
-      else
-        ""
+        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)
-      val tags = emptyList<List<String>>()
-      val id = generateId(pubKey, createdAt, kind, tags, content)
-      val sig = Utils.sign(id, privateKey)
-      return ChannelCreateEvent(id, pubKey, createdAt, tags, content, sig)
+            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?)
-}
+    data class ChannelData(var name: String?, var about: String?, var picture: String?)
+}

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

@@ -1,38 +1,35 @@
 package com.vitorpamplona.amethyst.service.model
 
-import java.util.Date
+import androidx.compose.runtime.Immutable
+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 ChannelHideMessageEvent (
-  id: ByteArray,
-  pubKey: ByteArray,
-  createdAt: Long,
-  tags: List<List<String>>,
-  content: String,
-  sig: ByteArray
-): Event(id, pubKey, createdAt, kind, tags, content, sig) {
-  @Transient val eventsToHide: List<String>
+@Immutable
+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) }
 
-  init {
-    eventsToHide = tags.filter { it.firstOrNull() == "e" }.mapNotNull { it.getOrNull(1) }
-  }
+    companion object {
+        const val kind = 43
 
-  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()
 
-    fun create(reason: String, messagesToHide: List<String>?, mentions: List<String>?, privateKey: ByteArray, createdAt: Long = Date().time / 1000): ChannelHideMessageEvent {
-      val content = reason
-      val pubKey = Utils.pubkeyCreate(privateKey)
-      val tags =
-        messagesToHide?.map {
-          listOf("e", it)
-        } ?: emptyList()
-
-      val id = generateId(pubKey, createdAt, kind, tags, content)
-      val sig = Utils.sign(id, privateKey)
-      return ChannelHideMessageEvent(id, pubKey, createdAt, tags, content, sig)
+            val id = generateId(pubKey, createdAt, kind, tags, reason)
+            val sig = Utils.sign(id, privateKey)
+            return ChannelHideMessageEvent(id.toHexKey(), pubKey, createdAt, tags, reason, sig.toHexKey())
+        }
     }
-  }
-}
+}

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

@@ -1,47 +1,63 @@
 package com.vitorpamplona.amethyst.service.model
 
-import java.util.Date
+import androidx.compose.runtime.Immutable
+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 ChannelMessageEvent (
-  id: ByteArray,
-  pubKey: ByteArray,
-  createdAt: Long,
-  tags: List<List<String>>,
-  content: String,
-  sig: ByteArray
-): Event(id, pubKey, createdAt, kind, tags, content, sig) {
-  @Transient val channel: String?
-  @Transient val replyTos: List<String>
-  @Transient val mentions: List<String>
+@Immutable
+class ChannelMessageEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : BaseTextNoteEvent(id, pubKey, createdAt, kind, tags, content, sig) {
 
-  init {
-    channel = tags.firstOrNull { it[0] == "e" && it.size > 3 && it[3] == "root" }?.getOrNull(1) ?: tags.firstOrNull { it.firstOrNull() == "e" }?.getOrNull(1)
-    replyTos = tags.filter { it.getOrNull(1) != channel }.mapNotNull { it.getOrNull(1) }
-    mentions = tags.filter { it.firstOrNull() == "p" }.mapNotNull { it.getOrNull(1) }
-  }
+    fun channel() = tags.firstOrNull {
+        it.size > 3 && it[0] == "e" && it[3] == "root"
+    }?.get(1) ?: tags.firstOrNull {
+        it.size > 1 && it[0] == "e"
+    }?.get(1)
 
-  companion object {
-    const val kind = 42
+    override fun replyTos() = tags.filter { it.firstOrNull() == "e" && it.getOrNull(1) != channel() }.mapNotNull { it.getOrNull(1) }
 
-    fun create(message: String, channel: String, replyTos: List<String>? = null, mentions: List<String>? = null, privateKey: ByteArray, createdAt: Long = Date().time / 1000): ChannelMessageEvent {
-      val content = message
-      val pubKey = Utils.pubkeyCreate(privateKey)
-      val tags = mutableListOf(
-        listOf("e", channel, "", "root")
-      )
-      replyTos?.forEach {
-        tags.add(listOf("e", it))
-      }
-      mentions?.forEach {
-        tags.add(listOf("p", it))
-      }
+    companion object {
+        const val kind = 42
 
-      val id = generateId(pubKey, createdAt, kind, tags, content)
-      val sig = Utils.sign(id, privateKey)
-      return ChannelMessageEvent(id, pubKey, createdAt, tags, content, sig)
+        fun create(
+            message: String,
+            channel: String,
+            replyTos: List<String>? = null,
+            mentions: List<String>? = null,
+            zapReceiver: String?,
+            privateKey: ByteArray,
+            createdAt: Long = Date().time / 1000,
+            markAsSensitive: Boolean
+        ): 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))
+            }
+            if (markAsSensitive) {
+                tags.add(listOf("content-warning", ""))
+            }
+
+            val id = generateId(pubKey, createdAt, kind, tags, content)
+            val sig = Utils.sign(id, privateKey)
+            return ChannelMessageEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
+        }
     }
-  }
-}
+}

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

@@ -1,46 +1,46 @@
 package com.vitorpamplona.amethyst.service.model
 
-import java.util.Date
-import nostr.postr.ContactMetaData
+import android.util.Log
+import androidx.compose.runtime.Immutable
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.toHexKey
 import nostr.postr.Utils
-import nostr.postr.events.Event
-import nostr.postr.events.MetadataEvent
-import nostr.postr.toHex
+import java.util.Date
 
-class ChannelMetadataEvent (
-  id: ByteArray,
-  pubKey: ByteArray,
-  createdAt: Long,
-  tags: List<List<String>>,
-  content: String,
-  sig: ByteArray
-): Event(id, pubKey, createdAt, kind, tags, content, sig) {
-  @Transient val channel: String?
-  @Transient val channelInfo: ChannelCreateEvent.ChannelData
+@Immutable
+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.size > 1 && it[0] == "e" }?.get(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)
+        }
 
-  init {
-    channel = tags.firstOrNull { it.firstOrNull() == "e" }?.getOrNull(1)
-    try {
-      channelInfo = MetadataEvent.gson.fromJson(content, ChannelCreateEvent.ChannelData::class.java)
-    } catch (e: Exception) {
-      throw Error("can't parse $content", e)
+    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())
+        }
     }
-  }
-
-  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)
-      val tags = listOf( listOf("e", originalChannelIdHex, "", "root") )
-      val id = generateId(pubKey, createdAt, kind, tags, content)
-      val sig = Utils.sign(id, privateKey)
-      return ChannelMetadataEvent(id, pubKey, createdAt, tags, content, sig)
-    }
-  }
-}
+}

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

@@ -1,39 +1,37 @@
 package com.vitorpamplona.amethyst.service.model
 
-import java.util.Date
+import androidx.compose.runtime.Immutable
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.toHexKey
 import nostr.postr.Utils
-import nostr.postr.events.Event
-import nostr.postr.events.MetadataEvent
-import nostr.postr.toHex
+import java.util.Date
 
-class ChannelMuteUserEvent (
-  id: ByteArray,
-  pubKey: ByteArray,
-  createdAt: Long,
-  tags: List<List<String>>,
-  content: String,
-  sig: ByteArray
-): Event(id, pubKey, createdAt, kind, tags, content, sig) {
-  @Transient val usersToMute: List<String>
+@Immutable
+class ChannelMuteUserEvent(
+    id: HexKey,
+    pubKey: HexKey,
+    createdAt: Long,
+    tags: List<List<String>>,
+    content: String,
+    sig: HexKey
+) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
 
-  init {
-    usersToMute = tags.filter { it.firstOrNull() == "p" }.mapNotNull { it.getOrNull(1) }
-  }
+    fun usersToMute() = tags.filter { it.firstOrNull() == "p" }.mapNotNull { it.getOrNull(1) }
 
-  companion object {
-    const val kind = 44
+    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)
-      val tags =
-        usersToMute?.map {
-          listOf("p", it)
-        } ?: emptyList()
+        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, pubKey, createdAt, tags, content, sig)
+            val id = generateId(pubKey, createdAt, kind, tags, content)
+            val sig = Utils.sign(id, privateKey)
+            return ChannelMuteUserEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
+        }
     }
-  }
-}
+}

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 androidx.compose.runtime.Immutable
+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
+
+@Immutable
+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.size > 1 && it[0] == "p" }.mapNotNull {
+            try {
+                decodePublicKey(it[1]).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)
+}

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

@@ -0,0 +1,32 @@
+package com.vitorpamplona.amethyst.service.model
+
+import androidx.compose.runtime.Immutable
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.toHexKey
+import nostr.postr.Utils
+import java.util.Date
+
+@Immutable
+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())
+        }
+    }
+}

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

@@ -0,0 +1,302 @@
+package com.vitorpamplona.amethyst.service.model
+
+import android.util.Log
+import androidx.compose.runtime.Immutable
+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.*
+
+@Immutable
+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 hasAnyTaggedUser() = tags.any { it.size > 1 && it[0] == "p" }
+
+    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] }
+
+    fun taggedUrls() = tags.filter { it.size > 1 && it[0] == "r" }.map { it[1] }
+
+    override fun isSensitive() = tags.any {
+        (it.size > 0 && it[0].equals("content-warning", true)) ||
+            (it.size > 1 && it[0] == "t" && it[1].equals("nsfw", true)) ||
+            (it.size > 1 && it[0] == "t" && it[1].equals("nude", true))
+    }
+
+    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.firstOrNull { it.size > 1 && it[0] == "reward" }?.get(1)?.let { BigDecimal(it) }
+        } 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 {
+        return try {
+            id.contentEquals(generateId()) && secp256k1.verifySchnorr(Hex.decode(sig), Hex.decode(id), Hex.decode(pubKey))
+        } catch (e: Exception) {
+            Log.e("Event", "Fail checking if event $id has a valid signature", e)
+            false
+        }
+    }
+
+    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 MessageDigest.getInstance("SHA-256").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 gson: Gson = GsonBuilder()
+            .disableHtmlEscaping()
+            .registerTypeAdapter(Event::class.java, EventSerializer())
+            .registerTypeAdapter(Event::class.java, EventDeserializer())
+            .registerTypeAdapter(ByteArray::class.java, ByteArraySerializer())
+            .registerTypeAdapter(ByteArray::class.java, ByteArrayDeserializer())
+            .registerTypeAdapter(Response::class.java, ResponseDeserializer())
+            .registerTypeAdapter(Request::class.java, RequestDeserializer())
+            .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) {
+            AppDefinitionEvent.kind -> AppDefinitionEvent(id, pubKey, createdAt, tags, content, sig)
+            AppRecommendationEvent.kind -> AppRecommendationEvent(id, pubKey, createdAt, tags, content, sig)
+            AudioTrackEvent.kind -> AudioTrackEvent(id, pubKey, createdAt, tags, content, sig)
+            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)
+            HighlightEvent.kind -> HighlightEvent(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)
+            PeopleListEvent.kind -> PeopleListEvent(id, pubKey, createdAt, tags, content, sig)
+            PinListEvent.kind -> PinListEvent(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)
+            RelaySetEvent.kind -> RelaySetEvent(id, pubKey, createdAt, tags, content, sig)
+            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 MessageDigest.getInstance("SHA-256").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)
+        }
+    }
+}
+
+@Immutable
+interface AddressableEvent {
+    fun dTag(): String
+    fun address(): ATag
+}

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

@@ -0,0 +1,41 @@
+package com.vitorpamplona.amethyst.service.model
+
+import androidx.compose.runtime.Immutable
+import com.vitorpamplona.amethyst.model.HexKey
+import java.math.BigDecimal
+
+@Immutable
+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?
+    fun isSensitive(): Boolean
+}

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

@@ -0,0 +1,77 @@
+package com.vitorpamplona.amethyst.service.model
+
+import androidx.compose.runtime.Immutable
+import com.vitorpamplona.amethyst.model.HexKey
+import com.vitorpamplona.amethyst.model.toHexKey
+import nostr.postr.Utils
+import java.util.Date
+
+@Immutable
+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 dimensions() = tags.firstOrNull { it.size > 1 && it[0] == DIMENSION }?.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 DIMENSION = "dim"
+        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,
+            dimensions: 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) },
+                dimensions?.let { listOf(DIMENSION, 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)