Relay hints: nprofile parsing, hint routing, NIP-10 author pubkeys by alltheseas · Pull Request #1234 · damus-io/notedeck

alltheseas · 2026-01-02T01:58:33Z

Summary

Rebased and simplified relay hints against the post-outbox master. Down from ~1,030 lines across 9 files to ~270 lines across 6 files by dropping dead RelayPool code and leveraging the existing outbox infrastructure.

nprofile parsing with relay hints — ParsedNprofile struct preserves relay hints from NIP-19 nprofile bech32 strings (nostr crate first, manual TLV fallback for robustness)
Hint-based routing — unknown_id_send() partitions IDs into hinted vs unhinted, routing hinted IDs to their hint relays via oneshot_to_relays() and unhinted to account read relays. No new state or retry logic; existing 2s debouncer handles retries naturally.
NIP-10 author pubkeys — Add author pubkey as 5th element in e-tags (root + reply) and q-tags per NIP-10 spec

Commits

enostr: add ParsedNprofile and nprofile parsing with relay hints — pubkey.rs, lib.rs
notedeck: route unknown ID lookups to relay hints — oneshot_api.rs, unknowns.rs
post: add NIP-10 author pubkey to reply and quote tags — post.rs, CHANGELOG.md

Each commit compiles independently.

What changed from the original PR

Original	New
`RelayPool::subscribe_to` / relay_status / canonicalize	Dropped — RelayPool no longer does subscriptions
Grace period / timeout / retry state machine	Dropped — existing 2s debouncer handles retry
`app.rs` hook points	Dropped — no timeout logic needed
`post.rs` relay_hint parameter in `to_quote()`	Dropped — nostrdb doesn't expose source relay
pool.rs tests	Dropped — tested dead code

Known limitations

Outgoing relay hints in e-tags use "" because nostrdb doesn't expose which relay delivered a note. A nostrdb change (storing source relay per note) would enable this.
Root e-tag uses replying_to.pubkey() rather than root author's pubkey, since root author isn't available without an extra DB lookup.

Test plan

cargo test -p enostr — ParsedNprofile + nprofile parsing tests pass
cargo test -p notedeck — oneshot_api + unknowns tests pass
cargo test -p notedeck_columns — post.rs tests pass
cargo clippy -D warnings — clean across all 3 crates
cargo build — full build compiles clean
Each commit compiles independently

kernelkind · 2026-01-05T16:34:59Z

I'm working on an outbox pool which will solve alot of the same things, but in a more unified way. I think there is some code that could be useful here. Let's revisit after i finish

coderabbitai · 2026-01-06T06:41:12Z

📝 Walkthrough

Walkthrough

Adds nprofile (NIP-19) parsing with relay-hint extraction, exposes ParsedNprofile, and routes unknown-ID lookups to hinted relays when available; also augments reply and quote tag construction to include author pubkey references.

Changes

Cohort / File(s)	Summary
NIP-19 parsing & export `crates/enostr/src/pubkey.rs`, `crates/enostr/src/lib.rs`, `CHANGELOG.md`	Introduce `ParsedNprofile` (pubkey + relay hints), implement `try_from_nprofile_string`, manual TLV fallback parsing, and `parse_with_relays`; re-export `ParsedNprofile` from `lib.rs`; document in changelog.
Unknown-ID routing / oneshot API `crates/notedeck/src/unknowns.rs`, `crates/notedeck/src/oneshot_api.rs`	Split unknown IDs into hinted vs unhinted groups, compute normalized hint relays and route hinted IDs via new `OneshotApi::oneshot_to_relays(filters, relay_urls)`; unhinted IDs use existing oneshot path.
Reply & quote tag updates `crates/notedeck_columns/src/post.rs`	Insert additional e/p tags containing the author pubkey in reply and quote construction flows per NIP-10/NIP-23 tag conventions.

Sequence Diagram(s)

sequenceDiagram
    participant User as User/Publisher
    participant API as OneshotApi
    participant Parser as ParsedNprofile Parser
    participant Pool as RelayPool
    participant HR as Hint Relays
    participant DR as Default Relays

    rect rgba(100, 200, 150, 0.5)
        Note over User,DR: Existing flow (unhinted)
        User->>API: oneshot(filters)
        API->>Pool: RelayUrlPkgs(selected_read_relays)
        Pool->>DR: send filters
        DR-->>User: responses
    end

    rect rgba(150, 150, 200, 0.5)
        Note over User,HR: New flow (hinted)
        User->>API: unknown_id_send(ids)
        API->>Parser: parse ids → ParsedNprofile (pubkey + relays)
        Parser-->>API: relay hints (optional)
        alt Hinted IDs
            API->>Pool: oneshot_to_relays(filters, hint_relays)
            Pool->>HR: send filters
            HR-->>User: responses
        end
        alt Unhinted IDs
            API->>Pool: oneshot(filters)
            Pool->>DR: send filters
            DR-->>User: responses
        end
    end

Estimated code review effort

🎯 4 (Complex) | ⏱️ ~45 minutes

Poem

🐰 I nibble at nprofile strings,

sniff out relays where the hint bell rings,
I route the lost to their nearest lair,
tuck author keys in tags with care,
and hop away, delighted to share.

🚥 Pre-merge checks | ✅ 3

✅ Passed checks (3 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title 'Relay hints NIP-10/NIP-19' is highly specific and directly summarizes the main feature addition—implementing relay hint infrastructure following NIP-10 and NIP-19 specifications across multiple modules.
Docstring Coverage	✅ Passed	Docstring coverage is 100.00% which is sufficient. The required threshold is 80.00%.

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

✨ Finishing Touches

🧪 Generate unit tests (beta)

Create PR with unit tests
Post copyable unit tests in a comment

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

coderabbitai

Actionable comments posted: 0

🧹 Nitpick comments (4)

crates/enostr/src/relay/pool.rs (2)
184-190: Redundant normalization in relay_status inner loop.

The pool URLs are already canonicalized via add_url, but relay_status re-canonicalizes each pool relay URL on every lookup. This creates O(n) allocations per call.
🔎 Proposed optimization
     pub fn relay_status(&self, url: &str) -> Option<RelayStatus> {
         let normalized = Self::canonicalize_url(url.to_string());
         self.relays
             .iter()
-            .find(|r| Self::canonicalize_url(r.url().to_string()) == normalized)
+            .find(|r| r.url() == normalized)
             .map(|r| r.status())
     }
325-335: Consider logging when hint relays are skipped.

When subscribe_to silently skips relays not in the pool, debugging hint routing issues becomes difficult. A trace log would help operators understand why hints aren't being used.
🔎 Proposed enhancement
         for relay in &mut self.relays {
             // Pool URLs are already canonicalized via add_url
             if !urls.contains(relay.url()) {
+                tracing::trace!("subscribe_to: skipping relay {} (not in target set)", relay.url());
                 continue;
             }
crates/notedeck_columns/src/post.rs (1)

1373-1439: Good test coverage for NIP-10 relay hints.

The tests properly verify the e-tag and q-tag structure including relay hints and author pubkeys. The test at line 1548 documents that passing None results in an empty string relay hint.

Consider adding a test case for replies within an existing thread (where a root tag already exists) to verify the root e-tag relay hint extraction works correctly.
crates/notedeck/src/unknowns.rs (1)
173-199: Consider avoiding clone in the hot path.

Line 183 clones the HashSet<RelayUrl> for each ready ID. While this works correctly, if there are many IDs with large hint sets, this could cause allocation overhead.
🔎 Suggested optimization using drain or swap
     pub fn check_grace_period_timeouts(&mut self) -> Vec<(UnknownId, HashSet<RelayUrl>)> {
         if self.grace_period_ids.is_empty() {
             return Vec::new();
         }

         let now = Instant::now();
-        let ready: Vec<_> = self
-            .grace_period_ids
-            .iter()
-            .filter(|(_, (_, added_at))| now.duration_since(*added_at) >= GRACE_PERIOD_TIMEOUT)
-            .map(|(id, (hints, _))| (*id, hints.clone()))
-            .collect();
-
-        // Remove ready IDs from grace period tracking
-        for (id, _) in &ready {
-            self.grace_period_ids.remove(id);
-        }
+        let ready_keys: Vec<_> = self
+            .grace_period_ids
+            .iter()
+            .filter(|(_, (_, added_at))| now.duration_since(*added_at) >= GRACE_PERIOD_TIMEOUT)
+            .map(|(id, _)| *id)
+            .collect();
+
+        let ready: Vec<_> = ready_keys
+            .into_iter()
+            .filter_map(|id| self.grace_period_ids.remove(&id).map(|(hints, _)| (id, hints)))
+            .collect();

         if !ready.is_empty() {

📜 Review details

Configuration used: defaults

Review profile: CHILL

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between db87775 and 5d9acf1.

📒 Files selected for processing (9)

CHANGELOG.md
crates/enostr/src/lib.rs
crates/enostr/src/pubkey.rs
crates/enostr/src/relay/pool.rs
crates/notedeck/src/app.rs
crates/notedeck/src/unknowns.rs
crates/notedeck_columns/src/post.rs
crates/notedeck_columns/src/repost.rs
crates/notedeck_columns/src/ui/note/post.rs

🧰 Additional context used

📓 Path-based instructions (2)

crates/notedeck*/src/**/*.rs

📄 CodeRabbit inference engine (AGENTS.md)

crates/notedeck*/src/**/*.rs: Use AppContext to access mutable handles to services (database, caches, relay pool, account state, localization, settings, wallet) rather than accessing global state
Never use Mutexes in UI paths; the render loop must never block. Use Rc<RefCell<>> for single-threaded interior mutability, Arc<tokio::sync::RwLock<>> for cross-thread sharing, and poll_promise::Promise for async results
Wrap async work in poll_promise::Promise, check with promise.ready() or promise.ready_mut() each frame—never block the render loop
Use tokio::sync::RwLock instead of Arc<Mutex<>> for cross-thread sharing in Notedeck
Persist state via TimedSerializer::try_save to avoid blocking the frame; batch mutations with SettingsHandler::update_batch
Wrap user-facing strings with tr! or tr_plural! macros for localization and run python3 scripts/export_source_strings.py after changing strings
Use JobPool for CPU-bound work and return results via tokio::sync::oneshot wrapped in Promises; use tokio::spawn() for network I/O and relay sync
Mark performance-critical functions with #[profiling::function] for visibility in the puffin profiler
Use tracing macros for structured logging and profiling scopes where hot paths exist
Prefer 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 (Nevernesting principle)
Global variables are not allowed in this codebase, even if they are thread local; state should be managed in a struct that is passed in as reference
Ensure docstring coverage for any code added or modified
Avoid Mutexes in Notedeck code; prefer poll_promise::Promise for async results, Rc<RefCell<>> for single-threaded interior mutability, or tokio::sync::RwLock when cross-thread sharing is truly necessary
Never block the render loop; use Promise::ready() for non-blocking result checks. Offload CPU-heavy work to...

Files:

crates/notedeck_columns/src/ui/note/post.rs
crates/notedeck/src/app.rs
crates/notedeck_columns/src/post.rs
crates/notedeck_columns/src/repost.rs
crates/notedeck/src/unknowns.rs

crates/notedeck*/src/app.rs

📄 CodeRabbit inference engine (AGENTS.md)

Implement the App trait with update(&mut self, &mut AppContext, &mut egui::Ui) -> AppResponse to drive egui rendering and signal high-level actions

Files:

crates/notedeck/src/app.rs

🧠 Learnings (9)