Fix note content rendering to not remove whitespace before hashtag

Changelog-Fixed: Fixed note content rendering to not remove whitespace before hashtag Closes: https://github.com/damus-io/damus/issues/3122 Fixes: f436291209 ("Fix note content rendering to not remove whitespace before hashtag") Signed-off-by: Terry Yiu <git@tyiu.xyz>
2025-07-20 01:28:40 -04:00
775 changed files with 12707 additions and 73598 deletions
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -4,37 +4,8 @@ _[Please provide a summary of the changes in this PR.]_

 ## Checklist

-<!-- 
-CHOOSE YOUR CHECKLIST: 
- If this is an EXPERIMENTAL DAMUS LABS FEATURE, follow the "Experimental Feature Checklist" below and DELETE the "Standard PR Checklist"
- If this is a STANDARD PR, follow the "Standard PR Checklist" below and DELETE the "Experimental Feature Checklist"
-->
-
-### Experimental Feature Checklist
-
-<!-- DELETE THIS SECTION if this is a standard PR -->
-
-> [!TIP]
-> This Pull Request is an experimental feature for Damus Labs, and follows a fast-track review process.
-> The overall requirements are lowered and the review process is not as strict as usual. However, the feature will only be available for Purple users who opt-in.
-
- [ ] I have read (or I am familiar with) the [Contribution Guidelines](../docs/CONTRIBUTING.md).
- [ ] I have done some testing on the changes in this PR to ensure it is at least functional.
- [ ] I made sure that this new feature is only available when the user opts-in from the Damus Labs screen, and does not affect the rest of the app when turned off. 
- [ ] 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 an appropriate changelog entry to my commit in this PR. See [Adding changelog entries](../docs/CONTRIBUTING.md#add-changelog-changed-changelog-fixed-etc).
-    - Example changelog entry: `Changelog-Added: Added experimental feature <X> to Damus Labs`
-
-### Standard PR Checklist
-
-<!-- DELETE THIS SECTION if this is an experimental Damus Labs feature -->
-
 - [ ] I have read (or I am familiar with) the [Contribution Guidelines](../docs/CONTRIBUTING.md)
 - [ ] I have tested the changes in this PR
- [ ] I have profiled the changes to ensure there are no performance regressions, or I do not need to profile the changes.
-    - Utilize Xcode profiler to measure performance impact of code changes. See https://developer.apple.com/videos/play/wwdc2025/306
-    - If not needed, provide reason:
 - [ ] I have opened or referred to an existing github issue related to this change.
 - [ ] 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)
@@ -63,4 +34,4 @@ _Please provide a test report for the changes in this PR. You can use the templa

 ## Other notes

-_[Please provide any other information that you think is relevant to this PR.]_
+_[Please provide any other information that you think is relevant to this PR.]_
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -1,47 +0,0 @@
-# Agents
-
-## Damus Overview
-
-Damus is an iOS client built around a local relay model ([damus-io/damus#3204](https://github.com/damus-io/damus/pull/3204)) to keep interactions snappy and resilient. The app operates on `nostrdb` ([source](https://github.com/damus-io/damus/tree/master/nostrdb)), and agents working on Damus should maximize usage of `nostrdb` facilities whenever possible.
-
-## Codebase Layout
-
- `damus/` contains the SwiftUI app. Key subdirectories: `Core` (protocol, storage, networking, nostr primitives), `Features` (feature-specific flows like Timeline, Wallet, Purple), `Shared` (reusable UI components and utilities), `Models`, and localized resources (`*.lproj`, `en-US.xcloc`).
- `nostrdb/` hosts the embedded database. Swift bindings (`Ndb.swift`, iterators) wrap a C/LMDB core; prefer these abstractions when working with persistence or queries.
- `damus-c/` bridges C helpers (e.g., WASM runner) into Swift; check `damus-Bridging-Header.h` before adding new bridges.
- `nostrscript/` contains AssemblyScript sources compiled to WASM via the top-level `Makefile`.
- Tests live in `damusTests/` (unit/snapshot coverage) and `damusUITests/` (UI smoke tests). Keep them running before submitting changes.
-
-## Development Workflow
-
- Use `just build` / `just test` for simulator builds and the primary test suite (requires `xcbeautify`). Update or add `just` recipes if new repeatable workflows emerge.
- Xcode project is `damus.xcodeproj`; the main scheme is `damus`. Ensure new targets or resources integrate cleanly with this scheme.
- Rebuild WASM helpers with `make` when touching `nostrscript/` sources.
- Follow `docs/DEV_TIPS.md` for debugging (enabling Info logging, staging push notification settings) and keep tips updated when discovering new workflows.
-
-## Testing Expectations
-
- Provide a concrete test report in each PR (see `.github/pull_request_template.md`). Document devices, OS versions, and scenarios exercised.
- Add or update unit tests in `damusTests/` alongside feature changes, especially when touching parsing, storage, or replay logic.
- UI regressions should include `damusUITests/` coverage or rationale when automation is impractical.
- Snapshot fixtures under `damusTests/__Snapshots__` must be regenerated deliberately; explain updates in commit messages.
-
-## Contribution Standards
-
- Sign all commits (`git commit -s`) and include appropriate `Changelog-*`, `Closes:`, or `Fixes:` tags as described in `docs/CONTRIBUTING.md`.
- Keep patches scoped: one logical change per commit, ensuring the app builds and runs after each step.
- Favor Swift-first solutions that lean on `nostrdb` types (`Ndb`, `NdbNote`, iterators) before introducing new storage mechanisms.
- Update documentation when workflows change, especially this file, `README.md`, or developer notes.
-
-## Agent Requirements
-
-1. Code should tend toward simplicity.
-2. Commits should be logically distinct.
-3. Commits should be standalone.
-4. Code should be human readable.
-5. Code should be human reviewable.
-6. Ensure docstring coverage for any code added, or modified.
-7. Review and follow `pull_request_template.md` when creating PRs for iOS Damus.
-8. Ensure nevernesting: favor early returns and guard clauses over deeply nested conditionals; simplify control flow by exiting early instead of wrapping logic in multiple layers of `if` statements.
-9. Before proposing changes, please **review and analyze if a change or upgrade to nostrdb** is beneficial to the change at hand.
-10. **Never block the main thread**: All network requests, database queries, and expensive computations must run on background threads/queues. Use `Task { }`, `DispatchQueue.global()`, or Swift concurrency (`async/await`) appropriately. UI updates must dispatch back to `@MainActor`. Test for hangs and freezes before submitting.      
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,54 +1,3 @@
-## [1.15] - 2025-07-11
-
-**Note:** This version was only released on TestFlight, and never officially released on the App Store.
-
-### Added
-
- Added new onboarding suggestions based on user-selected interests (Daniel D’Aquino)
- Added adjustable max budget setting for Coinos one-click wallets (Daniel D’Aquino)
- Added send feature to the wallet view (Daniel D’Aquino)
- Added popover tips to DMs and Notifications toolbars on Trusted Network button (Terry Yiu)
- Added tip in threads to inform users what trusted network means (Terry Yiu)
- Added web of trust reply sorting in threads to mitigate spam (Terry Yiu)
- Added follow list kind 39089 (ericholguin)
- Added follow pack preview (ericholguin)
- Added follow pack timeline to Universe View (ericholguin)
- Added NIP-05 favicon to profile names and NIP-05 web of trust feed (Terry Yiu)
- Display uploading indicator in post view (Swift Coder)
-
-
-### Changed
-
- Improved the image sizing behavior on the image carousel for a smoother experience (Daniel D’Aquino)
- Handle npub correctly in draft notes (Askia Linder)
- Move users-section to be last in muted view (Askia Linder)
- Removed media from regular link previews if media is already being shown (Terry Yiu)
- Renamed Friends of Friends to Trusted Network (Terry Yiu)
- Added privacy-based redaction to nsec in key settings view (Terry Yiu)
- Added privacy-based redaction to wallet view (Terry Yiu)
- Renamed Bitcoin Beach wallet to Blink (Terry Yiu)
-
-
-### Fixed
-
- Fixed #nsfw tag filtering to be case insensitive (Terry Yiu)
- Fixed stretchy banner header in Edit profile (Swift)
- Fixed note rendering to include regular link previews with media removed when media previews are disabled (Terry Yiu)
- Improve error handling on wallet send feature (Daniel D’Aquino)
- Fixed issue where the text "??" would appear on the balance while loading (Daniel D’Aquino)
- Hide end previewables when hashtags are present (Terry Yiu)
- Fixed wallet transactions to always show profile display name unless there is no pubkey (Terry Yiu)
- Fixed quotes view header alignment (Terry Yiu)
-
-
-### Removed
-
- Removed hashtags in Universe View (ericholguin)
-
-
-[1.15]: https://github.com/damus-io/damus/releases/tag/v1.15
-
-
 ## [1.14] - 2025-05-25

 ### Added
--- a/DamusNotificationService/NotificationExtensionState.swift
+++ b/DamusNotificationService/NotificationExtensionState.swift
@@ -7,7 +7,6 @@

 import Foundation

-@MainActor
 struct NotificationExtensionState: HeadlessDamusState {
    let ndb: Ndb
    let settings: UserSettingsStore
--- a/DamusNotificationService/NotificationFormatter.swift
+++ b/DamusNotificationService/NotificationFormatter.swift
@@ -103,7 +103,7 @@ struct NotificationFormatter {
                content.title = Self.zap_notification_title(zap)
                content.body = Self.zap_notification_body(profiles: state.profiles, zap: zap)
                content.sound = UNNotificationSound.default
-                content.userInfo = LossyLocalNotification(type: .zap, mention: .init(nip19: .note(notify.event.id))).to_user_info()
+                content.userInfo = LossyLocalNotification(type: .zap, mention: .note(notify.event.id)).to_user_info()
                return (content, "myZapNotification")
            default:
                // The sync method should have taken care of this.
@@ -125,7 +125,8 @@ struct NotificationFormatter {
        let src = zap.request.ev
        let pk = zap.is_anon ? ANON_PUBKEY : src.pubkey

-        let profile = try? profiles.lookup(id: pk)
+        let profile_txn = profiles.lookup(id: pk)
+        let profile = profile_txn?.unsafeUnownedValue
        let name = Profile.displayName(profile: profile, pubkey: pk).displayName.truncate(maxLength: 50)

        let sats = NSNumber(value: (Double(zap.invoice.amount) / 1000.0))
--- a/DamusNotificationService/NotificationService.swift
+++ b/DamusNotificationService/NotificationService.swift
@@ -44,61 +44,63 @@ 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() 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.
+                contentHandler(UNNotificationContent())
+                return
+            }
+            contentHandler(improved_content)
+            return
+        }
+
+        let sender_profile = {
+            let txn = state.ndb.lookup_profile(nostr_event.pubkey)
+            let profile = txn?.unsafeUnownedValue?.profile
+            let picture = ((profile?.picture.map { URL(string: $0) }) ?? URL(string: robohash(nostr_event.pubkey)))!
+            return ProfileBuf(picture: picture,
+                                 name: profile?.name,
+                         display_name: profile?.display_name,
+                                nip05: profile?.nip05)
+        }()
+        let sender_pubkey = nostr_event.pubkey
+
+        // 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) {
+            // We cannot really suppress muted notifications until we have the notification supression entitlement.
+            // The best we can do if we ever get those muted notifications (which we generally won't due to server-side processing) is to obscure the details
+            let content = UNMutableNotificationContent()
+            content.title = NSLocalizedString("Muted event", comment: "Title for a push notification which has been muted")
+            content.body = NSLocalizedString("This is an event that has been muted according to your mute list rules. We cannot suppress this notification, but we obscured the details to respect your preferences", comment: "Description for a push notification which has been muted, and explanation that we cannot suppress it")
+            content.sound = UNNotificationSound.default
+            contentHandler(content)
+            return
+        }
+
+        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
+            contentHandler(request.content)
+            return
+        }
+
+        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
+            contentHandler(request.content)
+            return
+        }
+
+
        Task {
-            guard let state = await 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.
-                    contentHandler(UNNotificationContent())
-                    return
-                }
-                contentHandler(improved_content)
-                return
-            }
-
-            let sender_profile = {
-                let profile = try? state.profiles.lookup(id: nostr_event.pubkey)
-                let picture = ((profile?.picture.map { URL(string: $0) }) ?? URL(string: robohash(nostr_event.pubkey)))!
-                return ProfileBuf(picture: picture,
-                                     name: profile?.name,
-                             display_name: profile?.display_name,
-                                    nip05: profile?.nip05)
-            }()
-            let sender_pubkey = nostr_event.pubkey
-
-            // 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 await state.mutelist_manager.is_event_muted(nostr_event) {
-                // We cannot really suppress muted notifications until we have the notification supression entitlement.
-                // The best we can do if we ever get those muted notifications (which we generally won't due to server-side processing) is to obscure the details
-                let content = UNMutableNotificationContent()
-                content.title = NSLocalizedString("Muted event", comment: "Title for a push notification which has been muted")
-                content.body = NSLocalizedString("This is an event that has been muted according to your mute list rules. We cannot suppress this notification, but we obscured the details to respect your preferences", comment: "Description for a push notification which has been muted, and explanation that we cannot suppress it")
-                content.sound = UNNotificationSound.default
-                contentHandler(content)
-                return
-            }
-
-            guard await 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
-                contentHandler(request.content)
-                return
-            }
-
-            guard let notification_object = generate_local_notification_object(ndb: state.ndb, 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
-                contentHandler(request.content)
-                return
-            }
-        
            let sender_dn = DisplayName(name: sender_profile.name, display_name: sender_profile.display_name, pubkey: sender_pubkey)
            guard let (improvedContent, _) = await NotificationFormatter.shared.format_message(displayName: sender_dn.displayName, notify: notification_object, state: state) else {

@@ -184,13 +186,8 @@ func message_intent_from_note(ndb: Ndb, sender_profile: ProfileBuf, content: Str

    // gather recipients
    if let recipient_note_id = note.direct_replies() {
-        let replying_to_pk = try? ndb.lookup_note(recipient_note_id, borrow: { replying_to_note -> Pubkey? in
-            switch replying_to_note {
-            case .none: return nil
-            case .some(let note): return note.pubkey
-            }
-        })
-        if let replying_to_pk {
+        let replying_to = ndb.lookup_note(recipient_note_id)
+        if let replying_to_pk = replying_to?.unsafeUnownedValue?.pubkey {
            meta.isReplyToCurrentUser = replying_to_pk == our_pubkey

            if replying_to_pk != sender_pk {
@@ -250,12 +247,8 @@ func message_intent_from_note(ndb: Ndb, sender_profile: ProfileBuf, content: Str
 }

 func pubkey_to_inperson(ndb: Ndb, pubkey: Pubkey, our_pubkey: Pubkey) async -> INPerson {
-    let profile = try? ndb.lookup_profile(pubkey, borrow: { profileRecord in
-        switch profileRecord {
-        case .some(let pr): return pr.profile
-        case .none: return nil
-        }
-    })
+    let profile_txn = ndb.lookup_profile(pubkey)
+    let profile = profile_txn?.unsafeUnownedValue?.profile
    let name = profile?.name
    let display_name = profile?.display_name
    let nip05 = profile?.nip05
--- a/README.md
+++ b/README.md
@@ -154,7 +154,7 @@ We have a few mailing lists that anyone can join to get involved in damus develo

 ### Contributing

-Before starting to work on any contributions, please read [docs/CONTRIBUTING.md](./docs/CONTRIBUTING.md).
+See [docs/CONTRIBUTING.md](./docs/CONTRIBUTING.md)

 ### Privacy
 Your internet protocol (IP) address is exposed to the relays you connect to, and third party media hosters (e.g. nostr.build, imgur.com, giphy.com, youtube.com etc.) that render on Damus. If you want to improve your privacy, consider utilizing a service that masks your IP address (e.g. a VPN) from trackers online.
--- a/1
+++ b/1
@@ -1,2 +1 @@
 Fix q tags
-1.5-24 profile loading was much better
--- a/damus-c/alignof.h
+++ b/damus-c/alignof.h
--- a/damus-c/amount.c
+++ b/damus-c/amount.c
--- a/damus-c/amount.h
+++ b/damus-c/amount.h
--- a/damus-c/array_size.h
+++ b/damus-c/array_size.h
--- a/damus-c/bech32.c
+++ b/damus-c/bech32.c
--- a/damus-c/bech32.h
+++ b/damus-c/bech32.h
--- a/damus-c/bech32_util.c
+++ b/damus-c/bech32_util.c
--- a/damus-c/bech32_util.h
+++ b/damus-c/bech32_util.h
--- a/damus-c/block.h
+++ b/damus-c/block.h
@@ -0,0 +1,57 @@
+//
+//  block.h
+//  damus
+//
+//  Created by William Casarin on 2023-04-09.
+//
+
+#ifndef block_h
+#define block_h
+
+#include "nostr_bech32.h"
+#include "str_block.h"
+
+#define MAX_BLOCKS 1024
+
+enum block_type {
+    BLOCK_HASHTAG = 1,
+    BLOCK_TEXT = 2,
+    BLOCK_MENTION_INDEX = 3,
+    BLOCK_MENTION_BECH32 = 4,
+    BLOCK_URL = 5,
+    BLOCK_INVOICE = 6,
+};
+
+
+typedef struct invoice_block {
+    struct str_block invstr;
+    union {
+        struct bolt11 *bolt11;
+    };
+} invoice_block_t;
+
+typedef struct mention_bech32_block {
+    struct str_block str;
+    struct nostr_bech32 bech32;
+} mention_bech32_block_t;
+
+typedef struct note_block {
+    enum block_type type;
+    union {
+        struct str_block str;
+        struct invoice_block invoice;
+        struct mention_bech32_block mention_bech32;
+        int mention_index;
+    } block;
+} block_t;
+
+typedef struct note_blocks {
+    int words;
+    int num_blocks;
+    struct note_block *blocks;
+} blocks_t;
+
+void blocks_init(struct note_blocks *blocks);
+void blocks_free(struct note_blocks *blocks);
+
+#endif /* block_h */
--- a/damus-c/bolt11.c
+++ b/damus-c/bolt11.c
--- a/damus-c/bolt11.h
+++ b/damus-c/bolt11.h
--- a/damus-c/build_assert.h
+++ b/damus-c/build_assert.h
--- a/damus-c/check_type.h
+++ b/damus-c/check_type.h
--- a/nostrdb/ccan/ccan/compiler/compiler.h
+++ b/nostrdb/ccan/ccan/compiler/compiler.h
@@ -14,7 +14,7 @@
 * Example:
 * static void COLD moan(const char *reason)
 * {
- *	fprintf(stderr, "Error: %s (%s)\n", reason, strerror(errno));
+ *    fprintf(stderr, "Error: %s (%s)\n", reason, strerror(errno));
 * }
 */
 #define COLD __attribute__((__cold__))
@@ -33,8 +33,8 @@
 * Example:
 * static void NORETURN fail(const char *reason)
 * {
- *	fprintf(stderr, "Error: %s (%s)\n", reason, strerror(errno));
- *	exit(1);
+ *    fprintf(stderr, "Error: %s (%s)\n", reason, strerror(errno));
+ *    exit(1);
 * }
 */
 #define NORETURN __attribute__((__noreturn__))
@@ -56,7 +56,7 @@
 * void PRINTF_FMT(2,3) my_printf(const char *prefix, const char *fmt, ...);
 */
 #define PRINTF_FMT(nfmt, narg) \
-	__attribute__((format(__printf__, nfmt, narg)))
+    __attribute__((format(__printf__, nfmt, narg)))
 #else
 #define PRINTF_FMT(nfmt, narg)
 #endif
@@ -106,7 +106,7 @@
 * // With some preprocessor options, this is unnecessary.
 * static UNNEEDED void add_to_counter(int add)
 * {
- *	counter += add;
+ *    counter += add;
 * }
 */
 #define UNNEEDED __attribute__((__unused__))
@@ -121,12 +121,12 @@
 * the compiler that it must exist even if it (seems) unused.
 *
 * Example:
- *	// Even if this is unused, these are vital for debugging.
- *	static NEEDED int counter;
- *	static NEEDED void dump_counter(void)
- *	{
- *		printf("Counter is %i\n", counter);
- *	}
+ *    // Even if this is unused, these are vital for debugging.
+ *    static NEEDED int counter;
+ *    static NEEDED void dump_counter(void)
+ *    {
+ *        printf("Counter is %i\n", counter);
+ *    }
 */
 #define NEEDED __attribute__((__used__))
 #else
@@ -144,11 +144,11 @@
 * to the reader that it's deliberate.
 *
 * Example:
- *	// This is used as a callback, so needs to have this prototype.
- *	static int some_callback(void *unused UNUSED)
- *	{
- *		return 0;
- *	}
+ *    // This is used as a callback, so needs to have this prototype.
+ *    static int some_callback(void *unused UNUSED)
+ *    {
+ *        return 0;
+ *    }
 */
 #define UNUSED __attribute__((__unused__))
 #endif
@@ -178,28 +178,28 @@
 * This can be done using the IS_COMPILE_CONSTANT() macro.
 *
 * Example:
- *	enum greek { ALPHA, BETA, GAMMA, DELTA, EPSILON };
+ *    enum greek { ALPHA, BETA, GAMMA, DELTA, EPSILON };
 *
- *	// Out-of-line version.
- *	const char *greek_name(enum greek greek);
+ *    // Out-of-line version.
+ *    const char *greek_name(enum greek greek);
 *
- *	// Inline version.
- *	static inline const char *_greek_name(enum greek greek)
- *	{
- *		switch (greek) {
- *		case ALPHA: return "alpha";
- *		case BETA: return "beta";
- *		case GAMMA: return "gamma";
- *		case DELTA: return "delta";
- *		case EPSILON: return "epsilon";
- *		default: return "**INVALID**";
- *		}
- *	}
+ *    // Inline version.
+ *    static inline const char *_greek_name(enum greek greek)
+ *    {
+ *        switch (greek) {
+ *        case ALPHA: return "alpha";
+ *        case BETA: return "beta";
+ *        case GAMMA: return "gamma";
+ *        case DELTA: return "delta";
+ *        case EPSILON: return "epsilon";
+ *        default: return "**INVALID**";
+ *        }
+ *    }
 *
- *	// Use inline if compiler knows answer.  Otherwise call function
- *	// to avoid copies of the same code everywhere.
- *	#define greek_name(g)						\
- *		 (IS_COMPILE_CONSTANT(greek) ? _greek_name(g) : greek_name(g))
+ *    // Use inline if compiler knows answer.  Otherwise call function
+ *    // to avoid copies of the same code everywhere.
+ *    #define greek_name(g)                        \
+ *         (IS_COMPILE_CONSTANT(greek) ? _greek_name(g) : greek_name(g))
 */
 #define IS_COMPILE_CONSTANT(expr) __builtin_constant_p(expr)
 #else
@@ -220,7 +220,7 @@
 * // buf param may be freed by this; need return value!
 * static char *WARN_UNUSED_RESULT enlarge(char *buf, unsigned *size)
 * {
- *	return realloc(buf, (*size) *= 2);
+ *    return realloc(buf, (*size) *= 2);
 * }
 */
 #define WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
@@ -307,7 +307,7 @@
 *
 * Example:
 * if (cpu_supports("mmx"))
- *	printf("MMX support engaged!\n");
+ *    printf("MMX support engaged!\n");
 */
 #define cpu_supports(x) __builtin_cpu_supports(x)
 #else
--- a/nostrdb/src/config.h
+++ b/nostrdb/src/config.h
--- a/damus-c/container_of.h
+++ b/damus-c/container_of.h
--- a/damus-c/cppmagic.h
+++ b/damus-c/cppmagic.h
--- a/nostrdb/src/cursor.h
+++ b/nostrdb/src/cursor.h
@@ -2,20 +2,28 @@
 #ifndef JB55_CURSOR_H
 #define JB55_CURSOR_H

-#include "ccan/likely/likely.h"
+#include "typedefs.h"
+#include "varint.h"

 #include <stdio.h>
-#include <inttypes.h>
 #include <ctype.h>
 #include <assert.h>
 #include <string.h>

+#define unlikely(x) __builtin_expect((x),0)
+#define likely(x)   __builtin_expect((x),1)
+
 struct cursor {
 	unsigned char *start;
 	unsigned char *p;
 	unsigned char *end;
 };

+struct array {
+	struct cursor cur;
+	unsigned int elem_size;
+};
+
 static inline void reset_cursor(struct cursor *cursor)
 {
 	cursor->p = cursor->start;
@@ -27,13 +35,19 @@ static inline void wipe_cursor(struct cursor *cursor)
 	memset(cursor->start, 0, cursor->end - cursor->start);
 }

-static inline void make_cursor(unsigned char *start, unsigned char *end, struct cursor *cursor)
+static inline void make_cursor(u8 *start, u8 *end, struct cursor *cursor)
 {
 	cursor->start = start;
 	cursor->p = start;
 	cursor->end = end;
 }

+static inline void make_array(struct array *a, u8* start, u8 *end, unsigned int elem_size)
+{
+	make_cursor(start, end, &a->cur);
+	a->elem_size = elem_size;
+}
+
 static inline int cursor_eof(struct cursor *c)
 {
 	return c->p == c->end;
@@ -66,7 +80,7 @@ static inline void *cursor_alloc(struct cursor *mem, unsigned long size)

 static inline int cursor_slice(struct cursor *mem, struct cursor *slice, size_t size)
 {
-	unsigned char *p;
+	u8 *p;
 	if (!(p = cursor_alloc(mem, size))) {
 		return 0;
 	}
@@ -74,16 +88,6 @@ static inline int cursor_slice(struct cursor *mem, struct cursor *slice, size_t
 	return 1;
 }

-static inline int cursor_malloc_slice(struct cursor *mem, struct cursor *slice, size_t size)
-{
-	unsigned char *p;
-	if (!(p = cursor_malloc(mem, size))) {
-		return 0;
-	}
-	make_cursor(p, mem->p, slice);
-	return 1;
-}
-

 static inline void copy_cursor(struct cursor *src, struct cursor *dest)
 {
@@ -102,7 +106,7 @@ static inline int cursor_skip(struct cursor *cursor, int n)
    return 1;
 }

-static inline int cursor_pull_byte(struct cursor *cursor, unsigned char *c)
+static inline int pull_byte(struct cursor *cursor, u8 *c)
 {
 	if (unlikely(cursor->p >= cursor->end))
 		return 0;
@@ -113,7 +117,7 @@ static inline int cursor_pull_byte(struct cursor *cursor, unsigned char *c)
 	return 1;
 }

-static inline int parse_byte(struct cursor *cursor, unsigned char *c)
+static inline int parse_byte(struct cursor *cursor, u8 *c)
 {
    if (unlikely(cursor->p >= cursor->end))
        return 0;
@@ -158,7 +162,7 @@ static inline int cursor_pull_c_str(struct cursor *cursor, const char **str)
 }


-static inline int cursor_push_byte(struct cursor *cursor, unsigned char c)
+static inline int cursor_push_byte(struct cursor *cursor, u8 c)
 {
 	if (unlikely(cursor->p + 1 > cursor->end)) {
 		return 0;
@@ -170,7 +174,7 @@ static inline int cursor_push_byte(struct cursor *cursor, unsigned char c)
 	return 1;
 }

-static inline int cursor_pull(struct cursor *cursor, unsigned char *data, int len)
+static inline int cursor_pull(struct cursor *cursor, u8 *data, int len)
 {
 	if (unlikely(cursor->p + len > cursor->end)) {
 		return 0;
@@ -240,7 +244,7 @@ static inline unsigned char *cursor_top(struct cursor *cur, int len)

 static inline int cursor_top_int(struct cursor *cur, int *i)
 {
-	unsigned char *p;
+	u8 *p;
 	if (unlikely(!(p = cursor_top(cur, sizeof(*i))))) {
 		return 0;
 	}
@@ -248,7 +252,7 @@ static inline int cursor_top_int(struct cursor *cur, int *i)
 	return 1;
 }

-static inline int cursor_pop(struct cursor *cur, unsigned char *data, int len)
+static inline int cursor_pop(struct cursor *cur, u8 *data, int len)
 {
 	if (unlikely(cur->p - len < cur->start)) {
 		return 0;
@@ -260,9 +264,9 @@ static inline int cursor_pop(struct cursor *cur, unsigned char *data, int len)
 	return 1;
 }

-static inline int cursor_push(struct cursor *cursor, unsigned char *data, int len)
+static inline int cursor_push(struct cursor *cursor, u8 *data, int len)
 {
-	if (unlikely(cursor->p + len > cursor->end)) {
+	if (unlikely(cursor->p + len >= cursor->end)) {
 		return 0;
 	}

@@ -276,7 +280,7 @@ static inline int cursor_push(struct cursor *cursor, unsigned char *data, int le

 static inline int cursor_push_int(struct cursor *cursor, int i)
 {
-	return cursor_push(cursor, (unsigned char*)&i, sizeof(i));
+	return cursor_push(cursor, (u8*)&i, sizeof(i));
 }

 static inline size_t cursor_count(struct cursor *cursor, size_t elem_size)
@@ -284,79 +288,73 @@ static inline size_t cursor_count(struct cursor *cursor, size_t elem_size)
 	return (cursor->p - cursor->start)/elem_size;
 }

-/* Encodes a 64-bit integer into a variable-length format and pushes it into a cursor.
- * Returns the number of bytes used or -1 in case of an error. */
-static inline int cursor_push_varint(struct cursor *cursor, uint64_t n)
+/* TODO: push_varint */
+static inline int push_varint(struct cursor *cursor, int n)
 {
-	int len = 0;
-	do {
-		unsigned char b = (n & 0x7F) | (n > 0x7F ? 0x80 : 0);
+	int ok, len;
+	unsigned char b;
+	len = 0;
+
+	while (1) {
+		b = (n & 0xFF) | 0x80;
 		n >>= 7;
-		if (!cursor_push_byte(cursor, b))
-			return -1; // Error handling
+		if (n == 0) {
+			b &= 0x7F;
+			ok = cursor_push_byte(cursor, b);
+			len++;
+			if (!ok) return 0;
+			break;
+		}
+
+		ok = cursor_push_byte(cursor, b);
 		len++;
-	} while (n != 0);
+		if (!ok) return 0;
+	}

 	return len;
 }

-static inline int cursor_pull_varint(struct cursor *cursor, uint64_t *n)
+/* TODO: pull_varint */
+static inline int pull_varint(struct cursor *cursor, int *n)
 {
 	int ok, i;
 	unsigned char b;
-
 	*n = 0;

-	for (i = 0; i < 10; i++) { // Loop up to 10 bytes for 64-bit
-		ok = cursor_pull_byte(cursor, &b);
+	for (i = 0;; i++) {
+		ok = pull_byte(cursor, &b);
 		if (!ok) return 0;

-		*n |= ((int64_t)b & 0x7F) << (i * 7);
+		*n |= ((int)b & 0x7F) << (i * 7);

+		/* is_last */
 		if ((b & 0x80) == 0) {
-			return i + 1; // Successfully read i+1 bytes
+			return i+1;
 		}
+
+		if (i == 4) return 0;
 	}

-	return 10; // Successfully read 10 bytes for a full 64-bit integer
-}
-
-static int cursor_pull_varint_u32(struct cursor *cursor, uint32_t *v)
-{
-	uint64_t bigval;
-
-	if (!cursor_pull_varint(cursor, &bigval))
-		return 0;
-
-	if (bigval > UINT32_MAX)
-		return 0;
-
-	*v = (uint32_t) bigval;
-	return 1;
+	return 0;
 }

 static inline int cursor_pull_int(struct cursor *cursor, int *i)
 {
-	return cursor_pull(cursor, (unsigned char*)i, sizeof(*i));
+	return cursor_pull(cursor, (u8*)i, sizeof(*i));
 }

 static inline int cursor_push_u32(struct cursor *cursor, uint32_t i) {
    return cursor_push(cursor, (unsigned char*)&i, sizeof(i));
 }

-static inline int cursor_push_u16(struct cursor *cursor, unsigned short i)
+static inline int cursor_push_u16(struct cursor *cursor, u16 i)
 {
-	return cursor_push(cursor, (unsigned char*)&i, sizeof(i));
-}
-
-static inline int cursor_pull_u16(struct cursor *cursor, uint16_t *i)
-{
-	return cursor_pull(cursor, (unsigned char*)i, sizeof(*i));
+	return cursor_push(cursor, (u8*)&i, sizeof(i));
 }

 static inline void *index_cursor(struct cursor *cursor, unsigned int index, int elem_size)
 {
-	unsigned char *p;
+	u8 *p;
 	p = &cursor->start[elem_size * index];

 	if (unlikely(p >= cursor->end))
@@ -368,7 +366,7 @@ static inline void *index_cursor(struct cursor *cursor, unsigned int index, int

 static inline int push_sized_str(struct cursor *cursor, const char *str, int len)
 {
-	return cursor_push(cursor, (unsigned char*)str, len);
+	return cursor_push(cursor, (u8*)str, len);
 }

 static inline int cursor_push_lowercase(struct cursor *cur, const char *str, int len)
@@ -387,40 +385,41 @@ static inline int cursor_push_lowercase(struct cursor *cur, const char *str, int

 static inline int cursor_push_str(struct cursor *cursor, const char *str)
 {
-	return cursor_push(cursor, (unsigned char*)str, (int)strlen(str));
+	return cursor_push(cursor, (u8*)str, (int)strlen(str));
 }

 static inline int cursor_push_c_str(struct cursor *cursor, const char *str)
 {
-	if (str == NULL)
-		return cursor_push_byte(cursor, 0);
 	return cursor_push_str(cursor, str) && cursor_push_byte(cursor, 0);
 }

 /* TODO: push varint size */
 static inline int push_prefixed_str(struct cursor *cursor, const char *str)
 {
-	uint64_t len;
-	len = strlen(str);
-	if (!cursor_push_varint(cursor, len))
-		return 0;
+	int ok, len;
+	len = (int)strlen(str);
+	ok = push_varint(cursor, len);
+	if (!ok) return 0;
 	return push_sized_str(cursor, str, len);
 }

 static inline int pull_prefixed_str(struct cursor *cursor, struct cursor *dest_buf, const char **str)
 {
-	uint64_t len;
+	int len, ok;

-	if (!cursor_pull_varint(cursor, &len))
+	ok = pull_varint(cursor, &len);
+	if (!ok) return 0;
+
+	if (unlikely(dest_buf->p + len > dest_buf->end)) {
 		return 0;
+	}

-	if (unlikely(dest_buf->p + len > dest_buf->end))
-		return 0;
+	ok = pull_data_into_cursor(cursor, dest_buf, (unsigned char**)str, len);
+	if (!ok) return 0;

-	if (!pull_data_into_cursor(cursor, dest_buf, (unsigned char**)str, len))
-		return 0;
+	ok = cursor_push_byte(dest_buf, 0);

-	return cursor_push_byte(dest_buf, 0);
+	return 1;
 }

 static inline int cursor_remaining_capacity(struct cursor *cursor)
@@ -454,7 +453,7 @@ static inline void cursor_print_around(struct cursor *cur, int range)
 }
 #undef max

-static inline int pull_bytes(struct cursor *cur, int count, const unsigned char **bytes) {
+static inline int pull_bytes(struct cursor *cur, int count, const u8 **bytes) {
    if (cur->p + count > cur->end)
        return 0;
    
@@ -464,7 +463,7 @@ static inline int pull_bytes(struct cursor *cur, int count, const unsigned char
 }

 static inline int parse_str(struct cursor *cur, const char *str) {
-    unsigned int i;
+    int i;
    char c, cs;
    unsigned long len;
    
@@ -486,21 +485,47 @@ static inline int parse_str(struct cursor *cur, const char *str) {
    return 1;
 }

-static inline int is_whitespace(char c) {
+static inline int is_whitespace(int c) {
    return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
 }

-static inline int is_underscore(char c) {
+
+static inline int next_char_is_whitespace(unsigned char *curChar, unsigned char *endChar) {
+    unsigned char * next = curChar + 1;
+    if(next > endChar) return 0;
+    else if(next == endChar) return 1;
+    return is_whitespace(*next);
+}
+
+static int char_disallowed_at_end_url(char c){
+    return c == '.' || c == ',';
+}
+
+static inline int is_final_url_char(unsigned char *curChar, unsigned char *endChar){
+    if(is_whitespace(*curChar)){
+        return 1;
+    }
+    else if(next_char_is_whitespace(curChar, endChar)) {
+        // next char is whitespace so this char could be the final char in the url
+        return char_disallowed_at_end_url(*curChar);
+    }
+    else{
+        // next char isn't whitespace so it can't be a final char
+        return 0;
+    }
+}
+
+static inline int is_underscore(int c) {
    return c == '_';
 }

-static inline int is_utf8_byte(unsigned char c) {
+static inline int is_utf8_byte(u8 c) {
    return c & 0x80;
 }

 static inline int parse_utf8_char(struct cursor *cursor, unsigned int *code_point, unsigned int *utf8_length)
 {
-    unsigned char first_byte;
+    u8 first_byte;
    if (!parse_byte(cursor, &first_byte))
        return 0; // Not enough data

@@ -525,7 +550,7 @@ static inline int parse_utf8_char(struct cursor *cursor, unsigned int *code_poin
        remaining_bytes = 0;
        *utf8_length = 1; // Assume 1 byte length for unrecognized UTF-8 characters
        // TODO: We need to gracefully handle unrecognized UTF-8 characters
-        //printf("Invalid UTF-8 byte: %x\n", *code_point);
+        printf("Invalid UTF-8 byte: %x\n", *code_point);
        *code_point = ((first_byte & 0xF0) << 6); // Prevent testing as punctuation
        return 0; // Invalid first byte
    }
@@ -571,7 +596,7 @@ static inline int is_punctuation(unsigned int codepoint) {
        return 0;
    
    // Check for ASCII punctuation
-    if (codepoint <= 128 && ispunct(codepoint))
+    if (ispunct(codepoint))
        return 1;

    // Check for Unicode punctuation exceptions (punctuation allowed in hashtags)
@@ -619,38 +644,39 @@ static inline int is_alphanumeric(char c) {
 }

 static inline int consume_until_boundary(struct cursor *cur) {
-	unsigned int c;
-	unsigned int char_length = 1;
-	unsigned int *utf8_char_length = &char_length;
-	
-	while (cur->p < cur->end) {
-		c = *cur->p;
-		
-		*utf8_char_length = 1;
-		
-		if (is_whitespace(c))
-			return 1;
-		
-		// Need to check for UTF-8 characters, which can be multiple bytes long
-		if (is_utf8_byte(c)) {
-			if (!parse_utf8_char(cur, &c, utf8_char_length)) {
-				if (!is_right_boundary(c)){
-					return 0;
-				}
-			}
-		}
-		
-		if (is_right_boundary(c))
-			return 1;
-		
-		// Need to use a variable character byte length for UTF-8 (2-4 bytes)
-		if (cur->p + *utf8_char_length <= cur->end)
-			cur->p += *utf8_char_length;
-		else
-			cur->p++;
-	}
-	
-	return 1;
+    unsigned int c;
+    unsigned int char_length = 1;
+    unsigned int *utf8_char_length = &char_length;
+    
+    while (cur->p < cur->end) {
+        c = *cur->p;
+        
+        *utf8_char_length = 1;
+        
+        if (is_whitespace(c))
+            return 1;
+        
+        // Need to check for UTF-8 characters, which can be multiple bytes long
+        if (is_utf8_byte(c)) {
+            if (!parse_utf8_char(cur, &c, utf8_char_length)) {
+                if (!is_right_boundary(c)){
+                    // TODO: We should work towards handling all UTF-8 characters.
+                    printf("Invalid UTF-8 code point: %x\n", c);
+                }
+            }
+        }
+        
+        if (is_right_boundary(c))
+            return 1;
+        
+        // Need to use a variable character byte length for UTF-8 (2-4 bytes)
+        if (cur->p + *utf8_char_length <= cur->end)
+            cur->p += *utf8_char_length;
+        else
+            cur->p++;
+    }
+    
+    return 1;
 }

 static inline int consume_until_whitespace(struct cursor *cur, int or_end) {
@@ -670,6 +696,23 @@ static inline int consume_until_whitespace(struct cursor *cur, int or_end) {
    return or_end;
 }

+static inline int consume_until_end_url(struct cursor *cur, int or_end) {
+    char c;
+    int consumedAtLeastOne = 0;
+    
+    while (cur->p < cur->end) {
+        c = *cur->p;
+        
+        if (is_final_url_char(cur->p, cur->end))
+            return consumedAtLeastOne;
+        
+        cur->p++;
+        consumedAtLeastOne = 1;
+    }
+    
+    return or_end;
+}
+
 static inline int consume_until_non_alphanumeric(struct cursor *cur, int or_end) {
    char c;
    int consumedAtLeastOne = 0;
@@ -699,27 +742,5 @@ static inline int cursor_memset(struct cursor *cursor, unsigned char c, int n)
    return 1;
 }

-static void consume_whitespace_or_punctuation(struct cursor *cur)
-{
-	while (cur->p < cur->end) {
-		if (!is_right_boundary(*cur->p))
-			return;
-		cur->p++;
-	}
-}
-
-// pad cursor buffer to n-byte alignment
-static inline int cursor_align(struct cursor *cur, int bytes) {
-	size_t size = cur->p - cur->start;
-	int pad;
-
-	// pad to n-byte alignment
-	pad = ((size + (bytes-1)) & ~(bytes-1)) - size;
-	if (pad > 0 && !cursor_memset(cur, 0, pad))
-		return 0;
-
-	return 1;
-}
-

 #endif
--- a/damus-c/damus-Bridging-Header.h
+++ b/damus-c/damus-Bridging-Header.h
@@ -2,6 +2,7 @@
 //  Use this file to import your target's public headers that you would like to expose to Swift.
 //

+#include "damus.h"
 #include "bolt11.h"
 #include "amount.h"
 #include "nostr_bech32.h"
--- a/damus-c/damus.c
+++ b/damus-c/damus.c
@@ -0,0 +1,393 @@
+//
+//  damus.c
+//  damus
+//
+//  Created by William Casarin on 2022-10-17.
+//
+
+#include "damus.h"
+#include "cursor.h"
+#include "bolt11.h"
+#include "bech32.h"
+#include <stdlib.h>
+#include <string.h>
+
+static int parse_digit(struct cursor *cur, int *digit) {
+    int c;
+    if ((c = peek_char(cur, 0)) == -1)
+        return 0;
+    
+    c -= '0';
+    
+    if (c >= 0 && c <= 9) {
+        *digit = c;
+        cur->p++;
+        return 1;
+    }
+    return 0;
+}
+
+
+static int parse_mention_index(struct cursor *cur, struct note_block *block) {
+    int d1, d2, d3, ind;
+    u8 *start = cur->p;
+    
+    if (!parse_str(cur, "#["))
+        return 0;
+    
+    if (!parse_digit(cur, &d1)) {
+        cur->p = start;
+        return 0;
+    }
+    
+    ind = d1;
+    
+    if (parse_digit(cur, &d2))
+        ind = (d1 * 10) + d2;
+    
+    if (parse_digit(cur, &d3))
+        ind = (d1 * 100) + (d2 * 10) + d3;
+    
+    if (!parse_char(cur, ']')) {
+        cur->p = start;
+        return 0;
+    }
+    
+    block->type = BLOCK_MENTION_INDEX;
+    block->block.mention_index = ind;
+    
+    return 1;
+}
+
+static int parse_hashtag(struct cursor *cur, struct note_block *block) {
+    int c;
+    u8 *start = cur->p;
+    
+    if (!parse_char(cur, '#'))
+        return 0;
+    
+    c = peek_char(cur, 0);
+    if (c == -1 || is_whitespace(c) || c == '#') {
+        cur->p = start;
+        return 0;
+    }
+    
+    consume_until_boundary(cur);
+    
+    block->type = BLOCK_HASHTAG;
+    block->block.str.start = (const char*)(start + 1);
+    block->block.str.end = (const char*)cur->p;
+    
+    return 1;
+}
+
+static int add_block(struct note_blocks *blocks, struct note_block block)
+{
+    if (blocks->num_blocks + 1 >= MAX_BLOCKS)
+        return 0;
+    
+    blocks->blocks[blocks->num_blocks++] = block;
+    return 1;
+}
+
+static int add_text_block(struct note_blocks *blocks, const u8 *start, const u8 *end)
+{
+    struct note_block b;
+    
+    if (start == end)
+        return 1;
+    
+    b.type = BLOCK_TEXT;
+    b.block.str.start = (const char*)start;
+    b.block.str.end = (const char*)end;
+    
+    return add_block(blocks, b);
+}
+
+static int consume_url_fragment(struct cursor *cur)
+{
+    int c;
+
+    if ((c = peek_char(cur, 0)) < 0)
+        return 1;
+
+    if (c != '#' && c != '?') {
+        return 1;
+    }
+
+    cur->p++;
+
+    return consume_until_end_url(cur, 1);
+}
+
+static int consume_url_path(struct cursor *cur)
+{
+    int c;
+
+    if ((c = peek_char(cur, 0)) < 0)
+        return 1;
+
+    if (c != '/') {
+        return 1;
+    }
+
+    while (cur->p < cur->end) {
+        c = *cur->p;
+
+        if (c == '?' || c == '#' || is_final_url_char(cur->p, cur->end)) {
+            return 1;
+        }
+
+        cur->p++;
+    }
+
+    return 1;
+}
+
+static int consume_url_host(struct cursor *cur)
+{
+	char c;
+	int count = 0;
+
+	while (cur->p < cur->end) {
+		c = *cur->p;
+		// TODO: handle IDNs
+        if ((is_alphanumeric(c) || c == '.' || c == '-') && !is_final_url_char(cur->p, cur->end))
+		{
+			count++;
+			cur->p++;
+			continue;
+		}
+
+		return count != 0;
+	}
+
+
+	// this means the end of the URL hostname is the end of the buffer and we finished
+	return count != 0;
+}
+
+static int parse_url(struct cursor *cur, struct note_block *block) {
+    u8 *start = cur->p;
+    u8 *host;
+    int host_len;
+    struct cursor path_cur;
+    
+    if (!parse_str(cur, "http"))
+        return 0;
+    
+    if (parse_char(cur, 's') || parse_char(cur, 'S')) {
+        if (!parse_str(cur, "://")) {
+            cur->p = start;
+            return 0;
+        }
+    } else {
+        if (!parse_str(cur, "://")) {
+            cur->p = start;
+            return 0;
+        }
+    }
+
+    // make sure to save the hostname. We will use this to detect damus.io links
+    host = cur->p;
+
+    if (!consume_url_host(cur)) {
+	    cur->p = start;
+	    return 0;
+    }
+
+    // get the length of the host string
+    host_len = (int)(cur->p - host);
+
+    // save the current parse state so that we can continue from here when
+    // parsing the bech32 in the damus.io link if we have it
+    copy_cursor(cur, &path_cur);
+
+    // skip leading /
+    cursor_skip(&path_cur, 1);
+
+    if (!consume_url_path(cur)) {
+	    cur->p = start;
+	    return 0;
+    }
+
+    if (!consume_url_fragment(cur)) {
+	    cur->p = start;
+	    return 0;
+    }
+
+    // smart parens
+    if (start - 1 >= 0 &&
+        start < cur->end &&
+        *(start - 1) == '(' &&
+        (cur->p - 1) < cur->end &&
+        *(cur->p - 1) == ')')
+    {
+        cur->p--;
+    }
+
+    // save the bech32 string pos in case we hit a damus.io link
+    block->block.str.start = (const char *)path_cur.p;
+
+    // if we have a damus link, make it a mention
+    if (host_len == 8
+	&& !strncmp((const char *)host, "damus.io", 8)
+	&& parse_nostr_bech32(&path_cur, &block->block.mention_bech32.bech32))
+    {
+	    block->block.str.end = (const char *)path_cur.p;
+	    block->type = BLOCK_MENTION_BECH32;
+	    return 1;
+    }
+
+    block->type = BLOCK_URL;
+    block->block.str.start = (const char *)start;
+    block->block.str.end = (const char *)cur->p;
+    
+    return 1;
+}
+
+static int parse_invoice(struct cursor *cur, struct note_block *block) {
+    u8 *start, *end;
+    char *fail;
+    struct bolt11 *bolt11;
+    // optional
+    parse_str(cur, "lightning:");
+    
+    start = cur->p;
+    
+    if (!parse_str(cur, "lnbc"))
+        return 0;
+    
+    if (!consume_until_whitespace(cur, 1)) {
+        cur->p = start;
+        return 0;
+    }
+    
+    end = cur->p;
+    
+    char str[end - start + 1];
+    str[end - start] = 0;
+    memcpy(str, start, end - start);
+    
+    if (!(bolt11 = bolt11_decode(NULL, str, &fail))) {
+        cur->p = start;
+        return 0;
+    }
+    
+    block->type = BLOCK_INVOICE;
+    
+    block->block.invoice.invstr.start = (const char*)start;
+    block->block.invoice.invstr.end = (const char*)end;
+    block->block.invoice.bolt11 = bolt11;
+    
+    cur->p = end;
+    
+    return 1;
+}
+
+
+static int parse_mention_bech32(struct cursor *cur, struct note_block *block) {
+    u8 *start = cur->p;
+    
+    parse_char(cur, '@');
+    parse_str(cur, "nostr:");
+
+    block->block.str.start = (const char *)cur->p;
+    
+    if (!parse_nostr_bech32(cur, &block->block.mention_bech32.bech32)) {
+        cur->p = start;
+        return 0;
+    }
+    
+    block->block.str.end = (const char *)cur->p;
+    
+    block->type = BLOCK_MENTION_BECH32;
+
+    return 1;
+}
+
+static int add_text_then_block(struct cursor *cur, struct note_blocks *blocks, struct note_block block, u8 **start, const u8 *pre_mention)
+{
+    if (!add_text_block(blocks, *start, pre_mention))
+        return 0;
+    
+    *start = (u8*)cur->p;
+    
+    if (!add_block(blocks, block))
+        return 0;
+    
+    return 1;
+}
+
+int damus_parse_content(struct note_blocks *blocks, const char *content) {
+    int cp, c;
+    struct cursor cur;
+    struct note_block block;
+    u8 *start, *pre_mention;
+    
+    blocks->words = 0;
+    blocks->num_blocks = 0;
+    make_cursor((u8*)content, (u8*)content + strlen(content), &cur);
+    
+    start = cur.p;
+    while (cur.p < cur.end && blocks->num_blocks < MAX_BLOCKS) {
+        cp = peek_char(&cur, -1);
+        c  = peek_char(&cur, 0);
+        
+        // new word
+        if (is_whitespace(cp) && !is_whitespace(c)) {
+            blocks->words++;
+        }
+        
+        pre_mention = cur.p;
+        if (cp == -1 || is_left_boundary(cp) || c == '#') {
+            if (c == '#' && (parse_mention_index(&cur, &block) || parse_hashtag(&cur, &block))) {
+                if (!add_text_then_block(&cur, blocks, block, &start, pre_mention))
+                    return 0;
+                continue;
+            } else if ((c == 'h' || c == 'H') && parse_url(&cur, &block)) {
+                if (!add_text_then_block(&cur, blocks, block, &start, pre_mention))
+                    return 0;
+                continue;
+            } else if ((c == 'l' || c == 'L') && parse_invoice(&cur, &block)) {
+                if (!add_text_then_block(&cur, blocks, block, &start, pre_mention))
+                    return 0;
+                continue;
+            } else if ((c == 'n' || c == '@') && parse_mention_bech32(&cur, &block)) {
+                if (!add_text_then_block(&cur, blocks, block, &start, pre_mention))
+                    return 0;
+                continue;
+            }
+        }
+        
+        cur.p++;
+    }
+    
+    if (cur.p - start > 0) {
+        if (!add_text_block(blocks, start, cur.p))
+            return 0;
+    }
+    
+    return 1;
+}
+
+void blocks_init(struct note_blocks *blocks) {
+    blocks->blocks = malloc(sizeof(struct note_block) * MAX_BLOCKS);
+    blocks->num_blocks = 0;
+}
+
+void blocks_free(struct note_blocks *blocks) {
+    if (!blocks->blocks) {
+        return;
+    }
+    
+    for (int i = 0; i < blocks->num_blocks; ++i) {
+        if (blocks->blocks[i].type == BLOCK_MENTION_BECH32) {
+            free(blocks->blocks[i].block.mention_bech32.bech32.buffer);
+            blocks->blocks[i].block.mention_bech32.bech32.buffer = NULL;
+        }
+    }
+
+    free(blocks->blocks);
+    blocks->num_blocks = 0;
+}
--- a/damus-c/damus.h
+++ b/damus-c/damus.h
@@ -0,0 +1,18 @@
+//
+//  damus.h
+//  damus
+//
+//  Created by William Casarin on 2022-10-17.
+//
+
+#ifndef damus_h
+#define damus_h
+
+#include <stdio.h>
+#include "block.h"
+
+typedef unsigned char u8;
+
+int damus_parse_content(struct note_blocks *blocks, const char *content);
+
+#endif /* damus_h */
--- a/damus-c/debug.h
+++ b/damus-c/debug.h
--- a/nostrdb/ccan/ccan/endian/endian.h
+++ b/nostrdb/ccan/ccan/endian/endian.h
@@ -11,13 +11,13 @@
 * Designed to be usable in constant-requiring initializers.
 *
 * Example:
- *	struct mystruct {
- *		char buf[BSWAP_16(0x1234)];
- *	};
+ *    struct mystruct {
+ *        char buf[BSWAP_16(0x1234)];
+ *    };
 */
-#define BSWAP_16(val)				\
-	((((uint16_t)(val) & 0x00ff) << 8)	\
-	 | (((uint16_t)(val) & 0xff00) >> 8))
+#define BSWAP_16(val)                \
+    ((((uint16_t)(val) & 0x00ff) << 8)    \
+     | (((uint16_t)(val) & 0xff00) >> 8))

 /**
 * BSWAP_32 - reverse bytes in a constant uint32_t value.
@@ -26,15 +26,15 @@
 * Designed to be usable in constant-requiring initializers.
 *
 * Example:
- *	struct mystruct {
- *		char buf[BSWAP_32(0xff000000)];
- *	};
+ *    struct mystruct {
+ *        char buf[BSWAP_32(0xff000000)];
+ *    };
 */
-#define BSWAP_32(val)					\
-	((((uint32_t)(val) & 0x000000ff) << 24)		\
-	 | (((uint32_t)(val) & 0x0000ff00) << 8)		\
-	 | (((uint32_t)(val) & 0x00ff0000) >> 8)		\
-	 | (((uint32_t)(val) & 0xff000000) >> 24))
+#define BSWAP_32(val)                    \
+    ((((uint32_t)(val) & 0x000000ff) << 24)        \
+     | (((uint32_t)(val) & 0x0000ff00) << 8)        \
+     | (((uint32_t)(val) & 0x00ff0000) >> 8)        \
+     | (((uint32_t)(val) & 0xff000000) >> 24))

 /**
 * BSWAP_64 - reverse bytes in a constant uint64_t value.
@@ -43,19 +43,19 @@
 * Designed to be usable in constant-requiring initializers.
 *
 * Example:
- *	struct mystruct {
- *		char buf[BSWAP_64(0xff00000000000000ULL)];
- *	};
+ *    struct mystruct {
+ *        char buf[BSWAP_64(0xff00000000000000ULL)];
+ *    };
 */
-#define BSWAP_64(val)						\
-	((((uint64_t)(val) & 0x00000000000000ffULL) << 56)	\
-	 | (((uint64_t)(val) & 0x000000000000ff00ULL) << 40)	\
-	 | (((uint64_t)(val) & 0x0000000000ff0000ULL) << 24)	\
-	 | (((uint64_t)(val) & 0x00000000ff000000ULL) << 8)	\
-	 | (((uint64_t)(val) & 0x000000ff00000000ULL) >> 8)	\
-	 | (((uint64_t)(val) & 0x0000ff0000000000ULL) >> 24)	\
-	 | (((uint64_t)(val) & 0x00ff000000000000ULL) >> 40)	\
-	 | (((uint64_t)(val) & 0xff00000000000000ULL) >> 56))
+#define BSWAP_64(val)                        \
+    ((((uint64_t)(val) & 0x00000000000000ffULL) << 56)    \
+     | (((uint64_t)(val) & 0x000000000000ff00ULL) << 40)    \
+     | (((uint64_t)(val) & 0x0000000000ff0000ULL) << 24)    \
+     | (((uint64_t)(val) & 0x00000000ff000000ULL) << 8)    \
+     | (((uint64_t)(val) & 0x000000ff00000000ULL) >> 8)    \
+     | (((uint64_t)(val) & 0x0000ff0000000000ULL) >> 24)    \
+     | (((uint64_t)(val) & 0x00ff000000000000ULL) >> 40)    \
+     | (((uint64_t)(val) & 0xff00000000000000ULL) >> 56))

 #if HAVE_BYTESWAP_H
 #include <byteswap.h>
@@ -65,12 +65,12 @@
 * @val: value whose bytes to swap.
 *
 * Example:
- *	// Output contains "1024 is 4 as two bytes reversed"
- *	printf("1024 is %u as two bytes reversed\n", bswap_16(1024));
+ *    // Output contains "1024 is 4 as two bytes reversed"
+ *    printf("1024 is %u as two bytes reversed\n", bswap_16(1024));
 */
 static inline uint16_t bswap_16(uint16_t val)
 {
-	return BSWAP_16(val);
+    return BSWAP_16(val);
 }

 /**
@@ -78,12 +78,12 @@ static inline uint16_t bswap_16(uint16_t val)
 * @val: value whose bytes to swap.
 *
 * Example:
- *	// Output contains "1024 is 262144 as four bytes reversed"
- *	printf("1024 is %u as four bytes reversed\n", bswap_32(1024));
+ *    // Output contains "1024 is 262144 as four bytes reversed"
+ *    printf("1024 is %u as four bytes reversed\n", bswap_32(1024));
 */
 static inline uint32_t bswap_32(uint32_t val)
 {
-	return BSWAP_32(val);
+    return BSWAP_32(val);
 }
 #endif /* !HAVE_BYTESWAP_H */

@@ -93,19 +93,19 @@ static inline uint32_t bswap_32(uint32_t val)
 * @val: value whose bytes to swap.
 *
 * Example:
- *	// Output contains "1024 is 1125899906842624 as eight bytes reversed"
- *	printf("1024 is %llu as eight bytes reversed\n",
- *		(unsigned long long)bswap_64(1024));
+ *    // Output contains "1024 is 1125899906842624 as eight bytes reversed"
+ *    printf("1024 is %llu as eight bytes reversed\n",
+ *        (unsigned long long)bswap_64(1024));
 */
 static inline uint64_t bswap_64(uint64_t val)
 {
-	return BSWAP_64(val);
+    return BSWAP_64(val);
 }
 #endif

 /* Needed for Glibc like endiness check */
-#define	__LITTLE_ENDIAN	1234
-#define	__BIG_ENDIAN	4321
+#define    __LITTLE_ENDIAN    1234
+#define    __BIG_ENDIAN    4321

 /* Sanity check the defines.  We don't handle weird endianness. */
 #if !HAVE_LITTLE_ENDIAN && !HAVE_BIG_ENDIAN
@@ -114,13 +114,13 @@ static inline uint64_t bswap_64(uint64_t val)
 #error "Can't compile for both big and little endian."
 #elif HAVE_LITTLE_ENDIAN
 #ifndef __BYTE_ORDER
-#define __BYTE_ORDER	__LITTLE_ENDIAN
+#define __BYTE_ORDER    __LITTLE_ENDIAN
 #elif __BYTE_ORDER != __LITTLE_ENDIAN
 #error "__BYTE_ORDER already defined, but not equal to __LITTLE_ENDIAN"
 #endif
 #elif HAVE_BIG_ENDIAN
 #ifndef __BYTE_ORDER
-#define __BYTE_ORDER	__BIG_ENDIAN
+#define __BYTE_ORDER    __BIG_ENDIAN
 #elif __BYTE_ORDER != __BIG_ENDIAN
 #error "__BYTE_ORDER already defined, but not equal to __BIG_ENDIAN"
 #endif
@@ -242,7 +242,7 @@ typedef uint16_t ENDIAN_TYPE beint16_t;
 */
 static inline leint64_t cpu_to_le64(uint64_t native)
 {
-	return CPU_TO_LE64(native);
+    return CPU_TO_LE64(native);
 }

 /**
@@ -251,7 +251,7 @@ static inline leint64_t cpu_to_le64(uint64_t native)
 */
 static inline leint32_t cpu_to_le32(uint32_t native)
 {
-	return CPU_TO_LE32(native);
+    return CPU_TO_LE32(native);
 }

 /**
@@ -260,7 +260,7 @@ static inline leint32_t cpu_to_le32(uint32_t native)
 */
 static inline leint16_t cpu_to_le16(uint16_t native)
 {
-	return CPU_TO_LE16(native);
+    return CPU_TO_LE16(native);
 }

 /**
@@ -269,7 +269,7 @@ static inline leint16_t cpu_to_le16(uint16_t native)
 */
 static inline uint64_t le64_to_cpu(leint64_t le_val)
 {
-	return LE64_TO_CPU(le_val);
+    return LE64_TO_CPU(le_val);
 }

 /**
@@ -278,7 +278,7 @@ static inline uint64_t le64_to_cpu(leint64_t le_val)
 */
 static inline uint32_t le32_to_cpu(leint32_t le_val)
 {
-	return LE32_TO_CPU(le_val);
+    return LE32_TO_CPU(le_val);
 }

 /**
@@ -287,7 +287,7 @@ static inline uint32_t le32_to_cpu(leint32_t le_val)
 */
 static inline uint16_t le16_to_cpu(leint16_t le_val)
 {
-	return LE16_TO_CPU(le_val);
+    return LE16_TO_CPU(le_val);
 }

 /**
@@ -296,7 +296,7 @@ static inline uint16_t le16_to_cpu(leint16_t le_val)
 */
 static inline beint64_t cpu_to_be64(uint64_t native)
 {
-	return CPU_TO_BE64(native);
+    return CPU_TO_BE64(native);
 }

 /**
@@ -305,7 +305,7 @@ static inline beint64_t cpu_to_be64(uint64_t native)
 */
 static inline beint32_t cpu_to_be32(uint32_t native)
 {
-	return CPU_TO_BE32(native);
+    return CPU_TO_BE32(native);
 }

 /**
@@ -314,7 +314,7 @@ static inline beint32_t cpu_to_be32(uint32_t native)
 */
 static inline beint16_t cpu_to_be16(uint16_t native)
 {
-	return CPU_TO_BE16(native);
+    return CPU_TO_BE16(native);
 }

 /**
@@ -323,7 +323,7 @@ static inline beint16_t cpu_to_be16(uint16_t native)
 */
 static inline uint64_t be64_to_cpu(beint64_t be_val)
 {
-	return BE64_TO_CPU(be_val);
+    return BE64_TO_CPU(be_val);
 }

 /**
@@ -332,7 +332,7 @@ static inline uint64_t be64_to_cpu(beint64_t be_val)
 */
 static inline uint32_t be32_to_cpu(beint32_t be_val)
 {
-	return BE32_TO_CPU(be_val);
+    return BE32_TO_CPU(be_val);
 }

 /**
@@ -341,7 +341,7 @@ static inline uint32_t be32_to_cpu(beint32_t be_val)
 */
 static inline uint16_t be16_to_cpu(beint16_t be_val)
 {
-	return BE16_TO_CPU(be_val);
+    return BE16_TO_CPU(be_val);
 }

 /* Whichever they include first, they get these definitions. */
--- a/damus-c/error.c
+++ b/damus-c/error.c
--- a/damus-c/error.h
+++ b/damus-c/error.h
--- a/damus-c/hash_u5.c
+++ b/damus-c/hash_u5.c
--- a/damus-c/hash_u5.h
+++ b/damus-c/hash_u5.h
--- a/damus-c/hex.c
+++ b/damus-c/hex.c
--- a/damus-c/hex.h
+++ b/damus-c/hex.h
@@ -0,0 +1,84 @@
+/* CC0 (Public domain) - see LICENSE file for details */
+#ifndef CCAN_HEX_H
+#define CCAN_HEX_H
+#include "config.h"
+#include <stdbool.h>
+#include <stdlib.h>
+
+/**
+ * hex_decode - Unpack a hex string.
+ * @str: the hexadecimal string
+ * @slen: the length of @str
+ * @buf: the buffer to write the data into
+ * @bufsize: the length of
+ *
+ * Returns false if there are any characters which aren't 0-9, a-f or A-F,
+ * of the string wasn't the right length for @bufsize.
+ *
+ * Example:
+ *    unsigned char data[20];
+ *
+ *    if (!hex_decode(argv[1], strlen(argv[1]), data, 20))
+ *        printf("String is malformed!\n");
+ */
+bool hex_decode(const char *str, size_t slen, void *buf, size_t bufsize);
+
+/**
+ * hex_encode - Create a nul-terminated hex string
+ * @buf: the buffer to read the data from
+ * @bufsize: the length of buf
+ * @dest: the string to fill
+ * @destsize: the max size of the string
+ *
+ * Returns true if the string, including terminator, fit in @destsize;
+ *
+ * Example:
+ *    unsigned char buf[] = { 0x1F, 0x2F };
+ *    char str[5];
+ *
+ *    if (!hex_encode(buf, sizeof(buf), str, sizeof(str)))
+ *        abort();
+ */
+bool hex_encode(const void *buf, size_t bufsize, char *dest, size_t destsize);
+
+/**
+ * hex_str_size - Calculate how big a nul-terminated hex string is
+ * @bytes: bytes of data to represent
+ *
+ * Example:
+ *    unsigned char buf[] = { 0x1F, 0x2F };
+ *    char str[hex_str_size(sizeof(buf))];
+ *
+ *    hex_encode(buf, sizeof(buf), str, sizeof(str));
+ */
+static inline size_t hex_str_size(size_t bytes)
+{
+    return 2 * bytes + 1;
+}
+
+/**
+ * hex_data_size - Calculate how many bytes of data in a hex string
+ * @strlen: the length of the string (with or without NUL)
+ *
+ * Example:
+ *    const char str[] = "1F2F";
+ *    unsigned char buf[hex_data_size(sizeof(str))];
+ *
+ *    hex_decode(str, strlen(str), buf, sizeof(buf));
+ */
+static inline size_t hex_data_size(size_t strlen)
+{
+    return strlen / 2;
+}
+
+static inline char hexchar(unsigned int val)
+{
+    if (val < 10)
+        return '0' + val;
+    if (val < 16)
+        return 'a' + val - 10;
+    abort();
+}
+
+
+#endif /* CCAN_HEX_H */
--- a/damus-c/likely.h
+++ b/damus-c/likely.h
--- a/damus-c/list.c
+++ b/damus-c/list.c
--- a/damus-c/list.h
+++ b/damus-c/list.h
--- a/damus-c/mem.c
+++ b/damus-c/mem.c
--- a/damus-c/mem.h
+++ b/damus-c/mem.h
--- a/damus-c/node_id.c
+++ b/damus-c/node_id.c
--- a/damus-c/node_id.h
+++ b/damus-c/node_id.h
--- a/damus-c/nostr_bech32.c
+++ b/damus-c/nostr_bech32.c
@@ -0,0 +1,325 @@
+//
+//  nostr_bech32.c
+//  damus
+//
+//  Created by William Casarin on 2023-04-09.
+//
+
+#include "nostr_bech32.h"
+#include <stdlib.h>
+#include "endian.h"
+#include "cursor.h"
+#include "bech32.h"
+#include <stdbool.h>
+
+#define MAX_TLVS 16
+
+#define TLV_SPECIAL 0
+#define TLV_RELAY 1
+#define TLV_AUTHOR 2
+#define TLV_KIND 3
+#define TLV_KNOWN_TLVS 4
+
+struct nostr_tlv {
+    u8 type;
+    u8 len;
+    const u8 *value;
+};
+
+struct nostr_tlvs {
+    struct nostr_tlv tlvs[MAX_TLVS];
+    int num_tlvs;
+};
+
+static int parse_nostr_tlv(struct cursor *cur, struct nostr_tlv *tlv) {
+    // get the tlv tag
+    if (!pull_byte(cur, &tlv->type))
+        return 0;
+    
+    // unknown, fail!
+    if (tlv->type >= TLV_KNOWN_TLVS)
+        return 0;
+    
+    // get the length
+    if (!pull_byte(cur, &tlv->len))
+        return 0;
+    
+    // is the reported length greater then our buffer? if so fail
+    if (cur->p + tlv->len > cur->end)
+        return 0;
+    
+    tlv->value = cur->p;
+    cur->p += tlv->len;
+    
+    return 1;
+}
+
+static int parse_nostr_tlvs(struct cursor *cur, struct nostr_tlvs *tlvs) {
+    int i;
+    tlvs->num_tlvs = 0;
+    
+    for (i = 0; i < MAX_TLVS; i++) {
+        if (parse_nostr_tlv(cur, &tlvs->tlvs[i])) {
+            tlvs->num_tlvs++;
+        } else {
+            break;
+        }
+    }
+    
+    if (tlvs->num_tlvs == 0)
+        return 0;
+    
+    return 1;
+}
+
+static int find_tlv(struct nostr_tlvs *tlvs, u8 type, struct nostr_tlv **tlv) {
+    *tlv = NULL;
+    
+    for (int i = 0; i < tlvs->num_tlvs; i++) {
+        if (tlvs->tlvs[i].type == type) {
+            *tlv = &tlvs->tlvs[i];
+            return 1;
+        }
+    }
+    
+    return 0;
+}
+
+static int parse_nostr_bech32_type(const char *prefix, enum nostr_bech32_type *type) {
+    // Parse type
+    if (strcmp(prefix, "note") == 0) {
+        *type = NOSTR_BECH32_NOTE;
+        return 1;
+    } else if (strcmp(prefix, "npub") == 0) {
+        *type = NOSTR_BECH32_NPUB;
+        return 1;
+    } else if (strcmp(prefix, "nsec") == 0) {
+        *type = NOSTR_BECH32_NSEC;
+        return 1;
+    } else if (strcmp(prefix, "nprofile") == 0) {
+        *type = NOSTR_BECH32_NPROFILE;
+        return 1;
+    } else if (strcmp(prefix, "nevent") == 0) {
+        *type = NOSTR_BECH32_NEVENT;
+        return 1;
+    } else if (strcmp(prefix, "nrelay") == 0) {
+        *type = NOSTR_BECH32_NRELAY;
+        return 1;
+    } else if (strcmp(prefix, "naddr") == 0) {
+        *type = NOSTR_BECH32_NADDR;
+        return 1;
+    }
+    
+    return 0;
+}
+
+static int parse_nostr_bech32_note(struct cursor *cur, struct bech32_note *note) {
+    return pull_bytes(cur, 32, &note->event_id);
+}
+
+static int parse_nostr_bech32_npub(struct cursor *cur, struct bech32_npub *npub) {
+    return pull_bytes(cur, 32, &npub->pubkey);
+}
+
+static int parse_nostr_bech32_nsec(struct cursor *cur, struct bech32_nsec *nsec) {
+    return pull_bytes(cur, 32, &nsec->nsec);
+}
+
+static int tlvs_to_relays(struct nostr_tlvs *tlvs, struct relays *relays) {
+    struct nostr_tlv *tlv;
+    struct str_block *str;
+    
+    relays->num_relays = 0;
+    
+    for (int i = 0; i < tlvs->num_tlvs; i++) {
+        tlv = &tlvs->tlvs[i];
+        if (tlv->type != TLV_RELAY)
+            continue;
+        
+        if (relays->num_relays + 1 > MAX_RELAYS)
+            break;
+        
+        str = &relays->relays[relays->num_relays++];
+        str->start = (const char*)tlv->value;
+        str->end = (const char*)(tlv->value + tlv->len);
+    }
+    
+    return 1;
+}
+
+static uint32_t decode_tlv_u32(const uint8_t *bytes) {
+    beint32_t *be32_bytes = (beint32_t*)bytes;
+    return be32_to_cpu(*be32_bytes);
+}
+
+static int parse_nostr_bech32_nevent(struct cursor *cur, struct bech32_nevent *nevent) {
+    struct nostr_tlvs tlvs;
+    struct nostr_tlv *tlv;
+    
+    if (!parse_nostr_tlvs(cur, &tlvs))
+        return 0;
+    
+    if (!find_tlv(&tlvs, TLV_SPECIAL, &tlv))
+        return 0;
+    
+    if (tlv->len != 32)
+        return 0;
+    
+    nevent->event_id = tlv->value;
+    
+    if (find_tlv(&tlvs, TLV_AUTHOR, &tlv)) {
+        nevent->pubkey = tlv->value;
+    } else {
+        nevent->pubkey = NULL;
+    }
+    
+    if(find_tlv(&tlvs, TLV_KIND, &tlv)) {
+        nevent->kind = decode_tlv_u32(tlv->value);
+        nevent->has_kind = true;
+    } else {
+        nevent->has_kind = false;
+    }
+    
+    return tlvs_to_relays(&tlvs, &nevent->relays);
+}
+
+static int parse_nostr_bech32_naddr(struct cursor *cur, struct bech32_naddr *naddr) {
+    struct nostr_tlvs tlvs;
+    struct nostr_tlv *tlv;
+    
+    if (!parse_nostr_tlvs(cur, &tlvs))
+        return 0;
+    
+    if (!find_tlv(&tlvs, TLV_SPECIAL, &tlv))
+        return 0;
+    
+    naddr->identifier.start = (const char*)tlv->value;
+    naddr->identifier.end = (const char*)tlv->value + tlv->len;
+    
+    if (!find_tlv(&tlvs, TLV_AUTHOR, &tlv))
+        return 0;
+    
+    naddr->pubkey = tlv->value;
+    
+    if(!find_tlv(&tlvs, TLV_KIND, &tlv)) {
+        return 0;
+    }
+    naddr->kind = decode_tlv_u32(tlv->value);
+    
+    return tlvs_to_relays(&tlvs, &naddr->relays);
+}
+
+static int parse_nostr_bech32_nprofile(struct cursor *cur, struct bech32_nprofile *nprofile) {
+    struct nostr_tlvs tlvs;
+    struct nostr_tlv *tlv;
+    
+    if (!parse_nostr_tlvs(cur, &tlvs))
+        return 0;
+    
+    if (!find_tlv(&tlvs, TLV_SPECIAL, &tlv))
+        return 0;
+    
+    if (tlv->len != 32)
+        return 0;
+    
+    nprofile->pubkey = tlv->value;
+    
+    return tlvs_to_relays(&tlvs, &nprofile->relays);
+}
+
+static int parse_nostr_bech32_nrelay(struct cursor *cur, struct bech32_nrelay *nrelay) {
+    struct nostr_tlvs tlvs;
+    struct nostr_tlv *tlv;
+    
+    if (!parse_nostr_tlvs(cur, &tlvs))
+        return 0;
+    
+    if (!find_tlv(&tlvs, TLV_SPECIAL, &tlv))
+        return 0;
+    
+    nrelay->relay.start = (const char*)tlv->value;
+    nrelay->relay.end = (const char*)tlv->value + tlv->len;
+    
+    return 1;
+}
+
+int parse_nostr_bech32(struct cursor *cur, struct nostr_bech32 *obj) {
+    u8 *start, *end;
+    
+    start = cur->p;
+    
+    if (!consume_until_non_alphanumeric(cur, 1)) {
+        cur->p = start;
+        return 0;
+    }
+    
+    end = cur->p;
+    
+    size_t data_len;
+    size_t input_len = end - start;
+    if (input_len < 10 || input_len > 10000) {
+        return 0;
+    }
+    
+    obj->buffer = malloc(input_len * 2);
+    if (!obj->buffer)
+        return 0;
+    
+    u8 data[input_len];
+    char prefix[input_len];
+    
+    if (bech32_decode_len(prefix, data, &data_len, (const char*)start, input_len) == BECH32_ENCODING_NONE) {
+        cur->p = start;
+        return 0;
+    }
+    
+    obj->buflen = 0;
+    if (!bech32_convert_bits(obj->buffer, &obj->buflen, 8, data, data_len, 5, 0)) {
+        goto fail;
+    }
+    
+    if (!parse_nostr_bech32_type(prefix, &obj->type)) {
+        goto fail;
+    }
+    
+    struct cursor bcur;
+    make_cursor(obj->buffer, obj->buffer + obj->buflen, &bcur);
+    
+    switch (obj->type) {
+        case NOSTR_BECH32_NOTE:
+            if (!parse_nostr_bech32_note(&bcur, &obj->data.note))
+                goto fail;
+            break;
+        case NOSTR_BECH32_NPUB:
+            if (!parse_nostr_bech32_npub(&bcur, &obj->data.npub))
+                goto fail;
+            break;
+        case NOSTR_BECH32_NSEC:
+            if (!parse_nostr_bech32_nsec(&bcur, &obj->data.nsec))
+                goto fail;
+            break;
+        case NOSTR_BECH32_NEVENT:
+            if (!parse_nostr_bech32_nevent(&bcur, &obj->data.nevent))
+                goto fail;
+            break;
+        case NOSTR_BECH32_NADDR:
+            if (!parse_nostr_bech32_naddr(&bcur, &obj->data.naddr))
+                goto fail;
+            break;
+        case NOSTR_BECH32_NPROFILE:
+            if (!parse_nostr_bech32_nprofile(&bcur, &obj->data.nprofile))
+                goto fail;
+            break;
+        case NOSTR_BECH32_NRELAY:
+            if (!parse_nostr_bech32_nrelay(&bcur, &obj->data.nrelay))
+                goto fail;
+            break;
+    }
+    
+    return 1;
+
+fail:
+    free(obj->buffer);
+    cur->p = start;
+    return 0;
+}
--- a/damus-c/nostr_bech32.h
+++ b/damus-c/nostr_bech32.h
@@ -0,0 +1,89 @@
+//
+//  nostr_bech32.h
+//  damus
+//
+//  Created by William Casarin on 2023-04-09.
+//
+
+#ifndef nostr_bech32_h
+#define nostr_bech32_h
+
+#include <stdio.h>
+#include "str_block.h"
+#include "cursor.h"
+#include <stdbool.h>
+
+typedef unsigned char u8;
+#define MAX_RELAYS 10
+
+struct relays {
+    struct str_block relays[MAX_RELAYS];
+    int num_relays;
+};
+
+enum nostr_bech32_type {
+    NOSTR_BECH32_NOTE = 1,
+    NOSTR_BECH32_NPUB = 2,
+    NOSTR_BECH32_NPROFILE = 3,
+    NOSTR_BECH32_NEVENT = 4,
+    NOSTR_BECH32_NRELAY = 5,
+    NOSTR_BECH32_NADDR = 6,
+    NOSTR_BECH32_NSEC = 7,
+};
+
+struct bech32_note {
+    const u8 *event_id;
+};
+
+struct bech32_npub {
+    const u8 *pubkey;
+};
+
+struct bech32_nsec {
+    const u8 *nsec;
+};
+
+struct bech32_nevent {
+    struct relays relays;
+    const u8 *event_id;
+    const u8 *pubkey; // optional
+    uint32_t kind;
+    bool has_kind;
+};
+
+struct bech32_nprofile {
+    struct relays relays;
+    const u8 *pubkey;
+};
+
+struct bech32_naddr {
+    struct relays relays;
+    struct str_block identifier;
+    const u8 *pubkey;
+    uint32_t kind;
+};
+
+struct bech32_nrelay {
+    struct str_block relay;
+};
+
+typedef struct nostr_bech32 {
+    enum nostr_bech32_type type;
+    u8 *buffer; // holds strings and tlv stuff
+    size_t buflen;
+    
+    union {
+        struct bech32_note note;
+        struct bech32_npub npub;
+        struct bech32_nsec nsec;
+        struct bech32_nevent nevent;
+        struct bech32_nprofile nprofile;
+        struct bech32_naddr naddr;
+        struct bech32_nrelay nrelay;
+    } data;
+} nostr_bech32_t;
+
+
+int parse_nostr_bech32(struct cursor *cur, struct nostr_bech32 *obj);
+
+#endif /* nostr_bech32_h */
--- a/damus-c/overflows.h
+++ b/damus-c/overflows.h
--- a/damus-c/parser.h
+++ b/damus-c/parser.h
--- a/damus-c/sha256.c
+++ b/damus-c/sha256.c
@@ -0,0 +1,308 @@
+/* MIT (BSD) license - see LICENSE file for details */
+/* SHA256 core code translated from the Bitcoin project's C++:
+ *
+ * src/crypto/sha256.cpp commit 417532c8acb93c36c2b6fd052b7c11b6a2906aa2
+ * Copyright (c) 2014 The Bitcoin Core developers
+ * Distributed under the MIT software license, see the accompanying
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.
+ */
+#include "sha256.h"
+#include "compiler.h"
+#include "endian.h"
+#include <stdbool.h>
+#include <assert.h>
+#include <string.h>
+
+static void invalidate_sha256(struct sha256_ctx *ctx)
+{
+#ifdef CCAN_CRYPTO_SHA256_USE_OPENSSL
+    ctx->c.md_len = 0;
+#else
+    ctx->bytes = (size_t)-1;
+#endif
+}
+
+static void check_sha256(struct sha256_ctx *ctx UNUSED)
+{
+#ifdef CCAN_CRYPTO_SHA256_USE_OPENSSL
+    assert(ctx->c.md_len != 0);
+#else
+    assert(ctx->bytes != (size_t)-1);
+#endif
+}
+
+#ifdef CCAN_CRYPTO_SHA256_USE_OPENSSL
+void sha256_init(struct sha256_ctx *ctx)
+{
+    SHA256_Init(&ctx->c);
+}
+
+void sha256_update(struct sha256_ctx *ctx, const void *p, size_t size)
+{
+    check_sha256(ctx);
+    SHA256_Update(&ctx->c, p, size);
+}
+
+void sha256_done(struct sha256_ctx *ctx, struct sha256 *res)
+{
+    SHA256_Final(res->u.u8, &ctx->c);
+    invalidate_sha256(ctx);
+}
+#else
+static uint32_t Ch(uint32_t x, uint32_t y, uint32_t z)
+{
+    return z ^ (x & (y ^ z));
+}
+static uint32_t Maj(uint32_t x, uint32_t y, uint32_t z)
+{
+    return (x & y) | (z & (x | y));
+}
+static uint32_t Sigma0(uint32_t x)
+{
+    return (x >> 2 | x << 30) ^ (x >> 13 | x << 19) ^ (x >> 22 | x << 10);
+}
+static uint32_t Sigma1(uint32_t x)
+{
+    return (x >> 6 | x << 26) ^ (x >> 11 | x << 21) ^ (x >> 25 | x << 7);
+}
+static uint32_t sigma0(uint32_t x)
+{
+    return (x >> 7 | x << 25) ^ (x >> 18 | x << 14) ^ (x >> 3);
+}
+static uint32_t sigma1(uint32_t x)
+{
+    return (x >> 17 | x << 15) ^ (x >> 19 | x << 13) ^ (x >> 10);
+}
+
+/** One round of SHA-256. */
+static void Round(uint32_t a, uint32_t b, uint32_t c, uint32_t *d, uint32_t e, uint32_t f, uint32_t g, uint32_t *h, uint32_t k, uint32_t w)
+{
+    uint32_t t1 = *h + Sigma1(e) + Ch(e, f, g) + k + w;
+    uint32_t t2 = Sigma0(a) + Maj(a, b, c);
+    *d += t1;
+    *h = t1 + t2;
+}
+
+/** Perform one SHA-256 transformation, processing a 64-byte chunk. */
+static void Transform(uint32_t *s, const uint32_t *chunk)
+{
+    uint32_t a = s[0], b = s[1], c = s[2], d = s[3], e = s[4], f = s[5], g = s[6], h = s[7];
+    uint32_t w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15;
+
+    Round(a, b, c, &d, e, f, g, &h, 0x428a2f98, w0 = be32_to_cpu(chunk[0]));
+    Round(h, a, b, &c, d, e, f, &g, 0x71374491, w1 = be32_to_cpu(chunk[1]));
+    Round(g, h, a, &b, c, d, e, &f, 0xb5c0fbcf, w2 = be32_to_cpu(chunk[2]));
+    Round(f, g, h, &a, b, c, d, &e, 0xe9b5dba5, w3 = be32_to_cpu(chunk[3]));
+    Round(e, f, g, &h, a, b, c, &d, 0x3956c25b, w4 = be32_to_cpu(chunk[4]));
+    Round(d, e, f, &g, h, a, b, &c, 0x59f111f1, w5 = be32_to_cpu(chunk[5]));
+    Round(c, d, e, &f, g, h, a, &b, 0x923f82a4, w6 = be32_to_cpu(chunk[6]));
+    Round(b, c, d, &e, f, g, h, &a, 0xab1c5ed5, w7 = be32_to_cpu(chunk[7]));
+    Round(a, b, c, &d, e, f, g, &h, 0xd807aa98, w8 = be32_to_cpu(chunk[8]));
+    Round(h, a, b, &c, d, e, f, &g, 0x12835b01, w9 = be32_to_cpu(chunk[9]));
+    Round(g, h, a, &b, c, d, e, &f, 0x243185be, w10 = be32_to_cpu(chunk[10]));
+    Round(f, g, h, &a, b, c, d, &e, 0x550c7dc3, w11 = be32_to_cpu(chunk[11]));
+    Round(e, f, g, &h, a, b, c, &d, 0x72be5d74, w12 = be32_to_cpu(chunk[12]));
+    Round(d, e, f, &g, h, a, b, &c, 0x80deb1fe, w13 = be32_to_cpu(chunk[13]));
+    Round(c, d, e, &f, g, h, a, &b, 0x9bdc06a7, w14 = be32_to_cpu(chunk[14]));
+    Round(b, c, d, &e, f, g, h, &a, 0xc19bf174, w15 = be32_to_cpu(chunk[15]));
+
+    Round(a, b, c, &d, e, f, g, &h, 0xe49b69c1, w0 += sigma1(w14) + w9 + sigma0(w1));
+    Round(h, a, b, &c, d, e, f, &g, 0xefbe4786, w1 += sigma1(w15) + w10 + sigma0(w2));
+    Round(g, h, a, &b, c, d, e, &f, 0x0fc19dc6, w2 += sigma1(w0) + w11 + sigma0(w3));
+    Round(f, g, h, &a, b, c, d, &e, 0x240ca1cc, w3 += sigma1(w1) + w12 + sigma0(w4));
+    Round(e, f, g, &h, a, b, c, &d, 0x2de92c6f, w4 += sigma1(w2) + w13 + sigma0(w5));
+    Round(d, e, f, &g, h, a, b, &c, 0x4a7484aa, w5 += sigma1(w3) + w14 + sigma0(w6));
+    Round(c, d, e, &f, g, h, a, &b, 0x5cb0a9dc, w6 += sigma1(w4) + w15 + sigma0(w7));
+    Round(b, c, d, &e, f, g, h, &a, 0x76f988da, w7 += sigma1(w5) + w0 + sigma0(w8));
+    Round(a, b, c, &d, e, f, g, &h, 0x983e5152, w8 += sigma1(w6) + w1 + sigma0(w9));
+    Round(h, a, b, &c, d, e, f, &g, 0xa831c66d, w9 += sigma1(w7) + w2 + sigma0(w10));
+    Round(g, h, a, &b, c, d, e, &f, 0xb00327c8, w10 += sigma1(w8) + w3 + sigma0(w11));
+    Round(f, g, h, &a, b, c, d, &e, 0xbf597fc7, w11 += sigma1(w9) + w4 + sigma0(w12));
+    Round(e, f, g, &h, a, b, c, &d, 0xc6e00bf3, w12 += sigma1(w10) + w5 + sigma0(w13));
+    Round(d, e, f, &g, h, a, b, &c, 0xd5a79147, w13 += sigma1(w11) + w6 + sigma0(w14));
+    Round(c, d, e, &f, g, h, a, &b, 0x06ca6351, w14 += sigma1(w12) + w7 + sigma0(w15));
+    Round(b, c, d, &e, f, g, h, &a, 0x14292967, w15 += sigma1(w13) + w8 + sigma0(w0));
+
+    Round(a, b, c, &d, e, f, g, &h, 0x27b70a85, w0 += sigma1(w14) + w9 + sigma0(w1));
+    Round(h, a, b, &c, d, e, f, &g, 0x2e1b2138, w1 += sigma1(w15) + w10 + sigma0(w2));
+    Round(g, h, a, &b, c, d, e, &f, 0x4d2c6dfc, w2 += sigma1(w0) + w11 + sigma0(w3));
+    Round(f, g, h, &a, b, c, d, &e, 0x53380d13, w3 += sigma1(w1) + w12 + sigma0(w4));
+    Round(e, f, g, &h, a, b, c, &d, 0x650a7354, w4 += sigma1(w2) + w13 + sigma0(w5));
+    Round(d, e, f, &g, h, a, b, &c, 0x766a0abb, w5 += sigma1(w3) + w14 + sigma0(w6));
+    Round(c, d, e, &f, g, h, a, &b, 0x81c2c92e, w6 += sigma1(w4) + w15 + sigma0(w7));
+    Round(b, c, d, &e, f, g, h, &a, 0x92722c85, w7 += sigma1(w5) + w0 + sigma0(w8));
+    Round(a, b, c, &d, e, f, g, &h, 0xa2bfe8a1, w8 += sigma1(w6) + w1 + sigma0(w9));
+    Round(h, a, b, &c, d, e, f, &g, 0xa81a664b, w9 += sigma1(w7) + w2 + sigma0(w10));
+    Round(g, h, a, &b, c, d, e, &f, 0xc24b8b70, w10 += sigma1(w8) + w3 + sigma0(w11));
+    Round(f, g, h, &a, b, c, d, &e, 0xc76c51a3, w11 += sigma1(w9) + w4 + sigma0(w12));
+    Round(e, f, g, &h, a, b, c, &d, 0xd192e819, w12 += sigma1(w10) + w5 + sigma0(w13));
+    Round(d, e, f, &g, h, a, b, &c, 0xd6990624, w13 += sigma1(w11) + w6 + sigma0(w14));
+    Round(c, d, e, &f, g, h, a, &b, 0xf40e3585, w14 += sigma1(w12) + w7 + sigma0(w15));
+    Round(b, c, d, &e, f, g, h, &a, 0x106aa070, w15 += sigma1(w13) + w8 + sigma0(w0));
+
+    Round(a, b, c, &d, e, f, g, &h, 0x19a4c116, w0 += sigma1(w14) + w9 + sigma0(w1));
+    Round(h, a, b, &c, d, e, f, &g, 0x1e376c08, w1 += sigma1(w15) + w10 + sigma0(w2));
+    Round(g, h, a, &b, c, d, e, &f, 0x2748774c, w2 += sigma1(w0) + w11 + sigma0(w3));
+    Round(f, g, h, &a, b, c, d, &e, 0x34b0bcb5, w3 += sigma1(w1) + w12 + sigma0(w4));
+    Round(e, f, g, &h, a, b, c, &d, 0x391c0cb3, w4 += sigma1(w2) + w13 + sigma0(w5));
+    Round(d, e, f, &g, h, a, b, &c, 0x4ed8aa4a, w5 += sigma1(w3) + w14 + sigma0(w6));
+    Round(c, d, e, &f, g, h, a, &b, 0x5b9cca4f, w6 += sigma1(w4) + w15 + sigma0(w7));
+    Round(b, c, d, &e, f, g, h, &a, 0x682e6ff3, w7 += sigma1(w5) + w0 + sigma0(w8));
+    Round(a, b, c, &d, e, f, g, &h, 0x748f82ee, w8 += sigma1(w6) + w1 + sigma0(w9));
+    Round(h, a, b, &c, d, e, f, &g, 0x78a5636f, w9 += sigma1(w7) + w2 + sigma0(w10));
+    Round(g, h, a, &b, c, d, e, &f, 0x84c87814, w10 += sigma1(w8) + w3 + sigma0(w11));
+    Round(f, g, h, &a, b, c, d, &e, 0x8cc70208, w11 += sigma1(w9) + w4 + sigma0(w12));
+    Round(e, f, g, &h, a, b, c, &d, 0x90befffa, w12 += sigma1(w10) + w5 + sigma0(w13));
+    Round(d, e, f, &g, h, a, b, &c, 0xa4506ceb, w13 += sigma1(w11) + w6 + sigma0(w14));
+    Round(c, d, e, &f, g, h, a, &b, 0xbef9a3f7, w14 + sigma1(w12) + w7 + sigma0(w15));
+    Round(b, c, d, &e, f, g, h, &a, 0xc67178f2, w15 + sigma1(w13) + w8 + sigma0(w0));
+
+    s[0] += a;
+    s[1] += b;
+    s[2] += c;
+    s[3] += d;
+    s[4] += e;
+    s[5] += f;
+    s[6] += g;
+    s[7] += h;
+}
+
+static bool alignment_ok(const void *p UNUSED, size_t n UNUSED)
+{
+#if HAVE_UNALIGNED_ACCESS
+    return true;
+#else
+    return ((size_t)p % n == 0);
+#endif
+}
+
+static void add(struct sha256_ctx *ctx, const void *p, size_t len)
+{
+    const unsigned char *data = p;
+    size_t bufsize = ctx->bytes % 64;
+
+    if (bufsize + len >= 64) {
+        /* Fill the buffer, and process it. */
+        memcpy(ctx->buf.u8 + bufsize, data, 64 - bufsize);
+        ctx->bytes += 64 - bufsize;
+        data += 64 - bufsize;
+        len -= 64 - bufsize;
+        Transform(ctx->s, ctx->buf.u32);
+        bufsize = 0;
+    }
+
+    while (len >= 64) {
+        /* Process full chunks directly from the source. */
+        if (alignment_ok(data, sizeof(uint32_t)))
+            Transform(ctx->s, (const uint32_t *)data);
+        else {
+            memcpy(ctx->buf.u8, data, sizeof(ctx->buf));
+            Transform(ctx->s, ctx->buf.u32);
+        }
+        ctx->bytes += 64;
+        data += 64;
+        len -= 64;
+    }
+        
+    if (len) {
+        /* Fill the buffer with what remains. */
+        memcpy(ctx->buf.u8 + bufsize, data, len);
+        ctx->bytes += len;
+    }
+}
+
+void sha256_init(struct sha256_ctx *ctx)
+{
+    struct sha256_ctx init = SHA256_INIT;
+    *ctx = init;
+}
+
+void sha256_update(struct sha256_ctx *ctx, const void *p, size_t size)
+{
+    check_sha256(ctx);
+    add(ctx, p, size);
+}
+
+void sha256_done(struct sha256_ctx *ctx, struct sha256 *res)
+{
+    static const unsigned char pad[64] = {0x80};
+    uint64_t sizedesc;
+    size_t i;
+
+    sizedesc = cpu_to_be64((uint64_t)ctx->bytes << 3);
+    /* Add '1' bit to terminate, then all 0 bits, up to next block - 8. */
+    add(ctx, pad, 1 + ((128 - 8 - (ctx->bytes % 64) - 1) % 64));
+    /* Add number of bits of data (big endian) */
+    add(ctx, &sizedesc, 8);
+    for (i = 0; i < sizeof(ctx->s) / sizeof(ctx->s[0]); i++)
+        res->u.u32[i] = cpu_to_be32(ctx->s[i]);
+    invalidate_sha256(ctx);
+}
+#endif
+
+void sha256(struct sha256 *sha, const void *p, size_t size)
+{
+    struct sha256_ctx ctx;
+
+    sha256_init(&ctx);
+    sha256_update(&ctx, p, size);
+    sha256_done(&ctx, sha);
+}
+    
+void sha256_u8(struct sha256_ctx *ctx, uint8_t v)
+{
+    sha256_update(ctx, &v, sizeof(v));
+}
+
+void sha256_u16(struct sha256_ctx *ctx, uint16_t v)
+{
+    sha256_update(ctx, &v, sizeof(v));
+}
+
+void sha256_u32(struct sha256_ctx *ctx, uint32_t v)
+{
+    sha256_update(ctx, &v, sizeof(v));
+}
+
+void sha256_u64(struct sha256_ctx *ctx, uint64_t v)
+{
+    sha256_update(ctx, &v, sizeof(v));
+}
+
+/* Add as little-endian */
+void sha256_le16(struct sha256_ctx *ctx, uint16_t v)
+{
+    leint16_t lev = cpu_to_le16(v);
+    sha256_update(ctx, &lev, sizeof(lev));
+}
+    
+void sha256_le32(struct sha256_ctx *ctx, uint32_t v)
+{
+    leint32_t lev = cpu_to_le32(v);
+    sha256_update(ctx, &lev, sizeof(lev));
+}
+    
+void sha256_le64(struct sha256_ctx *ctx, uint64_t v)
+{
+    leint64_t lev = cpu_to_le64(v);
+    sha256_update(ctx, &lev, sizeof(lev));
+}
+
+/* Add as big-endian */
+void sha256_be16(struct sha256_ctx *ctx, uint16_t v)
+{
+    beint16_t bev = cpu_to_be16(v);
+    sha256_update(ctx, &bev, sizeof(bev));
+}
+    
+void sha256_be32(struct sha256_ctx *ctx, uint32_t v)
+{
+    beint32_t bev = cpu_to_be32(v);
+    sha256_update(ctx, &bev, sizeof(bev));
+}
+    
+void sha256_be64(struct sha256_ctx *ctx, uint64_t v)
+{
+    beint64_t bev = cpu_to_be64(v);
+    sha256_update(ctx, &bev, sizeof(bev));
+}
--- a/nostrdb/ccan/ccan/crypto/sha256/sha256.h
+++ b/nostrdb/ccan/ccan/crypto/sha256/sha256.h
@@ -20,17 +20,17 @@
 * Other fields may be added to the union in future.
 */
 struct sha256 {
-	union {
-		uint32_t u32[8];
-		unsigned char u8[32];
-	} u;
+    union {
+        uint32_t u32[8];
+        unsigned char u8[32];
+    } u;
 };

 /**
 * sha256 - return sha256 of an object.
 * @sha256: the sha256 to fill in
 * @p: pointer to memory,
- * @size: the number of bytes pointed to by @p
+ * @size: the number of bytes pointed to by
 *
 * The bytes pointed to by @p is SHA256 hashed into @sha256.  This is
 * equivalent to sha256_init(), sha256_update() then sha256_done().
@@ -42,14 +42,14 @@ void sha256(struct sha256 *sha, const void *p, size_t size);
 */
 struct sha256_ctx {
 #ifdef CCAN_CRYPTO_SHA256_USE_OPENSSL
-	SHA256_CTX c;
+    SHA256_CTX c;
 #else
-	uint32_t s[8];
-	union {
-		uint32_t u32[16];
-		unsigned char u8[64];
-	} buf;
-	size_t bytes;
+    uint32_t s[8];
+    union {
+        uint32_t u32[16];
+        unsigned char u8[64];
+    } buf;
+    size_t bytes;
 #endif
 };

@@ -66,13 +66,13 @@ struct sha256_ctx {
 * Example:
 * static void hash_all(const char **arr, struct sha256 *hash)
 * {
- *	size_t i;
- *	struct sha256_ctx ctx;
+ *    size_t i;
+ *    struct sha256_ctx ctx;
 *
- *	sha256_init(&ctx);
- *	for (i = 0; arr[i]; i++)
- *		sha256_update(&ctx, arr[i], strlen(arr[i]));
- *	sha256_done(&ctx, hash);
+ *    sha256_init(&ctx);
+ *    for (i = 0; arr[i]; i++)
+ *        sha256_update(&ctx, arr[i], strlen(arr[i]));
+ *    sha256_done(&ctx, hash);
 * }
 */
 void sha256_init(struct sha256_ctx *ctx);
@@ -86,33 +86,33 @@ void sha256_init(struct sha256_ctx *ctx);
 * Example:
 * static void hash_all(const char **arr, struct sha256 *hash)
 * {
- *	size_t i;
- *	struct sha256_ctx ctx = SHA256_INIT;
+ *    size_t i;
+ *    struct sha256_ctx ctx = SHA256_INIT;
 *
- *	for (i = 0; arr[i]; i++)
- *		sha256_update(&ctx, arr[i], strlen(arr[i]));
- *	sha256_done(&ctx, hash);
+ *    for (i = 0; arr[i]; i++)
+ *        sha256_update(&ctx, arr[i], strlen(arr[i]));
+ *    sha256_done(&ctx, hash);
 * }
 */
 #ifdef CCAN_CRYPTO_SHA256_USE_OPENSSL
-#define SHA256_INIT							\
-	{ { { 0x6a09e667ul, 0xbb67ae85ul, 0x3c6ef372ul, 0xa54ff53aul,	\
-	      0x510e527ful, 0x9b05688cul, 0x1f83d9abul, 0x5be0cd19ul }, \
-		0x0, 0x0,						\
-		{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },	\
-			0x0, 0x20 } }
+#define SHA256_INIT                            \
+    { { { 0x6a09e667ul, 0xbb67ae85ul, 0x3c6ef372ul, 0xa54ff53aul,    \
+          0x510e527ful, 0x9b05688cul, 0x1f83d9abul, 0x5be0cd19ul }, \
+        0x0, 0x0,                        \
+        { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },    \
+            0x0, 0x20 } }
 #else
-#define SHA256_INIT							\
-	{ { 0x6a09e667ul, 0xbb67ae85ul, 0x3c6ef372ul, 0xa54ff53aul,	\
-	    0x510e527ful, 0x9b05688cul, 0x1f83d9abul, 0x5be0cd19ul },	\
-	  { { 0 } }, 0 }
+#define SHA256_INIT                            \
+    { { 0x6a09e667ul, 0xbb67ae85ul, 0x3c6ef372ul, 0xa54ff53aul,    \
+        0x510e527ful, 0x9b05688cul, 0x1f83d9abul, 0x5be0cd19ul },    \
+      { { 0 } }, 0 }
 #endif

 /**
 * sha256_update - include some memory in the hash.
 * @ctx: the sha256_ctx to use
 * @p: pointer to memory,
- * @size: the number of bytes pointed to by @p
+ * @size: the number of bytes pointed to by
 *
 * You can call this multiple times to hash more data, before calling
 * sha256_done().
--- a/nostrdb/ccan/ccan/short_types/short_types.h
+++ b/nostrdb/ccan/ccan/short_types/short_types.h
--- a/damus-c/str.h
+++ b/damus-c/str.h
--- a/damus-c/str_block.h
+++ b/damus-c/str_block.h
@@ -8,4 +8,9 @@
 #ifndef str_block_h
 #define str_block_h

+typedef struct str_block {
+    const char *start;
+    const char *end;
+} str_block_t;
+
 #endif /* str_block_h */
--- a/nostrdb/ccan/ccan/str/str_debug.h
+++ b/nostrdb/ccan/ccan/str/str_debug.h
--- a/damus-c/structeq.h
+++ b/damus-c/structeq.h
--- a/damus-c/take.c
+++ b/damus-c/take.c
--- a/damus-c/take.h
+++ b/damus-c/take.h
--- a/damus-c/tal.c
+++ b/damus-c/tal.c
--- a/damus-c/tal.h
+++ b/damus-c/tal.h
--- a/damus-c/talstr.c
+++ b/damus-c/talstr.c
--- a/damus-c/talstr.h
+++ b/damus-c/talstr.h
--- a/damus-c/typedefs.h
+++ b/damus-c/typedefs.h
@@ -0,0 +1,14 @@
+
+#ifndef PROTOVERSE_TYPEDEFS_H
+#define PROTOVERSE_TYPEDEFS_H
+
+#include <stdint.h>
+
+typedef unsigned char u8;
+typedef unsigned int u32;
+typedef unsigned short u16;
+typedef uint64_t u64;
+typedef int64_t s64;
+
+
+#endif /* PROTOVERSE_TYPEDEFS_H */
--- a/damus-c/typesafe_cb.h
+++ b/damus-c/typesafe_cb.h
--- a/damus-c/utf8.c
+++ b/damus-c/utf8.c
--- a/damus-c/utf8.h
+++ b/damus-c/utf8.h
--- a/damus-c/varint.h
+++ b/damus-c/varint.h
--- a/damus-c/wasm.c
+++ b/damus-c/wasm.c
@@ -1179,7 +1179,7 @@ static INLINE int parse_i64(struct cursor *read, uint64_t *val)
 	shift = 0;

 	do {
-		if (!cursor_pull_byte(read, &byte))
+		if (!pull_byte(read, &byte))
 			return 0;
 		*val |= (byte & 0x7FULL) << shift;
 		shift += 7;
@@ -1199,7 +1199,7 @@ static INLINE int uleb128_read(struct cursor *read, unsigned int *val)
 	*val = 0;

 	for (;;) {
-		if (!cursor_pull_byte(read, &byte))
+		if (!pull_byte(read, &byte))
 			return 0;

 		*val |= (0x7F & byte) << shift;
@@ -1222,7 +1222,7 @@ static INLINE int sleb128_read(struct cursor *read, signed int *val)
 	shift = 0;

 	do {
-		if (!cursor_pull_byte(read, &byte))
+		if (!pull_byte(read, &byte))
 			return 0;
 		*val |= ((byte & 0x7F) << shift);
 		shift += 7;
@@ -1241,21 +1241,21 @@ static INLINE int uleb128_read(struct cursor *read, unsigned int *val)
 	unsigned char p[6] = {0};
 	*val = 0;

-	if (cursor_pull_byte(read, &p[0]) && (p[0] & 0x80) == 0) {
+	if (pull_byte(read, &p[0]) && (p[0] & 0x80) == 0) {
 		*val = LEB128_1(unsigned int);
 		if (p[0] == 0x7F)
 			assert((int)*val == -1);
 		return 1;
-	} else if (cursor_pull_byte(read, &p[1]) && (p[1] & 0x80) == 0) {
+	} else if (pull_byte(read, &p[1]) && (p[1] & 0x80) == 0) {
 		*val = LEB128_2(unsigned int);
 		return 2;
-	} else if (cursor_pull_byte(read, &p[2]) && (p[2] & 0x80) == 0) {
+	} else if (pull_byte(read, &p[2]) && (p[2] & 0x80) == 0) {
 		*val = LEB128_3(unsigned int);
 		return 3;
-	} else if (cursor_pull_byte(read, &p[3]) && (p[3] & 0x80) == 0) {
+	} else if (pull_byte(read, &p[3]) && (p[3] & 0x80) == 0) {
 		*val = LEB128_4(unsigned int);
 		return 4;
-	} else if (cursor_pull_byte(read, &p[4]) && (p[4] & 0x80) == 0) {
+	} else if (pull_byte(read, &p[4]) && (p[4] & 0x80) == 0) {
 		if (!(p[4] & 0xF0)) {
 			*val = LEB128_5(unsigned int);
 			return 5;
@@ -1296,7 +1296,7 @@ static int parse_section_tag(struct cursor *cur, enum section_tag *section)

 	start = cur->p;

-	if (!cursor_pull_byte(cur, &byte)) {
+	if (!pull_byte(cur, &byte)) {
 		return 0;
 	}

@@ -1315,7 +1315,7 @@ static int parse_valtype(struct wasm_parser *p, enum valtype *valtype)

 	start = p->cur.p;

-	if (unlikely(!cursor_pull_byte(&p->cur, (unsigned char*)valtype))) {
+	if (unlikely(!pull_byte(&p->cur, (unsigned char*)valtype))) {
 		return parse_err(p, "valtype tag oob");
 	}

@@ -1416,7 +1416,7 @@ static int parse_export_desc(struct wasm_parser *p, enum exportdesc *desc)
 {
 	unsigned char byte;

-	if (!cursor_pull_byte(&p->cur, &byte)) {
+	if (!pull_byte(&p->cur, &byte)) {
 		parse_err(p, "export desc byte eof");
 		return 0;
 	}
@@ -1523,7 +1523,7 @@ static int parse_name_subsection(struct wasm_parser *p, struct namesec *sec, u32
 	u8 tag;
 	u8 *start = p->cur.p;

-	if (!cursor_pull_byte(&p->cur, &tag))
+	if (!pull_byte(&p->cur, &tag))
 		return parse_err(p, "name subsection tag oob?");

 	if (!is_valid_name_subsection(tag))
@@ -1676,7 +1676,7 @@ static int parse_reftype(struct wasm_parser *p, enum reftype *reftype)
 {
 	u8 tag;

-	if (!cursor_pull_byte(&p->cur, &tag)) {
+	if (!pull_byte(&p->cur, &tag)) {
 		parse_err(p, "reftype");
 		return 0;
 	}
@@ -1720,7 +1720,7 @@ static int parse_export_section(struct wasm_parser *p,
 static int parse_limits(struct wasm_parser *p, struct limits *limits)
 {
 	unsigned char tag;
-	if (!cursor_pull_byte(&p->cur, &tag)) {
+	if (!pull_byte(&p->cur, &tag)) {
 		return parse_err(p, "oob");
 	}

@@ -1803,7 +1803,7 @@ static void print_code(u8 *code, int code_len)
 	make_cursor(code, code + code_len, &c);

 	for (;;) {
-		if (!cursor_pull_byte(&c, &tag)) {
+		if (!pull_byte(&c, &tag)) {
 			break;
 		}

@@ -2169,7 +2169,7 @@ static int parse_const_expr(struct expr_parser *p, struct expr *expr)
 	expr->code = p->code->p;

 	while (1) {
-		if (unlikely(!cursor_pull_byte(p->code, &tag))) {
+		if (unlikely(!pull_byte(p->code, &tag))) {
 			return note_error(p->errs, p->code, "oob");
 		}

@@ -2332,7 +2332,7 @@ static int parse_instrs_until_at(struct expr_parser *p, u8 stop_instr,
 		       p->code->p - p->code->start,
 		       dbg_inst, instr_name(stop_instr));
       for (;;) {
-               if (!cursor_pull_byte(p->code, &tag))
+               if (!pull_byte(p->code, &tag))
                       return note_error(p->errs, p->code, "oob");

 	       if ((tag != i_if && tag == stop_instr) ||
@@ -2413,7 +2413,7 @@ static int parse_element(struct wasm_parser *p, struct elem *elem)

 	make_expr_parser(&p->errs, &p->cur, &expr_parser);

-	if (!cursor_pull_byte(&p->cur, &tag))
+	if (!pull_byte(&p->cur, &tag))
 		return parse_err(p, "tag");

 	if (tag > 7)
@@ -2545,7 +2545,7 @@ static int parse_wdata(struct wasm_parser *p, struct wdata *data)
 	struct expr_parser parser;
 	u8 tag;

-	if (!cursor_pull_byte(&p->cur, &tag)) {
+	if (!pull_byte(&p->cur, &tag)) {
 		return parse_err(p, "tag");
 	}

@@ -2700,7 +2700,7 @@ static int parse_importdesc(struct wasm_parser *p, struct importdesc *desc)
 {
 	u8 tag;

-	if (!cursor_pull_byte(&p->cur, &tag)) {
+	if (!pull_byte(&p->cur, &tag)) {
 		parse_err(p, "oom");
 		return 0;
 	}
@@ -4134,7 +4134,7 @@ static int parse_blocktype(struct cursor *cur, struct errors *errs, struct block
 {
 	unsigned char byte;

-	if (unlikely(!cursor_pull_byte(cur, &byte))) {
+	if (unlikely(!pull_byte(cur, &byte))) {
 		return note_error(errs, cur, "parse_blocktype: oob\n");
 	}

@@ -4656,7 +4656,7 @@ static int parse_bulk_op(struct cursor *code, struct errors *errs,
 {
 	u8 tag;

-	if (unlikely(!cursor_pull_byte(code, &tag)))
+	if (unlikely(!pull_byte(code, &tag)))
 		return note_error(errs, code, "oob");

 	if (unlikely(tag < 10 || tag > 17))
@@ -6552,7 +6552,7 @@ static INLINE int interp_parse_instr(struct wasm_interp *interp,
 {
 	u8 tag;

-	if (unlikely(!cursor_pull_byte(code, &tag))) {
+	if (unlikely(!pull_byte(code, &tag))) {
 		return interp_error(interp, "no more instrs to pull");
 	}

--- a/damus-c/wasm.h
+++ b/damus-c/wasm.h
@@ -27,8 +27,6 @@ static const unsigned char WASM_MAGIC[] = {0,'a','s','m'};
 #define interp_error(p, fmt, ...) note_error(&((p)->errors), interp_codeptr(p), fmt, ##__VA_ARGS__)
 #define parse_err(p, fmt, ...) note_error(&((p)->errs), &(p)->cur, fmt, ##__VA_ARGS__)

-#include "short_types.h"
-
 enum valtype {
 	val_i32 = 0x7F,
 	val_i64 = 0x7E,
--- a/damus.xcodeproj/project.pbxproj
+++ b/damus.xcodeproj/project.pbxproj
--- a/damus/Assets.xcassets/Illustrations/damooseLabs.imageset/Contents.json
+++ b/damus/Assets.xcassets/Illustrations/damooseLabs.imageset/Contents.json
@@ -1,21 +0,0 @@
-{
-  "images" : [
-    {
-      "filename" : "damooseLabs.png",
-      "idiom" : "universal",
-      "scale" : "1x"
-    },
-    {
-      "idiom" : "universal",
-      "scale" : "2x"
-    },
-    {
-      "idiom" : "universal",
-      "scale" : "3x"
-    }
-  ],
-  "info" : {
-    "author" : "xcode",
-    "version" : 1
-  }
-}
--- a/damus/Assets.xcassets/Illustrations/damooseLabs.imageset/damooseLabs.png
+++ b/damus/Assets.xcassets/Illustrations/damooseLabs.imageset/damooseLabs.png
--- a/damus/Shared/Components/CustomPicker.swift
+++ b/damus/Shared/Components/CustomPicker.swift
--- a/damus/Shared/Components/DamusColors.swift
+++ b/damus/Shared/Components/DamusColors.swift
@@ -28,15 +28,7 @@ class DamusColors {
    static let green = Color("DamusGreen")
    static let purple = Color("DamusPurple")
    static let deepPurple = Color("DamusDeepPurple")
-    static let highlight = Color(UIColor { traits in
-        if traits.userInterfaceStyle == .dark {
-            // Vivid Damus magenta tuned for dark backgrounds (strong contrast without glow)
-            return UIColor(red: 0.95, green: 0.43, blue: 0.82, alpha: 0.78)
-        } else {
-            // Slightly deeper pink on light so text stays legible
-            return UIColor(red: 0.88, green: 0.32, blue: 0.74, alpha: 0.62)
-        }
-    })
+    static let highlight = Color("DamusHighlight")
    static let blue = Color("DamusBlue")
    static let bitcoin = Color("Bitcoin")
    static let success = Color("DamusSuccessPrimary")
@@ -60,24 +52,6 @@ class DamusColors {
    static let pink = Color(red: 211/255.0, green: 76/255.0, blue: 217/255.0)
    static let lighterPink = Color(red: 248/255.0, green: 105/255.0, blue: 182/255.0)
    static let lightBackgroundPink = Color(red: 0xF8/255.0, green: 0xE7/255.0, blue: 0xF8/255.0)
-
-    // Sepia mode colors for comfortable longform reading
-    // Light mode sepia
-    static let sepiaBackgroundLight = Color(red: 0.98, green: 0.95, blue: 0.90)  // #FAF3E6 - warm off-white
-    static let sepiaTextLight = Color(red: 0.35, green: 0.27, blue: 0.20)  // #5A4632 - warm brown
-    // Dark mode sepia (subtle warm tint that blends with dark UI)
-    static let sepiaBackgroundDark = Color(red: 0.08, green: 0.07, blue: 0.06)  // Near-black with subtle warmth
-    static let sepiaTextDark = Color(red: 0.85, green: 0.80, blue: 0.72)  // Warm off-white text
-
-    /// Returns appropriate sepia background for current color scheme.
-    static func sepiaBackground(for colorScheme: ColorScheme) -> Color {
-        colorScheme == .dark ? sepiaBackgroundDark : sepiaBackgroundLight
-    }
-
-    /// Returns appropriate sepia text color for current color scheme.
-    static func sepiaText(for colorScheme: ColorScheme) -> Color {
-        colorScheme == .dark ? sepiaTextDark : sepiaTextLight
-    }
 }

 func hex_col(r: UInt8, g: UInt8, b: UInt8) -> Color {
--- a/damus/Shared/Components/EndBlock.swift
+++ b/damus/Shared/Components/EndBlock.swift
--- a/damus/Shared/Buttons/GradientButtonStyle.swift
+++ b/damus/Shared/Buttons/GradientButtonStyle.swift
--- a/damus/Components/Gradients/AlbyGradient.swift
+++ b/damus/Components/Gradients/AlbyGradient.swift
@@ -0,0 +1,15 @@
+//
+//  AlbyGradient.swift
+//  damus
+//
+//  Created by William Casarin on 2023-05-09.
+//
+
+import SwiftUI
+
+fileprivate let alby_grad_c1 = hex_col(r: 226, g: 168, b: 122)
+fileprivate let alby_grad_c2 = hex_col(r: 249, g: 223, b: 127)
+fileprivate let alby_grad = [alby_grad_c2, alby_grad_c1]
+
+let AlbyGradient: LinearGradient =
+    LinearGradient(colors: alby_grad, startPoint: .bottomLeading, endPoint: .topTrailing)
--- a/damus/Shared/Components/Gradients/DamusBackground.swift
+++ b/damus/Shared/Components/Gradients/DamusBackground.swift
--- a/damus/Shared/Components/Gradients/DamusGradient.swift
+++ b/damus/Shared/Components/Gradients/DamusGradient.swift
--- a/damus/Shared/Components/Gradients/DamusLightGradient.swift
+++ b/damus/Shared/Components/Gradients/DamusLightGradient.swift
--- a/damus/Shared/Components/Gradients/DamusLogoGradient.swift
+++ b/damus/Shared/Components/Gradients/DamusLogoGradient.swift
--- a/damus/Shared/Components/Gradients/GoldSupportGradient.swift
+++ b/damus/Shared/Components/Gradients/GoldSupportGradient.swift
--- a/damus/Shared/Components/Gradients/GrayGradient.swift
+++ b/damus/Shared/Components/Gradients/GrayGradient.swift
--- a/damus/Shared/Components/Gradients/PinkGradient.swift
+++ b/damus/Shared/Components/Gradients/PinkGradient.swift
--- a/damus/Shared/Components/Highlight.swift
+++ b/damus/Shared/Components/Highlight.swift
--- a/damus/Shared/Components/IconLabel.swift
+++ b/damus/Shared/Components/IconLabel.swift
--- a/damus/Shared/Media/Models/ImageCarousel.swift
+++ b/damus/Shared/Media/Models/ImageCarousel.swift
--- a/damus/Shared/Components/InvoiceView.swift
+++ b/damus/Shared/Components/InvoiceView.swift
@@ -118,8 +118,7 @@ func getUrlToOpen(invoice: String, with wallet: Wallet.Model) throws(OpenWalletE
    }
 }

-
-let test_invoice = Invoice(description: .description("this is a description"), amount: .specific(10000), string: "lnbc100n1p357sl0sp5t9n56wdztun39lgdqlr30xqwksg3k69q4q2rkr52aplujw0esn0qpp5mrqgljk62z20q4nvgr6lzcyn6fhylzccwdvu4k77apg3zmrkujjqdpzw35xjueqd9ejqcfqv3jhxcmjd9c8g6t0dcxqyjw5qcqpjrzjqt56h4gvp5yx36u2uzqa6qwcsk3e2duunfxppzj9vhypc3wfe2wswz607uqq3xqqqsqqqqqqqqqqqlqqyg9qyysgqagx5h20aeulj3gdwx3kxs8u9f4mcakdkwuakasamm9562ffyr9en8yg20lg0ygnr9zpwp68524kmda0t5xp2wytex35pu8hapyjajxqpsql29r", expiry: 604800, created_at: 1666139119)
+let test_invoice = Invoice(description: .description("this is a description"), amount: .specific(10000), string: "lnbc100n1p357sl0sp5t9n56wdztun39lgdqlr30xqwksg3k69q4q2rkr52aplujw0esn0qpp5mrqgljk62z20q4nvgr6lzcyn6fhylzccwdvu4k77apg3zmrkujjqdpzw35xjueqd9ejqcfqv3jhxcmjd9c8g6t0dcxqyjw5qcqpjrzjqt56h4gvp5yx36u2uzqa6qwcsk3e2duunfxppzj9vhypc3wfe2wswz607uqq3xqqqsqqqqqqqqqqqlqqyg9qyysgqagx5h20aeulj3gdwx3kxs8u9f4mcakdkwuakasamm9562ffyr9en8yg20lg0ygnr9zpwp68524kmda0t5xp2wytex35pu8hapyjajxqpsql29r", expiry: 604800, payment_hash: Data(), created_at: 1666139119)

 struct InvoiceView_Previews: PreviewProvider {
    static var previews: some View {
--- a/damus/Shared/Components/InvoicesView.swift
+++ b/damus/Shared/Components/InvoicesView.swift
@@ -29,7 +29,7 @@ struct InvoicesView: View {

 struct InvoicesView_Previews: PreviewProvider {
    static var previews: some View {
-        InvoicesView(our_pubkey: test_note.pubkey, invoices: [Invoice.init(description: .description("description"), amount: .specific(10000), string: "invstr", expiry: 100000, created_at: 1000000)], settings: test_damus_state.settings)
+        InvoicesView(our_pubkey: test_note.pubkey, invoices: [Invoice.init(description: .description("description"), amount: .specific(10000), string: "invstr", expiry: 100000, payment_hash: Data(), created_at: 1000000)], settings: test_damus_state.settings)
            .frame(width: 300)
    }
 }
--- a/damus/Shared/Components/NIP05Badge.swift
+++ b/damus/Shared/Components/NIP05Badge.swift
@@ -60,7 +60,7 @@ struct NIP05Badge: View {
    }

    var username_matches_nip05: Bool {
-        guard let name = try? damus_state.profiles.lookup(id: pubkey)?.name
+        guard let name = damus_state.profiles.lookup(id: pubkey)?.map({ p in p?.name }).value
        else {
            return false
        }
@@ -109,7 +109,6 @@ extension View {
    }
 }

-@MainActor
 func use_nip05_color(pubkey: Pubkey, contacts: Contacts) -> Bool {
    return contacts.is_friend_or_self(pubkey) ? true : false
 }
--- a/damus/Shared/Buttons/NeutralButtonStyle.swift
+++ b/damus/Shared/Buttons/NeutralButtonStyle.swift
--- a/damus/Features/Zaps/Views/NoteZapButton.swift
+++ b/damus/Features/Zaps/Views/NoteZapButton.swift
@@ -70,9 +70,9 @@ struct NoteZapButton: View {
        return Color.orange
    }
    
-    func tap() async {
+    func tap() {
        guard let our_zap else {
-            Task { await send_zap(damus_state: damus_state, target: target, lnurl: lnurl, is_custom: false, comment: nil, amount_sats: nil, zap_type: damus_state.settings.default_zap_type) }
+            send_zap(damus_state: damus_state, target: target, lnurl: lnurl, is_custom: false, comment: nil, amount_sats: nil, zap_type: damus_state.settings.default_zap_type)
            return
        }
        
@@ -84,7 +84,7 @@ struct NoteZapButton: View {
            print("cancel_zap: we already have a real zap, can't cancel")
            break
        case .pending(let pzap):
-            guard let res = await cancel_zap(zap: pzap, box: damus_state.nostrNetwork.postbox, zapcache: damus_state.zaps, evcache: damus_state.events) else {
+            guard let res = cancel_zap(zap: pzap, box: damus_state.nostrNetwork.postbox, zapcache: damus_state.zaps, evcache: damus_state.events) else {
                
                UIImpactFeedbackGenerator(style: .soft).impactOccurred()
                return
@@ -146,7 +146,7 @@ struct NoteZapButton: View {
        .highPriorityGesture(TapGesture().onEnded {
            guard !damus_state.settings.nozaps else { return }
            
-            Task { await tap() }
+            tap()
        })
    }
 }
@@ -173,13 +173,13 @@ func initial_pending_zap_state(settings: UserSettingsStore) -> PendingZapState {
    return .external(ExtPendingZapState(state: .fetching_invoice))
 }

-func send_zap(damus_state: DamusState, target: ZapTarget, lnurl: String, is_custom: Bool, comment: String?, amount_sats: Int?, zap_type: ZapType) async {
+func send_zap(damus_state: DamusState, target: ZapTarget, lnurl: String, is_custom: Bool, comment: String?, amount_sats: Int?, zap_type: ZapType) {
    guard let keypair = damus_state.keypair.to_full() else {
        return
    }
    
    // Only take the first 10 because reasons
-    let relays = Array(await damus_state.nostrNetwork.ourRelayDescriptors.prefix(10))
+    let relays = Array(damus_state.nostrNetwork.pool.our_descriptors.prefix(10))
    let content = comment ?? ""
    
    guard let mzapreq = make_zap_request_event(keypair: keypair, content: content, relays: relays, target: target, zap_type: zap_type) else {
@@ -232,7 +232,7 @@ func send_zap(damus_state: DamusState, target: ZapTarget, lnurl: String, is_cust
                flusher = .once({ pe in
                    // send donation zap when the pending zap is flushed, this allows user to cancel and not send a donation
                    Task { @MainActor in
-                        await damus_state.nostrNetwork.send_donation_zap(nwc: nwc_state.url, percent: damus_state.settings.donation_percent, base_msats: amount_msat)
+                        await WalletConnect.send_donation_zap(pool: damus_state.nostrNetwork.pool, postbox: damus_state.nostrNetwork.postbox, nwc: nwc_state.url, percent: damus_state.settings.donation_percent, base_msats: amount_msat)
                    }
                })
            }
@@ -240,7 +240,7 @@ func send_zap(damus_state: DamusState, target: ZapTarget, lnurl: String, is_cust
            // we don't have a delay on one-tap nozaps (since this will be from customize zap view)
            let delay = damus_state.settings.nozaps ? nil : 5.0

-            let nwc_req = await damus_state.nostrNetwork.nwcPay(url: nwc_state.url, post: damus_state.nostrNetwork.postbox, invoice: inv, delay: delay, on_flush: flusher)
+            let nwc_req = WalletConnect.pay(url: nwc_state.url, pool: damus_state.nostrNetwork.pool, post: damus_state.nostrNetwork.postbox, invoice: inv, zap_request: zapreq, delay: delay, on_flush: flusher)

            guard let nwc_req, case .nwc(let pzap_state) = pending_zap_state else {
                print("nwc: failed to send nwc request for zapreq \(reqid.reqid)")
@@ -276,7 +276,7 @@ enum CancelZapErr {
    case not_nwc
 }

-func cancel_zap(zap: PendingZap, box: PostBox, zapcache: Zaps, evcache: EventCache) async -> CancelZapErr? {
+func cancel_zap(zap: PendingZap, box: PostBox, zapcache: Zaps, evcache: EventCache) -> CancelZapErr? {
    guard case .nwc(let nwc_state) = zap.state else {
        return .not_nwc
    }
@@ -298,7 +298,7 @@ func cancel_zap(zap: PendingZap, box: PostBox, zapcache: Zaps, evcache: EventCac
        return .already_confirmed
        
    case .postbox_pending(let nwc_req):
-        if let err = await box.cancel_send(evid: nwc_req.id) {
+        if let err = box.cancel_send(evid: nwc_req.id) {
            return .send_err(err)
        }
        let reqid = ZapRequestId(from_pending: zap)
--- a/damus/Features/Actions/Reposts/Views/Reposted.swift
+++ b/damus/Features/Actions/Reposts/Views/Reposted.swift
@@ -27,7 +27,7 @@ struct Reposted: View {

            // 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, damusState: damus)
+                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)
                    }
--- a/damus/Features/Search/Views/SearchHeaderView.swift
+++ b/damus/Features/Search/Views/SearchHeaderView.swift
@@ -125,7 +125,7 @@ struct HashtagUnfollowButton: View {
        
    func unfollow(_ hashtag: String) {
        is_following = false
-        Task { await handle_unfollow(state: damus_state, unfollow: FollowRef.hashtag(hashtag)) }
+        handle_unfollow(state: damus_state, unfollow: FollowRef.hashtag(hashtag))
    }
 }

@@ -144,7 +144,7 @@ struct HashtagFollowButton: View {
    
    func follow(_ hashtag: String) {
        is_following = true
-        Task { await handle_follow(state: damus_state, follow: .hashtag(hashtag)) }
+        handle_follow(state: damus_state, follow: .hashtag(hashtag))
    }
 }

--- a/damus/Shared/Components/Text/SelectableText.swift
+++ b/damus/Shared/Components/Text/SelectableText.swift
--- a/damus/Shared/Components/Shimmer.swift
+++ b/damus/Shared/Components/Shimmer.swift
--- a/damus/Features/Status/Models/Music/MusicController.swift
+++ b/damus/Features/Status/Models/Music/MusicController.swift
--- a/damus/Features/Status/Models/UserStatus.swift
+++ b/damus/Features/Status/Models/UserStatus.swift
--- a/damus/Features/Status/Views/UserStatusSheet.swift
+++ b/damus/Features/Status/Views/UserStatusSheet.swift
@@ -109,18 +109,16 @@ struct UserStatusSheet: View {
                    Spacer()
                    
                    Button(action: {
-                        Task {
-                            guard let status = self.status.general,
-                                  let kp = keypair.to_full(),
-                                  let ev = make_user_status_note(status: status, keypair: kp, expiry: duration.expiration)
-                            else {
-                                return
-                            }
-                            
-                            await postbox.send(ev)
-                            
-                            dismiss()
+                        guard let status = self.status.general,
+                              let kp = keypair.to_full(),
+                              let ev = make_user_status_note(status: status, keypair: kp, expiry: duration.expiration)
+                        else {
+                            return
                        }
+                        
+                        postbox.send(ev)
+                        
+                        dismiss()
                    }, label: {
                        Text("Share", comment: "Save button text for saving profile status settings.")
                    })
@@ -131,7 +129,7 @@ struct UserStatusSheet: View {
                Divider()
                
                ZStack(alignment: .top) {
-                    ProfilePicView(pubkey: keypair.pubkey, size: 120.0, highlight: .custom(DamusColors.white, 3.0), profiles: damus_state.profiles, disable_animation: damus_state.settings.disable_animation, damusState: damus_state)
+                    ProfilePicView(pubkey: keypair.pubkey, size: 120.0, highlight: .custom(DamusColors.white, 3.0), profiles: damus_state.profiles, disable_animation: damus_state.settings.disable_animation)
                        .padding(.top, 30)
                    
                    VStack(spacing: 0) {
--- a/damus/Features/Status/Views/UserStatusView.swift
+++ b/damus/Features/Status/Views/UserStatusView.swift
--- a/damus/Shared/Components/SupporterBadge.swift
+++ b/damus/Shared/Components/SupporterBadge.swift
--- a/Show More
+++ b/Show More