Fix reposts banner to be localizable

Changelog-Fixed: Fixed reposts banner to be localizable
Signed-off-by: Terry Yiu <git@tyiu.xyz>

.github/ISSUE_TEMPLATE/app_release.md

@@ -0,0 +1,52 @@
+---
+name: App release process
+about: Begin preparing for a new app release
+title: 'Release: '
+labels: release-tasks
+assignees: ''
+
+---
+
+A new version release. Please attempt to follow the release process steps below in the order they are shown.
+
+## TestFlight release candidates
+
+### Release candidate 1
+
+**Version:** _[Enter full build information for the release candidate, including major and minor version number, build number, and commit hash]_
+
+1. [ ] Merge in all needed changes to `master`
+2. [ ] Check CI, make sure it is passing
+3. [ ] Prepare preliminary changelog as a draft PR: _[Enter PR link to changelog here]_
+4. [ ] Make a _release_ build and submit to the internal TestFlight group via our new Release candidate workflow in Xcode Cloud.
+5. [ ] Prepare short screencast style video with main changes for the announcement
+6. [ ] Publish release build to these TestFlight groups:
+    - [ ] Alpha testers group
+    - [ ] Translators group
+    - [ ] Purple group
+7. [ ] Publish announcement on Nostr
+
+
+_[Duplicate this release candidate section if there is more than one release candidate]_
+
+
+## App Store release
+
+1. [ ] Release candidate checks:
+    - [ ] Release candidate has been on Purple TestFlight for at least one week
+    - [ ] No blocker issues came from feedback from Purple users (double-check)
+    - [ ] Check with stakeholders
+    - [ ] Check with developers & product for any release showstoppers (e.g., critical newfound bugs)
+2. [ ] Thorough check on release notes
+3. [ ] Submit to App Store review (with manual publishing setting enabled)
+4. [ ] Get App Store approval from Apple
+5. [ ] Prepare announcement
+7. [ ] Publish on the App Store and make announcement
+8. [ ] Publish changelog and tag commit hash corresponding to the release
+9. [ ] Perform a version bump on the repository, in preparation for the next release
+
+
+## Notes/others
+
+_Enter any relevant notes here_
+

.github/pull_request_template.md

@@ -0,0 +1,36 @@
+## Summary
+
+_[Please provide a summary of the changes in this PR.]_
+
+## Checklist
+
+- [ ] I have read (or I am familiar with) the [Contribution Guidelines](../docs/CONTRIBUTING.md)
+- [ ] I have tested the changes in this PR
+- [ ] My PR is either small, or I have split it into smaller logical commits that are easier to review
+- [ ] I have added the signoff line to all my commits. See [Signing off your work](../docs/CONTRIBUTING.md#sign-your-work---the-developers-certificate-of-origin)
+- [ ] I have added appropriate changelog entries for the changes in this PR. See [Adding changelog entries](../docs/CONTRIBUTING.md#add-changelog-changed-changelog-fixed-etc)
+    - [ ] I do not need to add a changelog entry. Reason: _[Please provide a reason]_
+- [ ] I have added appropriate `Closes:` or `Fixes:` tags in the commit messages wherever applicable, or made sure those are not needed. See [Submitting patches](https://github.com/damus-io/damus/blob/master/docs/CONTRIBUTING.md#submitting-patches)
+
+## Test report
+
+_Please provide a test report for the changes in this PR. You can use the template below, but feel free to modify it as needed._
+
+**Device:** _[Please specify the device you used for testing]_
+
+**iOS:** _[Please specify the iOS version you used for testing]_
+
+**Damus:** _[Please specify the Damus version or commit hash you used for testing]_
+
+**Setup:** _[Please provide a brief description of the setup you used for testing, if applicable]_
+
+**Steps:** _[Please provide a list of steps you took to test the changes in this PR]_
+
+**Results:**
+- [ ] PASS
+- [ ] Partial PASS
+  - Details: _[Please provide details of the partial pass]_
+
+## Other notes
+
+_[Please provide any other information that you think is relevant to this PR.]_

ACKNOWLEDGEMENTS.md

@@ -0,0 +1,5 @@
+### Acknowledgements and licenses
+
+1. This product contains code derived from [Nostr SDK iOS](https://github.com/nostr-sdk/nostr-sdk-ios). [License](https://github.com/nostr-sdk/nostr-sdk-ios/blob/40df800c6749d7ce0b6fd7328e76cbc0dc71c87b/LICENSE)
+2. This product includes software developed by the "Marcin Krzyzanowski" (http://krzyzanowskim.com/). [License](https://github.com/krzyzanowskim/CryptoSwift/blob/e74bbbfbef939224b242ae7c342a90e60b88b5ce/LICENSE)
+

CHANGELOG.md

@@ -1,3 +1,236 @@
+## [1.12.3] - 2025-02-06
+
+### Added
+
+- Purple members who have been active for more than a year now get a special badge (Daniel D’Aquino)
+
+### Changed
+
+- Improved clarity of the mute button to indicate it can be used for blocking a user (Daniel D’Aquino)
+- Made the microphone access request message more clear to users (Daniel D’Aquino)
+
+[v1.12.3]: https://github.com/damus-io/damus/releases/tag/v1.12.3
+
+
+## [1.12](https://github.com/damus-io/damus/releases/tag/v1.12) - 2024-12-20
+
+### Added
+
+- Render Gif and video files while composing posts (Swift Coder)
+- Add profile info text in stretchable banner with follow button (Swift Coder)
+- Paste Gif image similar to jpeg and png files (Swift Coder)
+
+
+### Changed
+
+- Improved UX around the label for searching words (Daniel D’Aquino)
+- Improved accessibility support on some elements (Daniel D’Aquino)
+
+
+### Fixed
+
+- Fixed issue where the "next" button would appear hidden and hard to click on the create account view (Daniel D’Aquino)
+- Fix non scrollable wallet screen (Swift Coder)
+- Fixed suggested users category titles to be localizable (Terry Yiu)
+- Fixed GradientFollowButton to have consistent width and autoscale text limited to 1 line (Terry Yiu)
+- Fixed right-to-left localization issues (Terry Yiu)
+- Fixed AddMuteItemView to trim leading and trailing whitespaces from mute text and disallow adding text with only whitespaces (Terry Yiu)
+- Fixed SideMenuView text to autoscale and limit to 1 line (Terry Yiu)
+- Fixed an issue where a profile would need to be input twice in the search to be found (Daniel D’Aquino)
+- Fixed non-breaking spaces in localized strings (Terry Yiu)
+- Fixed localization issue on Add mute item button (Terry Yiu)
+- Replace non-breaking spaces with regular spaces as Apple's NSLocalizedString macro does not seem to work with it (Terry Yiu)
+- Fixed localization issues in RelayConfigView (Terry Yiu)
+- Fix duplicate uploads (Swift Coder)
+- Remove duplicate pubkey from Follow Suggestion list (Swift Coder)
+- Fix Page control indicator (Swift Coder)
+- Fix damus sharing issues (Swift Coder)
+- Fixed issue where banner edit button is unclickable (Daniel D’Aquino)
+- Handle empty notification pages by displaying suitable text (Swift Coder)
+
+[v1.12](https://github.com/damus-io/damus/releases/tag/v1.12): [https://github.com/damus-io/damus/releases/tag/v1.12]
+
+
+## [v1.11(10)](https://github.com/damus-io/damus/releases/tag/v1.11-10) - 2024-11-18
+
+### Added
+
+- Add Damus Share Feature (Swift)
+- Added new easy to use video controls for full screen video (Daniel D’Aquino)
+- Add Edit, Share, and Tap-gesture in Profile pic image viewer (Swift Coder)
+- Disappearing header, tabbar, and post button on scroll (ericholguin)
+- Add Apple translation popovers for notes for iOS 17.4+ and macOS 14.4+ (Terry Yiu)
+- Added NDB search functionality to the universe view (ericholguin)
+- Added mute button to ProfileActionSheet (chungwwei)
+- Added mute action to selected text menu (ericholguin)
+- Added support for pasting images from the clipboard to the post composer (Swift Coder)
+
+### Changed
+
+- Improved image carousel image fill behavior (Daniel D’Aquino)
+- Improved video syncing and bandwidth usage when switching between timeline video and full screen mode (Daniel D’Aquino)
+- Swipe to dismiss on full screen carousel now shows an opacity effect for improved UX (Daniel D’Aquino)
+- Removed event contents from full screen media carousel for cleaner view (Daniel D’Aquino)
+- Add share button for images on full screen image carousel view (Swift)
+- Changed boldness of font in side menu labels. (ericholguin)
+- Changed search notes button with searched keyword (ericholguin)
+- Changed opacity of tabbar and post button (ericholguin)
+- Allow multiple images to be uploaded at the same time (swiftcoder) (William Casarin)
+- Changed side menu design (ericholguin)
+- Truncate fulltext search results (William Casarin)
+- Expanded profile search results to 128 (William Casarin)
+- Expand nostrdb text search results to 128 items (William Casarin)
+- Use LazyVStack in text search results (William Casarin)
+
+### Fixed
+
+- Fixed missing tab bar on navigation (Swift Coder)
+- Fixed some issues where QR code would not work, and improved UX (Daniel D’Aquino)
+- Fixed iOS 18 gesture issues that would take user to the thread view when clicking on a video or unmuting it (Daniel D’Aquino)
+- Fixed several issues that would cause video to automatically play or pause incorrectly (Daniel D’Aquino)
+- Fixed issue where full screen video would disappear when going to landscape mode (Daniel D’Aquino)
+- Fixed portrait video size on full screen carousel (Daniel D’Aquino)
+- Fix avatar image on qrcode view (Swift Coder)
+- Fix banner image upload (Swift Coder)
+- Fix dismiss button visibility (Swift Coder)
+- Fix quote repost counting (William Casarin)
+- Fixed overlapping text in Universe View (ericholguin)
+- Fixed localization issues and exported strings (Terry Yiu)
+- Fix sensitive long-press gesture on event chat bubble in iOS 18 (Daniel D’Aquino)
+- Fixed bottom padding for tabbar (ericholguin)
+- Fixed localization build failures (Terry Yiu)
+- Fixed back nav button placement in profile edit view (ericholguin)
+- Friend profiles will now more likely show up in profile search (William Casarin)
+- Fix broken QR code scanner and fix landscape mode (Terry Yiu)
+
+[1.11(10)](https://github.com/damus-io/damus/releases/tag/v1.11-10): https://github.com/damus-io/damus/releases/tag/v1.11-10
+
+## [1.10.1] - 2024-09-22
+
+### Added
+
+- Push notification support (Daniel D’Aquino)
+- Added profile edit safe guards (Eric Holguin)
+- Tor relay icon (ericholguin)
+- Add highlighter for web pages (Daniel D’Aquino)
+- Add support for adding comments when creating a highlight (Daniel D’Aquino)
+- Add support for rendering highlights with comments (Daniel D’Aquino)
+- Ability to create highlights (ericholguin)
+- Highlights (NIP-84) (ericholguin)
+- Revamp emoji picker to be less error-prone and add search, frequently used, and multiple skin tone support capabilities (Terry Yiu)
+
+
+### Changed
+
+- Improve notification view filtering UX (Daniel D’Aquino)
+- Improve visibility of friends filter button (Daniel D’Aquino)
+- Changed the default banner from ostriches to damoose (Eric Holguin)
+- Changed image and banner url text fields to new sheet view (Eric Holguin)
+- Onboarding design (ericholguin)
+
+
+### Fixed
+
+- Fix items that became unclickable on iOS 18 (Daniel D’Aquino)
+- Fix many reconnection issues (William Casarin)
+- Fixed issue where theme would be changed to black and can't be switched back on iOS 18 (cr0bar)
+- Fixed some scenarios where the contact list would never be saved locally and cause issues when switching relays. (Daniel D’Aquino)
+- Fix albyhub zaps not appearing (William Casarin)
+- Fix inadvertent escape from mention suggestion menu when typing a space character (Daniel D’Aquino)
+- Fix profile view toolbar alignment bug in iOS 18 (Terry Yiu)
+- Create Account model now uses correct metadata (ericholguin)
+- Restore localization for custom tabs (William Casarin)
+- Fix iOS 18 reflection runtime error for custom picker (William Casarin)
+
+
+[1.10.1]: https://github.com/damus-io/damus/releases/tag/v1.10.1
+
+
+## [1.9.1 (4)] - 2024-08-13
+
+### Fixed
+
+- Fix crash when viewing notes with invalid image dimension metadata (Daniel D’Aquino)
+
+[1.9.1 (4)]: https://github.com/damus-io/damus/releases/tag/v1.9.1-4
+
+
+## [1.9 (14)] - 2024-07-14
+
+### Added
+
+- Completely new threads experience that is easier and more pleasant to use (Daniel D’Aquino)
+- Add emoji search to emoji picker (Terry Yiu)
+
+
+### Changed
+
+- Added first aid contact damus support email (alltheseas)
+- Disable mutiny wallet button (William Casarin)
+- Make friends show up first when searching for profiles (Terry Yiu)
+
+
+### Fixed
+
+- Fix crash on profile page when there are profile updates (William Casarin)
+- Fix crash when adding duplicate mute items (William Casarin)
+- Fix pretty bad crash when building flatbuffer profiles (William Casarin)
+- Fix reactions view to not show reactions from replies on parent note (Terry Yiu)
+- Fix missing Mute button in profile view menu (Terry Yiu)
+- Fixed wallet not disconnecting when a user logs out (ericholguin)
+- Fix stale feed issue when follow list is too big (Daniel D’Aquino)
+
+[1.9 (14)]: https://github.com/damus-io/damus/releases/tag/v1.9-14
+
+## [1.8] - 2024-05-11
+
+### Added
+
+- Added nip10 marker replies (William Casarin)
+- Add marker nip10 support when reading notes (William Casarin)
+- Added title image and tags to longform events (ericholguin)
+- Add First Aid solution for users who do not have a contact list created for their account (Daniel D’Aquino)
+- Relay fees metadata (ericholguin)
+- Added callbackuri for a better ux when connecting mutiny wallet nwc (ericholguin)
+- Add event content preview to the full screen carousel (Daniel D’Aquino)
+- Show list of quoted reposts in threads (William Casarin)
+- Proxy Tags are now viewable on Selected Events (ericholguin)
+- Connect to Mutiny Wallet Button (ericholguin)
+- Add ability to mute words, add new mutelist interface (Charlie) (William Casarin)
+- Add ability to mute hashtag from SearchView (Charlie Fish)
+
+
+### Changed
+
+- Change reactions to use a native looking emoji picker (Terry Yiu)
+- Relay detail design (ericholguin)
+- Updated Zeus logo (ericholguin)
+- Improve UX around video playback (Daniel D’Aquino)
+- Moved paste nwc button to main wallet view (ericholguin)
+- Errors with an NWC will show as an alert (ericholguin)
+- Relay config view user interface (ericholguin)
+- Always strip GPS data from images (kernelkind)
+
+
+### Fixed
+
+- Fix thread bug where a quote isn't picked up as a reply (William Casarin)
+- Fixed threads not loading sometimes (William Casarin)
+- Fixed issue where some replies were including the q tag (William Casarin)
+- Fixed issue where timeline was scrolling when it isn't supposed to (William Casarin)
+- Fix issue where bootstrap relays would inadvertently be added to the user's list on connectivity issues (Daniel D’Aquino)
+- Fix broken GIF uploads (Daniel D’Aquino)
+- Fix ghost notifications caused by Purple impending expiration notifications (Daniel D’Aquino)
+- Improve reliability of contact list creation during onboarding (Daniel D’Aquino)
+- Fix emoji reactions being cut off (ericholguin)
+- Fix image indicators to limit number of dots to not spill screen beyond visible margins (ericholguin)
+- Fix bug that would cause connection issues with relays defined with a trailing slash URL, and an inability to delete them. (Daniel D’Aquino)
+- Issue where NWC Scanner view would not dismiss after a failed scan/paste (ericholguin)
+
+
+
+[1.8]: https://github.com/damus-io/damus/releases/tag/v1.8
+
 ## [1.7-rc2] - 2024-02-28
 
 ### Added

DamusNotificationService/DamusNotificationService.entitlements

@@ -2,6 +2,8 @@
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
+	<key>com.apple.developer.kernel.extended-virtual-addressing</key>
+	<true/>
 	<key>com.apple.security.app-sandbox</key>
 	<true/>
 	<key>com.apple.security.application-groups</key>
@@ -10,5 +12,9 @@
 	</array>
 	<key>com.apple.security.network.client</key>
 	<true/>
+	<key>keychain-access-groups</key>
+	<array>
+		<string>$(AppIdentifierPrefix)com.jb55.damus2</string>
+	</array>
 </dict>
 </plist>

DamusNotificationService/NotificationFormatter.swift

@@ -55,6 +55,9 @@ struct NotificationFormatter {
         var identifier = ""
         
         switch notify.type {
+            case .tagged:
+                title = String(format: NSLocalizedString("Tagged by %@", comment: "Tagged by heading in local notification"), displayName)
+                identifier = "myMentionNotification"
             case .mention:
                 title = String(format: NSLocalizedString("Mentioned by %@", comment: "Mentioned by heading in local notification"), displayName)
                 identifier = "myMentionNotification"
@@ -70,6 +73,9 @@ struct NotificationFormatter {
             case .zap, .profile_zap:
                 // not handled here. Try `format_message(displayName: String, notify: LocalNotification, state: HeadlessDamusState) async -> (content: UNMutableNotificationContent, identifier: String)?`
                 return nil
+            case .reply:
+                title = String(format: NSLocalizedString("%@ replied to your note", comment: "Heading for local notification indicating a new reply"), displayName)
+                identifier = "myReplyNotification"
         }
         content.title = title
         content.body = notify.content
@@ -87,10 +93,11 @@ struct NotificationFormatter {
         
         // If it does not work, try async formatting methods
         let content = UNMutableNotificationContent()
-        
+
         switch notify.type {
             case .zap, .profile_zap:
                 guard let zap = await get_zap(from: notify.event, state: state) else {
+                    Log.debug("format_message: async get_zap failed", for: .push_notifications)
                     return nil
                 }
                 content.title = Self.zap_notification_title(zap)

DamusNotificationService/NotificationService.swift

@@ -27,9 +27,9 @@ class NotificationService: UNNotificationServiceExtension {
         // Log that we got a push notification
         Log.debug("Got nostr event push notification from pubkey %s", for: .push_notifications, nostr_event.pubkey.hex())
         
-        guard let state = NotificationExtensionState(),
-              let display_name = state.ndb.lookup_profile(nostr_event.pubkey)?.unsafeUnownedValue?.profile?.display_name  // We are not holding the txn here.
-        else {
+        guard let state = NotificationExtensionState() else {
+            Log.debug("Failed to open nostrdb", for: .push_notifications)
+
             // Something failed to initialize so let's go for the next best thing
             guard let improved_content = NotificationFormatter.shared.format_message(event: nostr_event) else {
                 // We cannot format this nostr event. Suppress notification.
@@ -39,7 +39,11 @@ class NotificationService: UNNotificationServiceExtension {
             contentHandler(improved_content)
             return
         }
-        
+
+        let txn = state.ndb.lookup_profile(nostr_event.pubkey)
+        let profile = txn?.unsafeUnownedValue?.profile
+        let name = Profile.displayName(profile: profile, pubkey: nostr_event.pubkey).displayName
+
         // Don't show notification details that match mute list.
         // TODO: Remove this code block once we get notification suppression entitlement from Apple. It will be covered by the `guard should_display_notification` block
         if state.mutelist_manager.is_event_muted(nostr_event) {
@@ -54,6 +58,7 @@ class NotificationService: UNNotificationServiceExtension {
         }
         
         guard should_display_notification(state: state, event: nostr_event, mode: .push) else {
+            Log.debug("should_display_notification failed", for: .push_notifications)
             // We should not display notification for this event. Suppress notification.
             // contentHandler(UNNotificationContent())
             // TODO: We cannot really suppress until we have the notification supression entitlement. Show the raw notification
@@ -62,6 +67,7 @@ class NotificationService: UNNotificationServiceExtension {
         }
         
         guard let notification_object = generate_local_notification_object(from: nostr_event, state: state) else {
+            Log.debug("generate_local_notification_object failed", for: .push_notifications)
             // We could not process this notification. Probably an unsupported nostr event kind. Suppress.
             // contentHandler(UNNotificationContent())
             // TODO: We cannot really suppress until we have the notification supression entitlement. Show the raw notification
@@ -70,9 +76,13 @@ class NotificationService: UNNotificationServiceExtension {
         }
         
         Task {
-            if let (improvedContent, _) = await NotificationFormatter.shared.format_message(displayName: display_name, notify: notification_object, state: state) {
-                contentHandler(improvedContent)
+            guard let (improvedContent, _) = await NotificationFormatter.shared.format_message(displayName: name, notify: notification_object, state: state) else {
+
+                Log.debug("NotificationFormatter.format_message failed", for: .push_notifications)
+                return
             }
+
+            contentHandler(improvedContent)
         }
     }
     

README.md

@@ -8,7 +8,7 @@ A twitter-like [nostr][nostr] client for iPhone, iPad and MacOS.
 
 [nostr]: https://github.com/fiatjaf/nostr
 
-## How is Damus better than twitter?
+## How is Damus better than X/Twitter?
 There are no toxic algorithms.\
 You can send or receive zaps (satoshis) without asking for permission.\
 [There is no central database](https://fiatjaf.com/nostr.html). Therefore, Damus is censorship resistant.\

damus.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -1,6 +1,40 @@
 {
-  "originHash" : "babaf4d5748afecf49bbb702530d8e9576460692f478b0a50ee43195dd4440e2",
+  "originHash" : "085cf0f645323bf77edb52886489bf77b309a0a2d2b78a54beaf8520b540d596",
   "pins" : [
+    {
+      "identity" : "codescanner",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/twostraws/CodeScanner.git",
+      "state" : {
+        "revision" : "9fa582f4b36c69c2a55bff5fb3377eb170ae273c"
+      }
+    },
+    {
+      "identity" : "cryptoswift",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/krzyzanowskim/CryptoSwift.git",
+      "state" : {
+        "revision" : "e74bbbfbef939224b242ae7c342a90e60b88b5ce"
+      }
+    },
+    {
+      "identity" : "emojikit",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/tyiu/EmojiKit",
+      "state" : {
+        "revision" : "05805f72d63a6d6a2d7dc7fe14abd37c1317b11a",
+        "version" : "0.1.2"
+      }
+    },
+    {
+      "identity" : "emojipicker",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/tyiu/EmojiPicker.git",
+      "state" : {
+        "revision" : "0c28b4a1a6b8840cf2580bda59517f6d0a733dc8",
+        "version" : "0.1.1"
+      }
+    },
     {
       "identity" : "gsplayer",
       "kind" : "remoteSourceControl",
@@ -19,15 +53,6 @@
         "version" : "7.6.1"
       }
     },
-    {
-      "identity" : "mcemojipicker",
-      "kind" : "remoteSourceControl",
-      "location" : "https://github.com/izyumkin/MCEmojiPicker",
-      "state" : {
-        "revision" : "e0b4903b75ae1cc418d276d84d1cb946b8a1d73c",
-        "version" : "1.2.3"
-      }
-    },
     {
       "identity" : "secp256k1.swift",
       "kind" : "remoteSourceControl",
@@ -36,6 +61,15 @@
         "revision" : "40b4b38b3b1c83f7088c76189a742870e0ca06a9"
       }
     },
+    {
+      "identity" : "swift-collections",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/apple/swift-collections.git",
+      "state" : {
+        "revision" : "ee97538f5b81ae89698fd95938896dec5217b148",
+        "version" : "1.1.1"
+      }
+    },
     {
       "identity" : "swift-markdown-ui",
       "kind" : "remoteSourceControl",
@@ -62,13 +96,29 @@
         "version" : "509.0.0"
       }
     },
+    {
+      "identity" : "swift-trie",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/tyiu/swift-trie",
+      "state" : {
+        "revision" : "4c50bff6c168f74425f70476be62a072980d2da7",
+        "version" : "0.1.2"
+      }
+    },
+    {
+      "identity" : "swiftycrop",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/benedom/SwiftyCrop",
+      "state" : {
+        "revision" : "454d0a0d4faf6f3a19c8d817ab9d7d27524bd79f"
+      }
+    },
     {
       "identity" : "swipeactions",
       "kind" : "remoteSourceControl",
-      "location" : "https://github.com/aheze/SwipeActions",
+      "location" : "https://github.com/damus-io/SwipeActions.git",
       "state" : {
-        "revision" : "41e6f6dce02d8cfa164f8c5461a41340850ca3ab",
-        "version" : "1.1.0"
+        "revision" : "33d99756c3112e1a07c1732e3cddc5ad5bd0c5f4"
       }
     }
   ],

damus.xcodeproj/xcshareddata/xcschemes/HighlighterActionExtension.xcscheme

@@ -0,0 +1,101 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "1540"
+   wasCreatedForAppExtension = "YES"
+   version = "2.0">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES"
+      buildArchitectures = "Automatic">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "D703D7162C66E47100A400EA"
+               BuildableName = "HighlighterActionExtension.appex"
+               BlueprintName = "HighlighterActionExtension"
+               ReferencedContainer = "container:damus.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "4CE6DEE227F7A08100C66700"
+               BuildableName = "damus.app"
+               BlueprintName = "damus"
+               ReferencedContainer = "container:damus.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      shouldAutocreateTestPlan = "YES">
+   </TestAction>
+   <LaunchAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = ""
+      selectedLauncherIdentifier = "Xcode.IDEFoundation.Launcher.PosixSpawn"
+      launchStyle = "0"
+      askForAppToLaunch = "Yes"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      allowLocationSimulation = "YES"
+      launchAutomaticallySubstyle = "2">
+      <RemoteRunnable
+         runnableDebuggingMode = "1"
+         BundleIdentifier = "com.apple.mobilesafari"
+         RemotePath = "/Library/Developer/CoreSimulator/Volumes/iOS_21F79/Library/Developer/CoreSimulator/Profiles/Runtimes/iOS 17.5.simruntime/Contents/Resources/RuntimeRoot/Applications/MobileSafari.app">
+      </RemoteRunnable>
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "4CE6DEE227F7A08100C66700"
+            BuildableName = "damus.app"
+            BlueprintName = "damus"
+            ReferencedContainer = "container:damus.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+   </LaunchAction>
+   <ProfileAction
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES"
+      askForAppToLaunch = "Yes"
+      launchAutomaticallySubstyle = "2">
+      <BuildableProductRunnable
+         runnableDebuggingMode = "0">
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "4CE6DEE227F7A08100C66700"
+            BuildableName = "damus.app"
+            BlueprintName = "damus"
+            ReferencedContainer = "container:damus.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>

damus.xcodeproj/xcshareddata/xcschemes/damus.xcscheme

@@ -40,7 +40,7 @@
             </BuildableReference>
          </TestableReference>
          <TestableReference
-            skipped = "YES">
+            skipped = "NO">
             <BuildableReference
                BuildableIdentifier = "primary"
                BlueprintIdentifier = "4CE6DEFC27F7A08200C66700"

damus/Assets.xcassets/Colors/DamusHighlight.colorset/Contents.json

@@ -0,0 +1,38 @@
+{
+  "colors" : [
+    {
+      "color" : {
+        "color-space" : "srgb",
+        "components" : {
+          "alpha" : "1.000",
+          "blue" : "0xF2",
+          "green" : "0xD8",
+          "red" : "0xF4"
+        }
+      },
+      "idiom" : "universal"
+    },
+    {
+      "appearances" : [
+        {
+          "appearance" : "luminosity",
+          "value" : "dark"
+        }
+      ],
+      "color" : {
+        "color-space" : "srgb",
+        "components" : {
+          "alpha" : "1.000",
+          "blue" : "0x45",
+          "green" : "0x17",
+          "red" : "0x47"
+        }
+      },
+      "idiom" : "universal"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

damus/Assets.xcassets/Illustrations/damoose.imageset/Contents.json

@@ -1,7 +1,7 @@
 {
   "images" : [
     {
-      "filename" : "profile-banner.jpeg",
+      "filename" : "damoose.jpeg",
       "idiom" : "universal"
     }
   ],

damus/Assets.xcassets/Logos/Contents.json

@@ -0,0 +1,6 @@
+{
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

damus/Assets.xcassets/Logos/alby.imageset/Contents.json

@@ -0,0 +1,23 @@
+{
+  "images" : [
+    {
+      "filename" : "alby.svg",
+      "idiom" : "universal",
+      "scale" : "1x"
+    },
+    {
+      "filename" : "alby.svg",
+      "idiom" : "universal",
+      "scale" : "2x"
+    },
+    {
+      "filename" : "alby.svg",
+      "idiom" : "universal",
+      "scale" : "3x"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

damus/Assets.xcassets/Logos/coinos.imageset/Contents.json

@@ -0,0 +1,12 @@
+{
+  "images" : [
+    {
+      "filename" : "coinos.png",
+      "idiom" : "universal"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

damus/Assets.xcassets/Logos/tor.imageset/Contents.json

@@ -0,0 +1,12 @@
+{
+  "images" : [
+    {
+      "filename" : "tor.svg.png",
+      "idiom" : "universal"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

damus/Assets.xcassets/alby-go.imageset/Contents.json

@@ -0,0 +1,12 @@
+{
+  "images" : [
+    {
+      "filename" : "alby-go.png",
+      "idiom" : "universal"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

damus/Assets.xcassets/alby.imageset/Contents.json

@@ -1,23 +0,0 @@
-{
-  "images": [
-    {
-      "filename": "alby.svg",
-      "idiom": "universal",
-      "scale": "1x"
-    },
-    {
-      "idiom": "universal",
-      "scale": "2x",
-      "filename": "alby.svg"
-    },
-    {
-      "idiom": "universal",
-      "scale": "3x",
-      "filename": "alby.svg"
-    }
-  ],
-  "info": {
-    "author": "xcode",
-    "version": 1
-  }
-}

damus/Components/CustomPicker.swift

@@ -12,31 +12,25 @@ let RECTANGLE_GRADIENT = LinearGradient(gradient: Gradient(colors: [
     DamusColors.blue
 ]), startPoint: .leading, endPoint: .trailing)
 
-struct CustomPicker<SelectionValue: Hashable, Content: View>: View {
+struct CustomPicker<SelectionValue: Hashable>: View {
     
+    let tabs: [(String, SelectionValue)]
     @Environment(\.colorScheme) var colorScheme
-    
+
     @Namespace var picker
     @Binding var selection: SelectionValue
-    @ViewBuilder let content: Content
-    
+
     public var body: some View {
-        let contentMirror = Mirror(reflecting: content)
-        let blocksCount = Mirror(reflecting: contentMirror.descendant("value")!).children.count
         HStack {
-            ForEach(0..<blocksCount, id: \.self) { index in
-                let tupleBlock = contentMirror.descendant("value", ".\(index)")
-                let text = Mirror(reflecting: tupleBlock!).descendant("content") as! Text
-                let tag = Mirror(reflecting: tupleBlock!).descendant("modifier", "value", "tagged") as! SelectionValue
-                
+            ForEach(tabs, id: \.1) { (text, tag) in
                 Button {
                     withAnimation(.spring()) {
                         selection = tag
                     }
                 } label: {
-                    text
-                        .padding(EdgeInsets(top: 15, leading: 0, bottom: 10, trailing: 0))
+                    Text(text).padding(EdgeInsets(top: 15, leading: 0, bottom: 10, trailing: 0))
                         .font(.system(size: 14, weight: .heavy))
+                        .tag(tag)
                 }
                 .background(
                     Group {
@@ -52,7 +46,6 @@ struct CustomPicker<SelectionValue: Hashable, Content: View>: View {
                 .accentColor(tag == selection ? textColor() : .gray)
             }
         }
-        .background(Color(UIColor.systemBackground))
     }
     
     func textColor() -> Color {

damus/Components/DamusColors.swift

@@ -28,6 +28,7 @@ class DamusColors {
     static let green = Color("DamusGreen")
     static let purple = Color("DamusPurple")
     static let deepPurple = Color("DamusDeepPurple")
+    static let highlight = Color("DamusHighlight")
     static let blue = Color("DamusBlue")
     static let bitcoin = Color("Bitcoin")
     static let success = Color("DamusSuccessPrimary")

damus/Components/Gradients/DamusBackground.swift

@@ -20,6 +20,7 @@ struct DamusBackground: View {
             .resizable()
             .frame(maxWidth: .infinity, maxHeight: maxHeight, alignment: .center)
             .ignoresSafeArea()
+            .accessibilityHidden(true)
     }
 }
 

damus/Components/Gradients/MutinyGradient.swift

@@ -1,15 +0,0 @@
-//
-//  MutinyGradient.swift
-//  damus
-//
-//  Created by eric on 3/9/24.
-//
-
-import SwiftUI
-
-fileprivate let mutiny_grad_c1 = hex_col(r: 39, g: 95, b: 161)
-fileprivate let mutiny_grad_c2 = hex_col(r: 13, g: 33, b: 56)
-fileprivate let mutiny_grad = [mutiny_grad_c2, mutiny_grad_c1]
-
-let MutinyGradient: LinearGradient =
-    LinearGradient(colors: mutiny_grad, startPoint: .top, endPoint: .bottom)

damus/Components/ImageCarousel.swift

@@ -7,6 +7,7 @@
 
 import SwiftUI
 import Kingfisher
+import Combine
 
 // TODO: all this ShareSheet complexity can be replaced with ShareLink once we update to iOS 16
 struct ShareSheet: UIViewControllerRepresentable {
@@ -95,64 +96,203 @@ enum ImageShape {
     }
 }
 
+/// The `CarouselModel` helps `ImageCarousel` with some state management logic, keeping track of media sizes, and the ideal display size
+///
+/// This model is necessary because the state management logic required to keep track of media sizes for each one of the carousel items,
+/// and the ideal display size at each moment is not a trivial task.
+///
+/// The rules for the media fill are as follows:
+///  1. The media item should generally have a width that completely fills the width of its parent view
+///  2. The height of the carousel should be adjusted accordingly
+///  3. The only exception to rules 1 and 2 is when the total height would be 20% larger than the height of the device
+///  4. If none of the above can be computed (e.g. due to missing information), default to a reasonable height, where the media item will fit into.
+///
+/// ## Usage notes
+///
+/// The view is has the following state management responsibilities:
+///  1. Watching the size of the images (via the `.observe_image_size` modifier)
+///  2. Notifying this class of geometry reader changes, by setting `geo_size`
+///
+/// ## Implementation notes
+///
+/// This class is organized in a way to reduce stateful behavior and the transiency bugs it can cause.
+///
+/// This is accomplished through the following pattern:
+/// 1. The `current_item_fill` is a published property so that any updates instantly re-render the view
+/// 2. However, `current_item_fill` has a mathematical dependency on other members of this class
+/// 3. Therefore, the members on which the fill property depends on all have `didSet` observers that will cause the `current_item_fill` to be recalculated and published.
+///
+/// This pattern helps ensure that the state is always consistent and that the view is always up-to-date.
+/// 
+/// This class is marked as `@MainActor` since most of its properties are published and should be accessed from the main thread to avoid inconsistent SwiftUI state during renders
+@MainActor
 class CarouselModel: ObservableObject {
-    var current_url: URL?
-    var fillHeight: CGFloat
-    var maxHeight: CGFloat
-    var firstImageHeight: CGFloat?
+    // MARK: Immutable object attributes
+    // These are some attributes that are not expected to change throughout the lifecycle of this object
+    // These should not be modified after initialization to avoid state inconsistency
+    
+    /// The state of the app
+    let damus_state: DamusState
+    /// All urls in the carousel
+    let urls: [MediaUrl]
+    /// The default fill height for the carousel, if we cannot calculate a more appropriate height
+    /// **Usage note:** Default to this when `current_item_fill` is nil
+    let default_fill_height: CGFloat
+    /// The maximum height for any carousel item
+    let max_height: CGFloat
+    
+    
+    // MARK: Miscellaneous
+    
+    /// Holds items that allows us to cancel video size observers during de-initialization
+    private var all_cancellables: [AnyCancellable] = []
+    
+    
+    // MARK: State management properties
+    /// Properties relevant to state management. 
+    /// These should be made into computed/functional properties when possible to avoid stateful behavior
+    /// When that is not possible (e.g. when dealing with an observed published property), establish its mathematical dependencies, 
+    /// and use `didSet` observers to ensure that the state is always re-computed when necessary.
 
-    @Published var open_sheet: Bool
-    @Published var selectedIndex: Int
-    @Published var video_size: CGSize?
-    @Published var image_fill: ImageFill?
+    /// Stores information about the size of each media item in `urls`.
+    /// **Usage note:** The view is responsible for setting the size of image urls
+    var media_size_information: [URL: CGSize] {
+        didSet {
+            guard let current_url else { return }
+            // Upon updating information, update the carousel fill size if the size for the current url has changed
+            if oldValue[current_url] != media_size_information[current_url] {
+                self.refresh_current_item_fill()
+            }
+        }
+    }
+    /// Stores information about the geometry reader
+    /// **Usage note:** The view is responsible for setting this value
+    var geo_size: CGSize? {
+        didSet { self.refresh_current_item_fill() }
+    }
+    /// The index of the currently selected item
+    /// **Usage note:** The view is responsible for setting this value
+    @Published var selectedIndex: Int {
+        didSet { self.refresh_current_item_fill() }
+    }
+    /// The current fill for the media item.
+    /// **Usage note:** This property is read-only and should not be set directly. Update `selectedIndex` to update the current item being viewed.
+    var current_url: URL? {
+        return urls[safe: selectedIndex]?.url
+    }
+    /// Holds the ideal fill dimensions for the current item.
+    /// **Usage note:** This property is automatically updated when other properties are set, and should not be set directly
+    /// **Implementation note:** This property is mathematically dependent on geo_size, media_size_information, and `selectedIndex`, 
+    ///   and is automatically updated upon changes to these properties.
+    @Published private(set) var current_item_fill: ImageFill?
+    
+    
+    // MARK: Initialization and de-initialization
 
-    init(image_fill: ImageFill?) {
-        self.current_url = nil
-        self.fillHeight = 350
-        self.maxHeight = UIScreen.main.bounds.height * 1.2 // 1.2
-        self.firstImageHeight = nil
-        self.open_sheet = false
+    /// Initializes the `CarouselModel` with the given `DamusState` and `MediaUrl` array
+    init(damus_state: DamusState, urls: [MediaUrl]) {
+        // Immutable object attributes
+        self.damus_state = damus_state
+        self.urls = urls
+        self.default_fill_height = 350
+        self.max_height = UIScreen.main.bounds.height * 1.2 // 1.2
+        
+        // State management properties
         self.selectedIndex = 0
-        self.video_size = nil
-        self.image_fill = image_fill
+        self.current_item_fill = nil
+        self.geo_size = nil
+        self.media_size_information = [:]
+        
+        // Setup the rest of the state management logic
+        self.observe_video_sizes()
+        Task {
+            self.refresh_current_item_fill()
+        }
+    }
+    
+    /// This private function observes the video sizes for all videos
+    private func observe_video_sizes() {
+        for media_url in urls {
+            switch media_url {
+                case .video(let url):
+                    let video_player = damus_state.video.get_player(for: url)
+                    if let video_size = video_player.video_size {
+                        self.media_size_information[url] = video_size  // Set the initial size if available
+                    }
+                    let observer_cancellable = video_player.$video_size.sink(receiveValue: { new_size in
+                        self.media_size_information[url] = new_size    // Update the size when it changes
+                    })
+                    all_cancellables.append(observer_cancellable)      // Store the cancellable to cancel it later
+                case .image(_):
+                    break;  // Observing an image size needs to be done on the view directly, through the `.observe_image_size` modifier
+            }
+        }
+    }
+    
+    deinit {
+        for cancellable_item in all_cancellables {
+            cancellable_item.cancel()
+        }
+    }
+    
+    // MARK: State management and logic
+
+    /// This function refreshes the current item fill based on the current state of the model
+    /// **Usage note:** This is private, do not call this directly from outside the class.
+    /// **Implementation note:** This should be called using `didSet` observers on properties that affect the fill
+    private func refresh_current_item_fill() {
+        if let current_url,
+           let item_size = self.media_size_information[current_url],
+           let geo_size {
+            self.current_item_fill = ImageFill.calculate_image_fill(
+                geo_size: geo_size,
+                img_size: item_size,
+                maxHeight: self.max_height,
+                fillHeight: self.default_fill_height
+            )
+        }
+        else {
+            self.current_item_fill = nil    // Not enough information to compute the proper fill. Default to nil
+        }
     }
 }
 
 // MARK: - Image Carousel
+
+/// A carousel that displays images and videos
+/// 
+/// ## Implementation notes
+/// 
+/// - State management logic is mostly handled by `CarouselModel`, as it is complex, and becomes difficult to manage in a view
+///
 @MainActor
 struct ImageCarousel<Content: View>: View {
-    var urls: [MediaUrl]
-    
+    /// The event id of the note that this carousel is displaying
     let evid: NoteId
-    
-    let state: DamusState
+    /// The model that holds information and state of this carousel
+    /// This is observed to update the view when the model changes
     @ObservedObject var model: CarouselModel
     let content: ((_ dismiss: @escaping (() -> Void)) -> Content)?
 
     init(state: DamusState, evid: NoteId, urls: [MediaUrl]) {
-        self.urls = urls
         self.evid = evid
-        self.state = state
-        let media_model = state.events.get_cache_data(evid).media_metadata_model
-        self._model = ObservedObject(initialValue: CarouselModel(image_fill: media_model.fill))
+        self._model = ObservedObject(initialValue: CarouselModel(damus_state: state, urls: urls))
         self.content = nil
     }
     
     init(state: DamusState, evid: NoteId, urls: [MediaUrl], @ViewBuilder content: @escaping (_ dismiss: @escaping (() -> Void)) -> Content) {
-        self.urls = urls
         self.evid = evid
-        self.state = state
-        let media_model = state.events.get_cache_data(evid).media_metadata_model
-        self._model = ObservedObject(initialValue: CarouselModel(image_fill: media_model.fill))
+        self._model = ObservedObject(initialValue: CarouselModel(damus_state: state, urls: urls))
         self.content = content
     }
     
     var filling: Bool {
-        model.image_fill?.filling == true
+        model.current_item_fill?.filling == true
     }
     
     var height: CGFloat {
-        model.firstImageHeight ?? model.image_fill?.height ?? model.fillHeight
+        // Use the calculated fill height if available, otherwise use the default fill height
+        model.current_item_fill?.height ?? model.default_fill_height
     }
     
     func Placeholder(url: URL, geo_size: CGSize, num_urls: Int) -> some View {
@@ -160,7 +300,7 @@ struct ImageCarousel<Content: View>: View {
             if num_urls > 1 {
                 // jb55: quick hack since carousel with multiple images looks horrible with blurhash background
                 Color.clear
-            } else if let meta = state.events.lookup_img_metadata(url: url),
+            } else if let meta = model.damus_state.events.lookup_img_metadata(url: url),
                case .processed(let blurhash) = meta.state {
                 Image(uiImage: blurhash)
                     .resizable()
@@ -169,12 +309,6 @@ struct ImageCarousel<Content: View>: View {
                 Color.clear
             }
         }
-        .onAppear {
-            if self.model.image_fill == nil, let size = state.video.size_for_url(url) {
-                let fill = ImageFill.calculate_image_fill(geo_size: geo_size, img_size: size, maxHeight: model.maxHeight, fillHeight: model.fillHeight)
-                self.model.image_fill = fill
-            }
-        }
     }
     
     func Media(geo: GeometryProxy, url: MediaUrl, index: Int) -> some View {
@@ -183,24 +317,17 @@ struct ImageCarousel<Content: View>: View {
             case .image(let url):
                 Img(geo: geo, url: url, index: index)
                     .onTapGesture {
-                        model.open_sheet = true
+                        present(full_screen_item: .full_screen_carousel(urls: model.urls, selectedIndex: $model.selectedIndex))
                     }
             case .video(let url):
-                DamusVideoPlayer(url: url, video_size: $model.video_size, controller: state.video, style: .preview(on_tap: { model.open_sheet = true }))
-                    .onChange(of: model.video_size) { size in
-                        guard let size else { return }
-                        
-                        let fill = ImageFill.calculate_image_fill(geo_size: geo.size, img_size: size, maxHeight: model.maxHeight, fillHeight: model.fillHeight)
-
-                        print("video_size changed \(size)")
-                        if self.model.image_fill == nil {
-                            print("video_size firstImageHeight \(fill.height)")
-                            self.model.firstImageHeight = fill.height
-                            state.events.get_cache_data(evid).media_metadata_model.fill = fill
-                        }
-                        
-                        self.model.image_fill = fill
-                    }
+                   let video_model = model.damus_state.video.get_player(for: url)
+                    DamusVideoPlayerView(
+                        model: video_model,
+                        coordinator: model.damus_state.video,
+                        style: .preview(on_tap: {
+                            present(full_screen_item: .full_screen_carousel(urls: model.urls, selectedIndex: $model.selectedIndex))
+                        })
+                    )
             }
         }
     }
@@ -209,33 +336,21 @@ struct ImageCarousel<Content: View>: View {
         KFAnimatedImage(url)
             .callbackQueue(.dispatch(.global(qos:.background)))
             .backgroundDecode(true)
-            .imageContext(.note, disable_animation: state.settings.disable_animation)
+            .imageContext(.note, disable_animation: model.damus_state.settings.disable_animation)
             .image_fade(duration: 0.25)
             .cancelOnDisappear(true)
             .configure { view in
                 view.framePreloadCount = 3
             }
-            .imageFill(for: geo.size, max: model.maxHeight, fill: model.fillHeight) { fill in
-                state.events.get_cache_data(evid).media_metadata_model.fill = fill
-                // blur hash can be discarded when we have the url
-                // NOTE: this is the wrong place for this... we need to remove
-                //       it when the image is loaded in memory. This may happen
-                //       earlier than this (by the preloader, etc)
-                DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
-                    state.events.lookup_img_metadata(url: url)?.state = .not_needed
-                }
-                self.model.image_fill = fill
-                if index == 0 {
-                    self.model.firstImageHeight = fill.height
-                    //maxHeight = firstImageHeight ?? maxHeight
-                } else {
-                    //maxHeight = firstImageHeight ?? fill.height
-                }
-            }
+            .observe_image_size(size_changed: { size in
+                // Observe the image size to update the model when the size changes, so we can calculate the fill
+                model.media_size_information[url] = size
+            })
             .background {
-                Placeholder(url: url, geo_size: geo.size, num_urls: urls.count)
+                Placeholder(url: url, geo_size: geo.size, num_urls: model.urls.count)
             }
             .aspectRatio(contentMode: filling ? .fill : .fit)
+            .kfClickable()
             .position(x: geo.size.width / 2, y: geo.size.height / 2)
             .tabItem {
                 Text(url.absoluteString)
@@ -247,25 +362,19 @@ struct ImageCarousel<Content: View>: View {
     
     var Medias: some View {
         TabView(selection: $model.selectedIndex) {
-            ForEach(urls.indices, id: \.self) { index in
+            ForEach(model.urls.indices, id: \.self) { index in
                 GeometryReader { geo in
-                    Media(geo: geo, url: urls[index], index: index)
+                    Media(geo: geo, url: model.urls[index], index: index)
+                        .onChange(of: geo.size, perform: { new_size in
+                            model.geo_size = new_size
+                        })
+                        .onAppear {
+                            model.geo_size = geo.size
+                        }
                 }
             }
         }
         .tabViewStyle(PageTabViewStyle(indexDisplayMode: .never))
-        .fullScreenCover(isPresented: $model.open_sheet) {
-            if let content {
-                FullScreenCarouselView<Content>(video_controller: state.video, urls: urls, settings: state.settings, selectedIndex: $model.selectedIndex) {
-                    content({ // Dismiss closure
-                        model.open_sheet = false
-                    })
-                }
-            }
-            else {
-                FullScreenCarouselView<AnyView>(video_controller: state.video, urls: urls, settings: state.settings, selectedIndex: $model.selectedIndex)
-            }
-        }
         .frame(height: height)
         .onChange(of: model.selectedIndex) { value in
             model.selectedIndex = value
@@ -274,11 +383,17 @@ struct ImageCarousel<Content: View>: View {
     
     var body: some View {
         VStack {
-            Medias
-                .onTapGesture { }
+            if #available(iOS 18.0, *) {
+                Medias
+            } else {
+                // An empty tap gesture recognizer is needed on iOS 17 and below to suppress other overlapping tap recognizers
+                // Otherwise it will both open the carousel and go to a note at the same time
+                Medias.onTapGesture { }
+            }
             
-            if urls.count > 1 {
-                PageControlView(currentPage: $model.selectedIndex, numberOfPages: urls.count)
+            
+            if model.urls.count > 1 {
+                PageControlView(currentPage: $model.selectedIndex, numberOfPages: model.urls.count)
                     .frame(maxWidth: 0, maxHeight: 0)
                     .padding(.top, 5)
             }
@@ -286,27 +401,6 @@ struct ImageCarousel<Content: View>: View {
     }
 }
 
-// MARK: - Image Modifier
-extension KFOptionSetter {
-    /// Sets a block to get image size
-    ///
-    /// - Parameter block: The block which is used to read the image object.
-    /// - Returns: `Self` value after read size
-    public func imageFill(for size: CGSize, max: CGFloat, fill: CGFloat, block: @escaping (ImageFill) throws -> Void) -> Self {
-        let modifier = AnyImageModifier { image -> KFCrossPlatformImage in
-            let img_size = image.size
-            let geo_size = size
-            let fill = ImageFill.calculate_image_fill(geo_size: geo_size, img_size: img_size, maxHeight: max, fillHeight: fill)
-            DispatchQueue.main.async { [block, fill] in
-                try? block(fill)
-            }
-            return image
-        }
-        options.imageModifier = modifier
-        return self
-    }
-}
-
 
 public struct ImageFill {
     let filling: Bool?
@@ -343,4 +437,3 @@ struct ImageCarousel_Previews: PreviewProvider {
             .environmentObject(OrientationTracker())
     }
 }
-

damus/Components/InvoiceView.swift

@@ -94,8 +94,8 @@ enum OpenWalletError: Error {
 }
 
 func open_with_wallet(wallet: Wallet.Model, invoice: String) throws {
-    if let url = URL(string: "\(wallet.link)\(invoice)"), UIApplication.shared.canOpenURL(url) {
-        UIApplication.shared.open(url)
+    if let url = URL(string: "\(wallet.link)\(invoice)"), this_app.canOpenURL(url) {
+        this_app.open(url)
     } else {
         guard let store_link = wallet.appStoreLink else {
             throw OpenWalletError.no_wallet_to_open
@@ -105,11 +105,11 @@ func open_with_wallet(wallet: Wallet.Model, invoice: String) throws {
             throw OpenWalletError.store_link_invalid
         }
         
-        guard UIApplication.shared.canOpenURL(url) else {
+        guard this_app.canOpenURL(url) else {
             throw OpenWalletError.system_cannot_open_store_link
         }
         
-        UIApplication.shared.open(url)
+        this_app.open(url)
     }
 }
 
@@ -122,8 +122,3 @@ struct InvoiceView_Previews: PreviewProvider {
             .frame(width: 300, height: 200)
     }
 }
-
-
-func present_sheet(_ sheet: Sheets) {
-    notify(.present_sheet(sheet))
-}

damus/Components/Reposted.swift

@@ -10,22 +10,68 @@ import SwiftUI
 struct Reposted: View {
     let damus: DamusState
     let pubkey: Pubkey
+    let target: NostrEvent
+    @State var reposts: Int
+
+    init(damus: DamusState, pubkey: Pubkey, target: NostrEvent) {
+        self.damus = damus
+        self.pubkey = pubkey
+        self.target = target
+        self.reposts = damus.boosts.counts[target.id] ?? 1
+    }
 
     var body: some View {
         HStack(alignment: .center) {
             Image("repost")
                 .foregroundColor(Color.gray)
-            ProfileName(pubkey: pubkey, damus: damus, show_nip5_domain: false)
-                    .foregroundColor(Color.gray)
-            Text("Reposted", comment: "Text indicating that the note was reposted (i.e. re-shared).")
-                .foregroundColor(Color.gray)
+
+            // Show profile picture of the reposter only if the reposter is not the author of the reposted note.
+            if pubkey != target.pubkey {
+                ProfilePicView(pubkey: pubkey, size: eventview_pfp_size(.small), highlight: .none, profiles: damus.profiles, disable_animation: damus.settings.disable_animation)
+                    .onTapGesture {
+                        show_profile_action_sheet_if_enabled(damus_state: damus, pubkey: pubkey)
+                    }
+                    .onLongPressGesture(minimumDuration: 0.1) {
+                        UIImpactFeedbackGenerator(style: .medium).impactOccurred()
+                        damus.nav.push(route: Route.ProfileByKey(pubkey: pubkey))
+                    }
+            }
+
+            NavigationLink(value: Route.Reposts(reposts: .reposts(state: damus, target: target.id))) {
+                Text(people_reposted_text(profiles: damus.profiles, pubkey: pubkey, reposts: reposts))
+                    .font(.subheadline)
+                    .foregroundColor(.gray)
+            }
         }
+        .onReceive(handle_notify(.update_stats), perform: { note_id in
+            guard note_id == target.id else { return }
+            let repost_count = damus.boosts.counts[target.id]
+            if let repost_count, reposts != repost_count {
+                reposts = repost_count
+            }
+        })
+    }
+}
+
+func people_reposted_text(profiles: Profiles, pubkey: Pubkey, reposts: Int, locale: Locale = Locale.current) -> String {
+    guard reposts > 0 else {
+        return ""
+    }
+
+    let bundle = bundleForLocale(locale: locale)
+    let other_reposts = reposts - 1
+    let display_name = event_author_name(profiles: profiles, pubkey: pubkey)
+
+    if other_reposts == 0 {
+        return String(format: NSLocalizedString("%@ reposted", bundle: bundle, comment: "Text indicating that the note was reposted (i.e. re-shared)."), locale: locale, display_name)
+    } else {
+        return String(format: localizedStringFormat(key: "people_reposted_count", locale: locale), locale: locale, other_reposts, display_name)
     }
 }
 
 struct Reposted_Previews: PreviewProvider {
     static var previews: some View {
         let test_state = test_damus_state
-        Reposted(damus: test_state, pubkey: test_state.pubkey)
+        Reposted(damus: test_state, pubkey: test_state.pubkey, target: test_note)
     }
 }

damus/Components/SelectableText.swift

@@ -9,16 +9,19 @@ import UIKit
 import SwiftUI
 
 struct SelectableText: View {
-    
+    let damus_state: DamusState
+    let event: NostrEvent?
     let attributedString: AttributedString
     let textAlignment: NSTextAlignment
-    
+    @State private var selectedTextActionState: SelectedTextActionState = .hide
     @State private var selectedTextHeight: CGFloat = .zero
     @State private var selectedTextWidth: CGFloat = .zero
-    
+
     let size: EventViewKind
-    
-    init(attributedString: AttributedString, textAlignment: NSTextAlignment? = nil, size: EventViewKind) {
+
+    init(damus_state: DamusState, event: NostrEvent?, attributedString: AttributedString, textAlignment: NSTextAlignment? = nil, size: EventViewKind) {
+        self.damus_state = damus_state
+        self.event = event
         self.attributedString = attributedString
         self.textAlignment = textAlignment ?? NSTextAlignment.natural
         self.size = size
@@ -32,6 +35,13 @@ struct SelectableText: View {
                 font: eventviewsize_to_uifont(size),
                 fixedWidth: selectedTextWidth,
                 textAlignment: self.textAlignment,
+                enableHighlighting: self.enableHighlighting(),
+                postHighlight: { selectedText in
+                    self.selectedTextActionState = .show_highlight_post_view(highlighted_text: selectedText)
+                },
+                muteWord: { selectedText in
+                    self.selectedTextActionState = .show_mute_word_view(highlighted_text: selectedText)
+                },
                 height: $selectedTextHeight
             )
             .padding([.leading, .trailing], -1.0)
@@ -46,22 +56,123 @@ struct SelectableText: View {
                 self.selectedTextWidth = newSize.width
             }
         }
+        .sheet(isPresented: Binding(get: {
+            return self.selectedTextActionState.should_show_highlight_post_view()
+        }, set: { newValue in
+            self.selectedTextActionState = newValue ? .show_highlight_post_view(highlighted_text: self.selectedTextActionState.highlighted_text() ?? "") : .hide
+        })) {
+            if let event, case .show_highlight_post_view(let highlighted_text) = self.selectedTextActionState {
+                PostView(
+                    action: .highlighting(.init(selected_text: highlighted_text, source: .event(event.id))),
+                    damus_state: damus_state
+                )
+                .presentationDragIndicator(.visible)
+                .presentationDetents([.height(selectedTextHeight + 450), .medium, .large])
+            }
+        }
+        .sheet(isPresented: Binding(get: {
+            return self.selectedTextActionState.should_show_mute_word_view()
+        }, set: { newValue in
+            self.selectedTextActionState = newValue ? .show_mute_word_view(highlighted_text: self.selectedTextActionState.highlighted_text() ?? "") : .hide
+        })) {
+            if case .show_mute_word_view(let highlighted_text) = selectedTextActionState {
+                AddMuteItemView(state: damus_state, new_text: .constant(highlighted_text))
+                    .presentationDragIndicator(.visible)
+                    .presentationDetents([.height(300), .medium, .large])
+            }
+        }
         .frame(height: selectedTextHeight)
     }
+    
+    func enableHighlighting() -> Bool {
+        self.event != nil
+    }
+    
+    enum SelectedTextActionState {
+        case hide
+        case show_highlight_post_view(highlighted_text: String)
+        case show_mute_word_view(highlighted_text: String)
+        
+        func should_show_highlight_post_view() -> Bool {
+            guard case .show_highlight_post_view(let highlighted_text) = self else { return false }
+            return true
+        }
+        
+        func should_show_mute_word_view() -> Bool {
+            guard case .show_mute_word_view(let highlighted_text) = self else { return false }
+            return true
+        }
+        
+        func highlighted_text() -> String? {
+            switch self {
+                case .hide:
+                    return nil
+                case .show_mute_word_view(highlighted_text: let highlighted_text):
+                    return highlighted_text
+                case .show_highlight_post_view(highlighted_text: let highlighted_text):
+                    return highlighted_text
+            }
+        }
+    }
 }
 
- fileprivate struct TextViewRepresentable: UIViewRepresentable {
+fileprivate class TextView: UITextView {
+    var postHighlight: (String) -> Void
+    var muteWord: (String) -> Void
+
+    init(frame: CGRect, textContainer: NSTextContainer?, postHighlight: @escaping (String) -> Void, muteWord: @escaping (String) -> Void) {
+        self.postHighlight = postHighlight
+        self.muteWord = muteWord
+        super.init(frame: frame, textContainer: textContainer)
+    }
+
+    required init?(coder: NSCoder) {
+            fatalError("init(coder:) has not been implemented")
+        }
+
+    override func canPerformAction(_ action: Selector, withSender sender: Any?) -> Bool {
+        if action == #selector(highlightText(_:)) {
+            return true
+        }
+        
+        if action == #selector(muteText(_:)) {
+            return true
+        }
+        
+        return super.canPerformAction(action, withSender: sender)
+    }
+    
+    func getSelectedText() -> String? {
+        guard let selectedRange = self.selectedTextRange else { return nil }
+        return self.text(in: selectedRange)
+    }
+
+    @objc public func highlightText(_ sender: Any?) {
+        guard let selectedText = self.getSelectedText() else { return }
+        self.postHighlight(selectedText)
+    }
+    
+    @objc public func muteText(_ sender: Any?) {
+        guard let selectedText = self.getSelectedText() else { return }
+        self.muteWord(selectedText)
+    }
+
+}
+
+fileprivate struct TextViewRepresentable: UIViewRepresentable {
 
     let attributedString: AttributedString
     let textColor: UIColor
     let font: UIFont
     let fixedWidth: CGFloat
     let textAlignment: NSTextAlignment
-
+    let enableHighlighting: Bool
+    let postHighlight: (String) -> Void
+    let muteWord: (String) -> Void
     @Binding var height: CGFloat
 
-    func makeUIView(context: UIViewRepresentableContext<Self>) -> UITextView {
-        let view = UITextView()
+    func makeUIView(context: UIViewRepresentableContext<Self>) -> TextView {
+        let view = TextView(frame: .zero, textContainer: nil, postHighlight: postHighlight, muteWord: muteWord)
         view.isEditable = false
         view.dataDetectorTypes = .all
         view.isSelectable = true
@@ -71,10 +182,16 @@ struct SelectableText: View {
         view.textContainerInset.left = 1.0
         view.textContainerInset.right = 1.0
         view.textAlignment = textAlignment
+
+        let menuController = UIMenuController.shared
+        let highlightItem = UIMenuItem(title: "Highlight", action: #selector(view.highlightText(_:)))
+        let muteItem = UIMenuItem(title: "Mute", action: #selector(view.muteText(_:)))
+        menuController.menuItems = self.enableHighlighting ? [highlightItem, muteItem] : []
+
         return view
     }
 
-    func updateUIView(_ uiView: UITextView, context: UIViewRepresentableContext<Self>) {
+    func updateUIView(_ uiView: TextView, context: UIViewRepresentableContext<Self>) {
         let mutableAttributedString = createNSAttributedString()
         uiView.attributedText = mutableAttributedString
         uiView.textAlignment = self.textAlignment

damus/Components/SupporterBadge.swift

@@ -11,11 +11,21 @@ struct SupporterBadge: View {
     let percent: Int?
     let purple_account: DamusPurple.Account?
     let style: Style
+    let text_color: Color
+    var badge_variant: BadgeVariant {
+        if purple_account?.attributes.contains(.memberForMoreThanOneYear) == true {
+            return .oneYearSpecial
+        }
+        else {
+            return .normal
+        }
+    }
     
-    init(percent: Int?, purple_account: DamusPurple.Account? = nil, style: Style) {
+    init(percent: Int?, purple_account: DamusPurple.Account? = nil, style: Style, text_color: Color = .secondary) {
         self.percent = percent
         self.purple_account = purple_account
         self.style = style
+        self.text_color = text_color
     }
     
     let size: CGFloat = 17
@@ -24,14 +34,19 @@ struct SupporterBadge: View {
         HStack {
             if let purple_account, purple_account.active == true {
                 HStack(spacing: 1) {
-                    Image("star.fill")
-                        .resizable()
-                        .frame(width:size, height:size)
-                        .foregroundStyle(GoldGradient)
-                    if self.style == .full {
-                        let date = format_date(date: purple_account.created_at, time_style: .none)
-                        Text(date)
-                            .foregroundStyle(.secondary)
+                    switch self.badge_variant {
+                    case .normal:
+                        StarShape()
+                            .frame(width:size, height:size)
+                            .foregroundStyle(GoldGradient)
+                    case .oneYearSpecial:
+                        DoubleStar(size: size)
+                    }
+                    
+                    if self.style == .full,
+                       let ordinal = self.purple_account?.ordinal() {
+                        Text(ordinal)
+                            .foregroundStyle(text_color)
                             .font(.caption)
                     }
                 }
@@ -54,8 +69,102 @@ struct SupporterBadge: View {
         case full       // Shows the entire badge with a purple subscriber number if present
         case compact    // Does not show purple subscriber number. Only shows the star (if applicable)
     }
+    
+    enum BadgeVariant {
+        /// A normal badge that people are used to
+        case normal
+        /// A special badge for users who have been members for more than a year
+        case oneYearSpecial
+    }
 }
 
+
+struct StarShape: Shape {
+    func path(in rect: CGRect) -> Path {
+        var path = Path()
+        let center = CGPoint(x: rect.midX, y: rect.midY)
+        let radius: CGFloat = min(rect.width, rect.height) / 2
+        let points = 5
+        let adjustment: CGFloat = .pi / 2
+        
+        for i in 0..<points * 2 {
+            let angle = (CGFloat(i) * .pi / CGFloat(points)) - adjustment
+            let pointRadius = i % 2 == 0 ? radius : radius * 0.4
+            let point = CGPoint(x: center.x + pointRadius * cos(angle), y: center.y + pointRadius * sin(angle))
+            if i == 0 {
+                path.move(to: point)
+            } else {
+                path.addLine(to: point)
+            }
+        }
+        path.closeSubpath()
+        return path
+    }
+}
+
+struct DoubleStar: View {
+    let size: CGFloat
+    var starOffset: CGFloat = 5
+    
+    var body: some View {
+        if #available(iOS 17.0, *) {
+            DoubleStarShape(starOffset: starOffset)
+                .frame(width: size, height: size)
+                .foregroundStyle(GoldGradient)
+                .padding(.trailing, starOffset)
+        } else {
+            Fallback(size: size, starOffset: starOffset)
+        }
+    }
+    
+    @available(iOS 17.0, *)
+    struct DoubleStarShape: Shape {
+        var strokeSize: CGFloat = 3
+        var starOffset: CGFloat
+
+        func path(in rect: CGRect) -> Path {
+            let normalSizedStarPath = StarShape().path(in: rect)
+            let largerStarPath = StarShape().path(in: rect.insetBy(dx: -strokeSize, dy: -strokeSize))
+            
+            let finalPath = normalSizedStarPath
+                .subtracting(
+                    largerStarPath.offsetBy(dx: starOffset, dy: 0)
+                )
+                .union(
+                    normalSizedStarPath.offsetBy(dx: starOffset, dy: 0)
+                )
+            
+            return finalPath
+        }
+    }
+    
+    /// A fallback view for those who cannot run iOS 17
+    struct Fallback: View {
+        var size: CGFloat
+        var starOffset: CGFloat
+        
+        var body: some View {
+            HStack {
+                StarShape()
+                    .frame(width: size, height: size)
+                    .foregroundStyle(GoldGradient)
+                
+                StarShape()
+                    .fill(GoldGradient)
+                    .overlay(
+                        StarShape()
+                            .stroke(Color.damusAdaptableWhite, lineWidth: 1)
+                    )
+                    .frame(width: size + 1, height: size + 1)
+                    .padding(.leading, -size - starOffset)
+            }
+            .padding(.trailing, -3)
+        }
+    }
+}
+
+
+
 func support_level_color(_ percent: Int) -> Color {
     if percent == 0 {
         return .gray
@@ -84,7 +193,7 @@ struct SupporterBadge_Previews: PreviewProvider {
         HStack(alignment: .center) {
             SupporterBadge(
                 percent: nil,
-                purple_account: DamusPurple.Account(pubkey: test_pubkey, created_at: .now, expiry: .now.addingTimeInterval(10000), subscriber_number: subscriber_number, active: true),
+                purple_account: DamusPurple.Account(pubkey: test_pubkey, created_at: .now, expiry: .now.addingTimeInterval(10000), subscriber_number: subscriber_number, active: true, attributes: []),
                 style: .full
             )
                 .frame(width: 100)
@@ -116,4 +225,52 @@ struct SupporterBadge_Previews: PreviewProvider {
     }
 }
 
+#Preview("1 yr badge") {
+    VStack {
+        HStack(alignment: .center) {
+            SupporterBadge(
+                percent: nil,
+                purple_account: DamusPurple.Account(pubkey: test_pubkey, created_at: .now, expiry: .now.addingTimeInterval(10000), subscriber_number: 3, active: true, attributes: []),
+                style: .full
+            )
+                .frame(width: 100)
+        }
+        
+        HStack(alignment: .center) {
+            SupporterBadge(
+                percent: nil,
+                purple_account: DamusPurple.Account(pubkey: test_pubkey, created_at: .now, expiry: .now.addingTimeInterval(10000), subscriber_number: 3, active: true, attributes: [.memberForMoreThanOneYear]),
+                style: .full
+            )
+                .frame(width: 100)
+        }
+        
+        Text(verbatim: "Double star (just shape itself, with alt background color, to show it adapts to background well)")
+            .multilineTextAlignment(.center)
+        
+        if #available(iOS 17.0, *) {
+            HStack(alignment: .center) {
+                DoubleStar.DoubleStarShape(starOffset: 5)
+                    .frame(width: 17, height: 17)
+                    .padding(.trailing, -8)
+            }
+            .background(Color.blue)
+        }
+        
+        Text(verbatim: "Double star (fallback for iOS 16 and below)")
+
+        HStack(alignment: .center) {
+            DoubleStar.Fallback(size: 17, starOffset: 5)
+        }
+        
+        Text(verbatim: "Double star (fallback for iOS 16 and below, with alt color limitation shown)")
+            .multilineTextAlignment(.center)
+        
+        HStack(alignment: .center) {
+            DoubleStar.Fallback(size: 17, starOffset: 5)
+        }
+        .background(Color.blue)
+    }
+}
+
 

damus/Components/TranslateView.swift

@@ -27,19 +27,26 @@ struct TranslateView: View {
     let damus_state: DamusState
     let event: NostrEvent
     let size: EventViewKind
-    
+
+    @Binding var isAppleTranslationPopoverPresented: Bool
+
     @ObservedObject var translations_model: TranslationModel
     
-    init(damus_state: DamusState, event: NostrEvent, size: EventViewKind) {
+    init(damus_state: DamusState, event: NostrEvent, size: EventViewKind, isAppleTranslationPopoverPresented: Binding<Bool>) {
         self.damus_state = damus_state
         self.event = event
         self.size = size
+        self._isAppleTranslationPopoverPresented = isAppleTranslationPopoverPresented
         self._translations_model = ObservedObject(wrappedValue: damus_state.events.get_cache_data(event.id).translations_model)
     }
     
     var TranslateButton: some View {
         Button(NSLocalizedString("Translate Note", comment: "Button to translate note from different language.")) {
-            translate()
+            if damus_state.settings.translation_service == .none {
+                isAppleTranslationPopoverPresented = true
+            } else {
+                translate()
+            }
         }
         .translate_button_style()
     }
@@ -51,9 +58,9 @@ struct TranslateView: View {
                 .foregroundColor(.gray)
                 .font(.footnote)
                 .padding([.top, .bottom], 10)
-            
+
             if self.size == .selected {
-                SelectableText(attributedString: artifacts.content.attributed, size: self.size)
+                SelectableText(damus_state: damus_state, event: event, attributedString: artifacts.content.attributed, size: self.size)
             } else {
                 artifacts.content.text
                     .font(eventviewsize_to_font(self.size, font_size: font_size))
@@ -74,17 +81,25 @@ struct TranslateView: View {
     }
         
     func should_transl(_ note_lang: String) -> Bool {
-        should_translate(event: event, our_keypair: damus_state.keypair, settings: damus_state.settings, note_lang: note_lang)
+        guard should_translate(event: event, our_keypair: damus_state.keypair, note_lang: note_lang) else {
+            return false
+        }
+
+        if TranslationService.isAppleTranslationPopoverSupported {
+            return damus_state.settings.translation_service == .none || damus_state.settings.can_translate
+        } else {
+            return damus_state.settings.can_translate
+        }
     }
     
     var body: some View {
         Group {
             switch self.translations_model.state {
             case .havent_tried:
-                if damus_state.settings.auto_translate {
+                if damus_state.settings.auto_translate && damus_state.settings.translation_service != .none {
                     Text("")
                 } else if let note_lang = translations_model.note_language, should_transl(note_lang)  {
-                        TranslateButton
+                    TranslateButton
                 } else {
                     Text("")
                 }
@@ -114,9 +129,11 @@ extension View {
 }
 
 struct TranslateView_Previews: PreviewProvider {
+    @State static var isAppleTranslationPopoverPresented: Bool = false
+
     static var previews: some View {
         let ds = test_damus_state
-        TranslateView(damus_state: ds, event: test_note, size: .normal)
+        TranslateView(damus_state: ds, event: test_note, size: .normal, isAppleTranslationPopoverPresented: $isAppleTranslationPopoverPresented)
     }
 }
 

damus/ContentParsing.swift

@@ -12,7 +12,7 @@ enum NoteContent {
     case content(String, TagsSequence?)
 
     init(note: NostrEvent, keypair: Keypair) {
-        if note.known_kind == .dm {
+        if note.known_kind == .dm || note.known_kind == .highlight {
             self = .content(note.get_content(keypair), note.tags)
         } else {
             self = .note(note)

damus/ContentView.swift

@@ -8,6 +8,7 @@
 import SwiftUI
 import AVKit
 import MediaPlayer
+import EmojiPicker
 
 struct ZapSheet {
     let target: ZapTarget
@@ -30,7 +31,8 @@ enum Sheets: Identifiable {
     case onboardingSuggestions
     case purple(DamusPurpleURL)
     case purple_onboarding
-    
+    case error(ErrorView.UserPresentableError)
+
     static func zap(target: ZapTarget, lnurl: String) -> Sheets {
         return .zap(ZapSheet(target: target, lnurl: lnurl))
     }
@@ -52,10 +54,52 @@ enum Sheets: Identifiable {
         case .onboardingSuggestions: return "onboarding-suggestions"
         case .purple(let purple_url): return "purple" + purple_url.url_string()
         case .purple_onboarding: return "purple_onboarding"
+        case .error(_): return "error"
         }
     }
 }
 
+/// An item to be presented full screen in a mechanism that is more robust for timeline views.
+///
+/// ## Implementation notes
+///
+/// This is part of the `present(full_screen_item: FullScreenItem)` interface that allows views in a timeline to show something full-screen without the lazy stack issues
+/// Full screen cover modifiers are not suitable in those cases because device orientation changes or programmatic scroll commands will cause the view to be unloaded along with the cover,
+/// causing the user to lose the full screen view randomly.
+///
+/// The `ContentView` is responsible for handling these objects
+///
+/// New items can be added as needed.
+///
+enum FullScreenItem: Identifiable, Equatable {
+    /// A full screen media carousel for images and videos.
+    case full_screen_carousel(urls: [MediaUrl], selectedIndex: Binding<Int>)
+    
+    var id: String {
+        switch self {
+            case .full_screen_carousel(let urls, _): return "full_screen_carousel:\(urls.map(\.url))"
+        }
+    }
+    
+    static func == (lhs: FullScreenItem, rhs: FullScreenItem) -> Bool {
+        return lhs.id == rhs.id
+    }
+    
+    /// The view to display the item
+    func view(damus_state: DamusState) -> some View {
+        switch self {
+            case .full_screen_carousel(let urls, let selectedIndex):
+                return FullScreenCarouselView<AnyView>(video_coordinator: damus_state.video, urls: urls, settings: damus_state.settings, selectedIndex: selectedIndex)
+        }
+    }
+}
+
+func present_sheet(_ sheet: Sheets) {
+    notify(.present_sheet(sheet))
+}
+
+var tabHeight: CGFloat = 0.0
+
 struct ContentView: View {
     let keypair: Keypair
     let appDelegate: AppDelegate?
@@ -71,78 +115,29 @@ struct ContentView: View {
     @Environment(\.scenePhase) var scenePhase
     
     @State var active_sheet: Sheets? = nil
+    @State var active_full_screen_item: FullScreenItem? = nil
     @State var damus_state: DamusState!
-    @SceneStorage("ContentView.selected_timeline") var selected_timeline: Timeline = .home
+    @State var menu_subtitle: String? = nil
+    @SceneStorage("ContentView.selected_timeline") var selected_timeline: Timeline = .home {
+        willSet {
+            self.menu_subtitle = nil
+        }
+    }
     @State var muting: MuteItem? = nil
     @State var confirm_mute: Bool = false
     @State var hide_bar: Bool = false
     @State var user_muted_confirm: Bool = false
     @State var confirm_overwrite_mutelist: Bool = false
-    @SceneStorage("ContentView.filter_state") var filter_state : FilterState = .posts_and_replies
     @State private var isSideBarOpened = false
+    @State var headerOffset: CGFloat = 0.0
     var home: HomeModel = HomeModel()
     @StateObject var navigationCoordinator: NavigationCoordinator = NavigationCoordinator()
     @AppStorage("has_seen_suggested_users") private var hasSeenOnboardingSuggestions = false
     let sub_id = UUID().description
-
-    @Environment(\.colorScheme) var colorScheme
     
     // connect retry timer
     let timer = Timer.publish(every: 1, on: .main, in: .common).autoconnect()
     
-    var mystery: some View {
-        Text("Are you lost?", comment: "Text asking the user if they are lost in the app.")
-        .id("what")
-    }
-
-    func content_filter(_ fstate: FilterState) -> ((NostrEvent) -> Bool) {
-        var filters = ContentFilters.defaults(damus_state: damus_state!)
-        filters.append(fstate.filter)
-        return ContentFilters(filters: filters).filter
-    }
-
-    var PostingTimelineView: some View {
-        VStack {
-            ZStack {
-                TabView(selection: $filter_state) {
-                    // This is needed or else there is a bug when switching from the 3rd or 2nd tab to first. no idea why.
-                    mystery
-                    
-                    contentTimelineView(filter: content_filter(.posts))
-                        .tag(FilterState.posts)
-                        .id(FilterState.posts)
-                    contentTimelineView(filter: content_filter(.posts_and_replies))
-                        .tag(FilterState.posts_and_replies)
-                        .id(FilterState.posts_and_replies)
-                }
-                .tabViewStyle(.page(indexDisplayMode: .never))
-                
-                if privkey != nil {
-                    PostButtonContainer(is_left_handed: damus_state?.settings.left_handed ?? false) {
-                        self.active_sheet = .post(.posting(.none))
-                    }
-                }
-            }
-        }
-        .safeAreaInset(edge: .top, spacing: 0) {
-            VStack(spacing: 0) {
-                CustomPicker(selection: $filter_state, content: {
-                    Text("Notes", comment: "Label for filter for seeing only notes (instead of notes and replies).").tag(FilterState.posts)
-                    Text("Notes & Replies", comment: "Label for filter for seeing notes and replies (instead of only notes).").tag(FilterState.posts_and_replies)
-                })
-                Divider()
-                    .frame(height: 1)
-            }
-            .background(colorScheme == .dark ? Color.black : Color.white)
-        }
-    }
-    
-    func contentTimelineView(filter: (@escaping (NostrEvent) -> Bool)) -> some View {
-        TimelineView(events: home.events, loading: .constant(false), damus: damus_state, show_friend_icon: false, filter: filter) {
-            PullDownSearchView(state: damus_state, on_cancel: {})
-        }
-    }
-    
     func navIsAtRoot() -> Bool {
         return navigationCoordinator.isAtRoot()
     }
@@ -152,9 +147,16 @@ struct ContentView: View {
         isSideBarOpened = false
     }
     
-    var timelineNavItem: Text {
-        return Text(timeline_name(selected_timeline))
-            .bold()
+    var timelineNavItem: some View {
+        VStack {
+            Text(timeline_name(selected_timeline))
+                .bold()
+            if let menu_subtitle {
+                Text(menu_subtitle)
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+            }
+        }
     }
     
     func MainContent(damus: DamusState) -> some View {
@@ -170,34 +172,25 @@ struct ContentView: View {
                 }
                 
             case .home:
-                PostingTimelineView
+                PostingTimelineView(damus_state: damus_state!, home: home, isSideBarOpened: $isSideBarOpened, active_sheet: $active_sheet, headerOffset: $headerOffset)
                 
             case .notifications:
-                NotificationsView(state: damus, notifications: home.notifications)
+                NotificationsView(state: damus, notifications: home.notifications, subtitle: $menu_subtitle)
                 
             case .dms:
                 DirectMessagesView(damus_state: damus_state!, model: damus_state!.dms, settings: damus_state!.settings)
             }
         }
+        .background(DamusColors.adaptableWhite)
+        .edgesIgnoringSafeArea(selected_timeline != .home ? [] : [.top, .bottom])
         .navigationBarTitle(timeline_name(selected_timeline), displayMode: .inline)
+        .toolbar(selected_timeline != .home ? .visible : .hidden)
         .toolbar {
             ToolbarItem(placement: .principal) {
                 VStack {
-                    if selected_timeline == .home {
-                        Image("damus-home")
-                            .resizable()
-                            .frame(width:30,height:30)
-                            .shadow(color: DamusColors.purple, radius: 2)
-                            .opacity(isSideBarOpened ? 0 : 1)
-                            .animation(isSideBarOpened ? .none : .default, value: isSideBarOpened)
-                            .onTapGesture {
-                                isSideBarOpened.toggle()
-                            }
-                    } else {
-                        timelineNavItem
-                            .opacity(isSideBarOpened ? 0 : 1)
-                            .animation(isSideBarOpened ? .none : .default, value: isSideBarOpened)
-                    }
+                    timelineNavItem
+                        .opacity(isSideBarOpened ? 0 : 1)
+                        .animation(isSideBarOpened ? .none : .default, value: isSideBarOpened)
                 }
             }
         }
@@ -229,12 +222,6 @@ struct ContentView: View {
         navigationCoordinator.push(route: Route.Script(script: model))
     }
     
-    func open_profile(pubkey: Pubkey) {
-        let profile_model = ProfileModel(pubkey: pubkey, damus: damus_state!)
-        let followers = FollowersModel(damus_state: damus_state!, target: pubkey)
-        navigationCoordinator.push(route: Route.Profile(profile: profile_model, followers: followers))
-    }
-    
     func open_search(filt: NostrFilter) {
         let search = SearchModel(state: damus_state!, search: filt)
         navigationCoordinator.push(route: Route.Search(search: search))
@@ -248,14 +235,7 @@ struct ContentView: View {
                         MainContent(damus: damus)
                             .toolbar() {
                                 ToolbarItem(placement: .navigationBarLeading) {
-                                    Button {
-                                        isSideBarOpened.toggle()
-                                    } label: {
-                                        ProfilePicView(pubkey: damus_state!.pubkey, size: 32, highlight: .none, profiles: damus_state!.profiles, disable_animation: damus_state!.settings.disable_animation)
-                                            .opacity(isSideBarOpened ? 0 : 1)
-                                            .animation(isSideBarOpened ? .none : .default, value: isSideBarOpened)
-                                    }
-                                    .disabled(isSideBarOpened)
+                                    TopbarSideMenuButton(damus_state: damus, isSideBarOpened: $isSideBarOpened)
                                 }
                                 
                                 ToolbarItem(placement: .navigationBarTrailing) {
@@ -276,9 +256,11 @@ struct ContentView: View {
                                 }
                             }
                     }
+                    .background(DamusColors.adaptableWhite)
+                    .edgesIgnoringSafeArea(selected_timeline != .home ? [] : [.top, .bottom])
                     .tabViewStyle(.page(indexDisplayMode: .never))
                     .overlay(
-                        SideMenuView(damus_state: damus_state!, isSidebarVisible: $isSideBarOpened.animation())
+                        SideMenuView(damus_state: damus_state!, isSidebarVisible: $isSideBarOpened.animation(), selected: $selected_timeline)
                     )
                     .navigationDestination(for: Route.self) { route in
                         route.view(navigationCoordinator: navigationCoordinator, damusState: damus_state!)
@@ -288,13 +270,28 @@ struct ContentView: View {
                     }
                 }
                 .navigationViewStyle(.stack)
-            
-                if !hide_bar {
-                    TabBar(nstatus: home.notification_status, selected: $selected_timeline, settings: damus.settings, action: switch_timeline)
-                        .padding([.bottom], 8)
-                        .background(Color(uiColor: .systemBackground).ignoresSafeArea())
-                } else {
-                    Text("")
+                .damus_full_screen_cover($active_full_screen_item, damus_state: damus, content: { item in
+                    return item.view(damus_state: damus)
+                })
+                .overlay(alignment: .bottom) {
+                    if !hide_bar {
+                        if !isSideBarOpened {
+                            TabBar(nstatus: home.notification_status, navIsAtRoot: navIsAtRoot(), selected: $selected_timeline, headerOffset: $headerOffset, settings: damus.settings, action: switch_timeline)
+                                .padding([.bottom], 8)
+                                .background(selected_timeline != .home || (selected_timeline == .home && !self.navIsAtRoot()) ? DamusColors.adaptableWhite : DamusColors.adaptableWhite.opacity(abs(1.25 - (abs(headerOffset/100.0)))))
+                                .anchorPreference(key: HeaderBoundsKey.self, value: .bounds){$0}
+                                .overlayPreferenceValue(HeaderBoundsKey.self) { value in
+                                    GeometryReader{ proxy in
+                                        if let anchor = value{
+                                            Color.clear
+                                                .onAppear {
+                                                    tabHeight = proxy[anchor].height
+                                                }
+                                        }
+                                    }
+                                }
+                        }
+                    }
                 }
             }
         }
@@ -309,6 +306,9 @@ struct ContentView: View {
                 hasSeenOnboardingSuggestions = true
             }
             self.appDelegate?.state = damus_state
+            Task {  // We probably don't need this to be a detached task. According to https://docs.swift.org/swift-book/documentation/the-swift-programming-language/concurrency/#Defining-and-Calling-Asynchronous-Functions, awaits are only suspension points that do not block the thread.
+                await self.listenAndHandleLocalNotifications()
+            }
         }
         .sheet(item: $active_sheet) { item in
             switch item {
@@ -338,36 +338,14 @@ struct ContentView: View {
                 DamusPurpleURLSheetView(damus_state: damus_state!, purple_url: purple_url)
             case .purple_onboarding:
                 DamusPurpleNewUserOnboardingView(damus_state: damus_state)
+            case .error(let error):
+                ErrorView(damus_state: damus_state!, error: error)
             }
         }
         .onOpenURL { url in
-            on_open_url(state: damus_state!, url: url) { res in
-                guard let res else {
-                    return
-                }
-                
-                switch res {
-                    case .filter(let filt): self.open_search(filt: filt)
-                    case .profile(let pk):  self.open_profile(pubkey: pk)
-                    case .event(let ev):    self.open_event(ev: ev)
-                    case .wallet_connect(let nwc): self.open_wallet(nwc: nwc)
-                    case .script(let data): self.open_script(data)
-                    case .purple(let purple_url):
-                        if case let .welcome(checkout_id) = purple_url.variant {
-                            // If this is a welcome link, do the following before showing the onboarding screen:
-                            // 1. Check if this is legitimate and good to go.
-                            // 2. Mark as complete if this is good to go.
-                            Task {
-                                let is_good_to_go = try? await damus_state.purple.check_and_mark_ln_checkout_is_good_to_go(checkout_id: checkout_id)
-                                if is_good_to_go == true {
-                                    self.active_sheet = .purple(purple_url)
-                                }
-                            }
-                        }
-                        else {
-                            self.active_sheet = .purple(purple_url)
-                        }
-                }
+            Task {
+                let open_action = await DamusURLHandler.handle_opening_url_and_compute_view_action(damus_state: self.damus_state, url: url)
+                self.execute_open_action(open_action)
             }
         }
         .onReceive(handle_notify(.compose)) { action in
@@ -389,6 +367,8 @@ struct ContentView: View {
             self.confirm_mute = true
         }
         .onReceive(handle_notify(.attached_wallet)) { nwc in
+            try? damus_state.pool.add_relay(.nwc(url: nwc.relay))
+
             // update the lightning address on our profile when we attach a
             // wallet with an associated
             guard let ds = self.damus_state,
@@ -452,6 +432,9 @@ struct ContentView: View {
         .onReceive(handle_notify(.present_sheet)) { sheet in
             self.active_sheet = sheet
         }
+        .onReceive(handle_notify(.present_full_screen_item)) { item in
+            self.active_full_screen_item = item
+        }
         .onReceive(handle_notify(.zapping)) { zap_ev in
             guard !zap_ev.is_custom else {
                 return
@@ -527,27 +510,6 @@ struct ContentView: View {
             @unknown default:
                 break
             }
-        }
-        .onReceive(handle_notify(.local_notification)) { local in
-            guard let damus_state else { return }
-
-            switch local.mention {
-            case .pubkey(let pubkey):
-                open_profile(pubkey: pubkey)
-
-            case .note(let noteId):
-                openEvent(noteId: noteId, notificationType: local.type)
-            case .nevent(let nevent):
-                openEvent(noteId: nevent.noteid, notificationType: local.type)
-            case .nprofile(let nprofile):
-                open_profile(pubkey: nprofile.author)
-            case .nrelay(_):
-                break
-            case .naddr(let naddr):
-                break
-            }
-
-
         }
         .onReceive(handle_notify(.onlyzaps_mode)) { hide in
             home.filter_events()
@@ -604,7 +566,7 @@ struct ContentView: View {
         }, message: {
             Text("No mute list found, create a new one? This will overwrite any previous mute lists.", comment: "Alert message prompt that asks if the user wants to create a new mute list, overwriting previous mute lists.")
         })
-        .alert(NSLocalizedString("Mute User", comment: "Title of alert for muting a user."), isPresented: $confirm_mute, actions: {
+        .alert(NSLocalizedString("Mute/Block User", comment: "Title of alert for muting/blocking a user."), isPresented: $confirm_mute, actions: {
             Button(NSLocalizedString("Cancel", comment: "Alert button to cancel out of alert for muting a user."), role: .cancel) {
                 confirm_mute = false
             }
@@ -657,6 +619,28 @@ struct ContentView: View {
         self.selected_timeline = timeline
     }
 
+    /// Listens to requests to open a push/local user notification
+    ///
+    /// This function never returns, it just keeps streaming
+    func listenAndHandleLocalNotifications() async {
+        for await notification in await QueueableNotify<LossyLocalNotification>.shared.stream {
+            self.handleNotification(notification: notification)
+        }
+    }
+
+    func handleNotification(notification: LossyLocalNotification) {
+        Log.info("ContentView is handling a notification", for: .push_notifications)
+        guard let damus_state else {
+            // This should never happen because `listenAndHandleLocalNotifications` is called after damus state is initialized in `onAppear`
+            assertionFailure("DamusState not loaded when ContentView (new handler) was handling a notification")
+            Log.error("DamusState not loaded when ContentView (new handler) was handling a notification", for: .push_notifications)
+            return
+        }
+        let local = notification
+        let openAction = local.toViewOpenAction()
+        self.execute_open_action(openAction)
+    }
+
     func connect() {
         // nostrdb
         var mndb = Ndb()
@@ -717,9 +701,10 @@ struct ContentView: View {
                                       wallet: WalletModel(settings: settings),
                                       nav: self.navigationCoordinator,
                                       music: MusicController(onChange: music_changed),
-                                      video: VideoController(),
+                                      video: DamusVideoCoordinator(),
                                       ndb: ndb,
-                                      quote_reposts: .init(our_pubkey: pubkey)
+                                      quote_reposts: .init(our_pubkey: pubkey),
+                                      emoji_provider: DefaultEmojiProvider(showAllVariations: true)
         )
         
         home.damus_state = self.damus_state!
@@ -761,22 +746,57 @@ struct ContentView: View {
             damus_state.postbox.send(ev)
         }
     }
-
-    private func openEvent(noteId: NoteId, notificationType: LocalNotificationType) {
-        guard let target = damus_state.events.lookup(noteId) else {
+    
+    /// An open action within the app
+    /// This is used to model, store, and communicate a desired view action to be taken as a result of opening an object,
+    /// for example a URL
+    ///
+    /// ## Implementation notes
+    ///
+    /// - The reason this was created was to separate URL parsing logic, the underlying actions that mutate the state of the app, and the action to be taken on the view layer as a result. This makes it easier to test, to read the URL handling code, and to add new functionality in between the two (e.g. a confirmation screen before proceeding with a given open action)
+    enum ViewOpenAction {
+        /// Open a page route
+        case route(Route)
+        /// Open a sheet
+        case sheet(Sheets)
+        /// Do nothing.
+        ///
+        /// ## Implementation notes
+        /// - This is used here instead of Optional values to make semantics explicit and force better programming intent, instead of accidentally doing nothing because of Swift's syntax sugar.
+        case no_action
+    }
+    
+    /// Executes an action to open something in the app view
+    ///
+    /// - Parameter open_action: The action to perform
+    func execute_open_action(_ open_action: ViewOpenAction) {
+        switch open_action {
+        case .route(let route):
+            navigationCoordinator.push(route: route)
+        case .sheet(let sheet):
+            self.active_sheet = sheet
+        case .no_action:
             return
         }
+    }
+}
 
-        switch notificationType {
-        case .dm:
-            selected_timeline = .dms
-            damus_state.dms.set_active_dm(target.pubkey)
-            navigationCoordinator.push(route: Route.DMChat(dms: damus_state.dms.active_model))
-        case .like, .zap, .mention, .repost:
-            open_event(ev: target)
-        case .profile_zap:
-            break
+struct TopbarSideMenuButton: View {
+    let damus_state: DamusState
+    @Binding var isSideBarOpened: Bool
+    
+    var body: some View {
+        Button {
+            isSideBarOpened.toggle()
+        } label: {
+            ProfilePicView(pubkey: damus_state.pubkey, size: 32, highlight: .none, profiles: damus_state.profiles, disable_animation: damus_state.settings.disable_animation)
+                .opacity(isSideBarOpened ? 0 : 1)
+                .animation(isSideBarOpened ? .none : .default, value: isSideBarOpened)
+                .accessibilityHidden(true)  // Knowing there is a profile picture here leads to no actionable outcome to VoiceOver users, so it is best not to show it
         }
+        .accessibilityIdentifier(AppAccessibilityIdentifiers.main_side_menu_button.rawValue)
+        .accessibilityLabel(NSLocalizedString("Side menu", comment: "Accessibility label for the side menu button at the topbar"))
+        .disabled(isSideBarOpened)
     }
 }
 
@@ -873,7 +893,7 @@ func update_filters_with_since(last_of_kind: [UInt32: NostrEvent], filters: [Nos
 
 
 func setup_notifications() {
-    UIApplication.shared.registerForRemoteNotifications()
+    this_app.registerForRemoteNotifications()
     let center = UNUserNotificationCenter.current()
     
     center.getNotificationSettings { settings in
@@ -907,14 +927,41 @@ enum FindEventType {
 
 enum FoundEvent {
     case profile(Pubkey)
-    case invalid_profile(NostrEvent)
     case event(NostrEvent)
 }
 
+/// Finds an event from NostrDB if it exists, or from the network
+///
+/// This is the callback version. There is also an asyc/await version of this function.
+///
+/// - Parameters:
+///   - state: Damus state
+///   - query_: The query, including the event being looked for, and the relays to use when looking
+///   - callback: The function to call with results
 func find_event(state: DamusState, query query_: FindEvent, callback: @escaping (FoundEvent?) -> ()) {
     return find_event_with_subid(state: state, query: query_, subid: UUID().description, callback: callback)
 }
 
+/// Finds an event from NostrDB if it exists, or from the network
+///
+/// This is a the async/await version of `find_event`. Use this when using callbacks is impossible or cumbersome.
+///
+/// - Parameters:
+///   - state: Damus state
+///   - query_: The query, including the event being looked for, and the relays to use when looking
+///   - callback: The function to call with results
+func find_event(state: DamusState, query query_: FindEvent) async -> FoundEvent? {
+    await withCheckedContinuation { continuation in
+        find_event(state: state, query: query_) { event in
+            var already_resumed = false
+            if !already_resumed {   // Ensure we do not resume twice, as it causes a crash
+                continuation.resume(returning: event)
+                already_resumed = true
+            }
+        }
+    }
+}
+
 func find_event_with_subid(state: DamusState, query query_: FindEvent, subid: String, callback: @escaping (FoundEvent?) -> ()) {
 
     var filter: NostrFilter? = nil
@@ -964,10 +1011,6 @@ func find_event_with_subid(state: DamusState, query query_: FindEvent, subid: St
             switch query {
             case .profile:
                 if ev.known_kind == .metadata {
-                    guard state.ndb.lookup_profile_key(ev.pubkey) != nil else {
-                        callback(.invalid_profile(ev))
-                        return
-                    }
                     callback(.profile(ev.pubkey))
                 }
             case .event:
@@ -976,20 +1019,28 @@ func find_event_with_subid(state: DamusState, query query_: FindEvent, subid: St
         case .eose:
             if !has_event {
                 attempts += 1
-                if attempts == state.pool.our_descriptors.count / 2 {
-                    callback(nil)
+                if attempts >= state.pool.our_descriptors.count {
+                    callback(nil)   // If we could not find any events in any of the relays we are connected to, send back nil
                 }
-                state.pool.unsubscribe(sub_id: subid, to: [relay_id])
             }
+            state.pool.unsubscribe(sub_id: subid, to: [relay_id])   // We are only finding an event once, so close subscription on eose
         case .notice:
             break
         case .auth:
             break
         }
-
     }
 }
 
+
+/// Finds a replaceable event based on an `naddr` address.
+///
+/// This is the callback version of the function. There is another function that makes use of async/await
+///
+/// - Parameters:
+///   - damus_state: The Damus state
+///   - naddr: the `naddr` address
+///   - callback: A function to handle the found event
 func naddrLookup(damus_state: DamusState, naddr: NAddr, callback: @escaping (NostrEvent?) -> ()) {
     var nostrKinds: [NostrKind]? = NostrKind(rawValue: naddr.kind).map { [$0] }
 
@@ -1018,6 +1069,26 @@ func naddrLookup(damus_state: DamusState, naddr: NAddr, callback: @escaping (Nos
     }
 }
 
+/// Finds a replaceable event based on an `naddr` address.
+///
+/// This is the async/await version of the function. Another version of this function which makes use of callback functions also exists .
+///
+/// - Parameters:
+///   - damus_state: The Damus state
+///   - naddr: the `naddr` address
+///   - callback: A function to handle the found event
+func naddrLookup(damus_state: DamusState, naddr: NAddr) async -> NostrEvent? {
+    await withCheckedContinuation { continuation in
+        var already_resumed = false
+        naddrLookup(damus_state: damus_state, naddr: naddr) { event in
+            if !already_resumed {   // Ensure we do not resume twice, as it causes a crash
+                continuation.resume(returning: event)
+                already_resumed = true
+            }
+        }
+    }
+}
+
 func timeline_name(_ timeline: Timeline?) -> String {
     guard let timeline else {
         return ""
@@ -1105,7 +1176,7 @@ func handle_post_notification(keypair: FullKeypair, postbox: PostBox, events: Ev
         //let post = tup.0
         //let to_relays = tup.1
         print("post \(post.content)")
-        guard let new_ev = post_to_event(post: post, keypair: keypair) else {
+        guard let new_ev = post.to_event(keypair: keypair) else {
             return false
         }
         postbox.send(new_ev)
@@ -1128,60 +1199,32 @@ func handle_post_notification(keypair: FullKeypair, postbox: PostBox, events: Ev
     }
 }
 
-
-enum OpenResult {
-    case profile(Pubkey)
-    case filter(NostrFilter)
-    case event(NostrEvent)
-    case wallet_connect(WalletConnectURL)
-    case script([UInt8])
-    case purple(DamusPurpleURL)
-}
-
-func on_open_url(state: DamusState, url: URL, result: @escaping (OpenResult?) -> Void) {
-    if let purple_url = DamusPurpleURL(url: url) {
-        result(.purple(purple_url))
-        return
-    }
-    
-    if let nwc = WalletConnectURL(str: url.absoluteString) {
-        result(.wallet_connect(nwc))
-        return
-    }
-    
-    guard let link = decode_nostr_uri(url.absoluteString) else {
-        result(nil)
-        return
-    }
-    
-    switch link {
-    case .ref(let ref):
-        switch ref {
-        case .pubkey(let pk):
-            result(.profile(pk))
-        case .event(let noteid):
-            find_event(state: state, query: .event(evid: noteid)) { res in
-                guard let res, case .event(let ev) = res else { return }
-                result(.event(ev))
-            }
-        case .hashtag(let ht):
-            result(.filter(.filter_hashtag([ht.hashtag])))
-        case .param, .quote:
-            // doesn't really make sense here
-            break
-        case .naddr(let naddr):
-            naddrLookup(damus_state: state, naddr: naddr) { res in
-                guard let res = res else { return }
-                result(.event(res))
-            }
+extension LossyLocalNotification {
+    /// Computes a view open action from a mention reference.
+    /// Use this when opening a user-presentable interface to a specific mention reference.
+    func toViewOpenAction() -> ContentView.ViewOpenAction {
+        switch self.mention {
+        case .pubkey(let pubkey):
+            return .route(.ProfileByKey(pubkey: pubkey))
+        case .note(let noteId):
+            return .route(.LoadableNostrEvent(note_reference: .note_id(noteId)))
+        case .nevent(let nEvent):
+            // TODO: Improve this by implementing a route that handles nevents with their relay hints.
+            return .route(.LoadableNostrEvent(note_reference: .note_id(nEvent.noteid)))
+        case .nprofile(let nProfile):
+            // TODO: Improve this by implementing a profile route that handles nprofiles with their relay hints.
+            return .route(.ProfileByKey(pubkey: nProfile.author))
+        case .nrelay(let string):
+            // We do not need to implement `nrelay` support, it has been deprecated.
+            // See https://github.com/nostr-protocol/nips/blob/6e7a618e7f873bb91e743caacc3b09edab7796a0/BREAKING.md?plain=1#L21
+            return .sheet(.error(ErrorView.UserPresentableError(
+                user_visible_description: NSLocalizedString("You opened an invalid link. The link you tried to open refers to \"nrelay\", which has been deprecated and is not supported.", comment: "User-visible error description for a user who tries to open a deprecated \"nrelay\" link."),
+                tip: NSLocalizedString("Please contact the person who provided the link, and ask for another link.", comment: "User-visible tip on what to do if a link contains a deprecated \"nrelay\" reference."),
+                technical_info: "`MentionRef.toViewOpenAction` detected deprecated `nrelay` contents"
+            )))
+        case .naddr(let nAddr):
+            return .route(.LoadableNostrEvent(note_reference: .naddr(nAddr)))
         }
-    case .filter(let filt):
-        result(.filter(filt))
-        break
-        // TODO: handle filter searches?
-    case .script(let script):
-        result(.script(script))
-        break
     }
 }