use alloc::string::{String, ToString};
use alloc::vec::Vec;
use crate::{Coordinate, Event, EventBuilder, EventId, Kind, PublicKey, RelayUrl, Tag, Tags};
use crate::nips::nip19::{AddressPointer, EventPointer, ProfilePointer};
#[non_exhaustive]
#[derive(Debug, thiserror::Error)]
pub enum Error {
#[error("{0}")]
Validation(&'static str),
}
pub type Result<T, E = Error> = core::result::Result<T, E>;
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum Quote {
Event(EventPointer),
Address(AddressPointer),
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct ThreadReferences {
pub root: Option<EventPointer>,
pub reply: Option<EventPointer>,
pub mentions: Vec<EventPointer>,
pub quotes: Vec<Quote>,
pub profiles: Vec<ProfilePointer>,
}
fn is_hex32(value: &str) -> bool {
EventId::from_wire_hex(value).is_ok()
}
fn relay_slot(items: &[String], index: usize) -> Vec<String> {
match items.get(index) {
Some(value) if !value.is_empty() => alloc::vec![value.clone()],
_ => Vec::new(),
}
}
fn e_tag_author(items: &[String]) -> Option<PublicKey> {
for index in [4usize, 3] {
if let Some(author) = items.get(index)
&& let Ok(pubkey) = PublicKey::from_wire_hex(author)
{
return Some(pubkey);
}
}
None
}
fn event_pointer(items: &[String]) -> Option<EventPointer> {
let id = EventId::from_wire_hex(items.get(1)?).ok()?;
let mut pointer = EventPointer {
id,
relays: relay_slot(items, 2),
author: None,
kind: None,
};
pointer.author = e_tag_author(items);
Some(pointer)
}
fn quote_from_tag(items: &[String]) -> Option<Quote> {
let value = items.get(1)?;
if value.is_empty() {
return None;
}
let relays = relay_slot(items, 2);
if let Ok(id) = EventId::from_wire_hex(value) {
let author = items.get(3).and_then(|a| PublicKey::from_wire_hex(a).ok());
return Some(Quote::Event(EventPointer {
id,
relays,
author,
kind: None,
}));
}
let address = Coordinate::from_wire_str(value).ok()?;
Some(Quote::Address(AddressPointer {
identifier: String::from(address.identifier()),
pubkey: address.pubkey(),
kind: address.kind(),
relays,
}))
}
fn inherit_hints(mut ptr: EventPointer, profiles: &[ProfilePointer]) -> EventPointer {
let Some(author) = ptr.author else {
return ptr;
};
let Some(profile) = profiles.iter().find(|p| p.pubkey == author) else {
return ptr;
};
for url in &profile.relays {
if !ptr.relays.contains(url) {
ptr.relays.push(url.clone());
}
}
ptr
}
impl From<&Tags> for ThreadReferences {
fn from(tags: &Tags) -> Self {
parse_thread_tags(tags)
}
}
fn parse_thread_tags(tags: &Tags) -> ThreadReferences {
let mut mentions = Vec::new();
let mut quotes = Vec::new();
let mut profiles = Vec::new();
let mut root: Option<EventPointer> = None;
let mut reply: Option<EventPointer> = None;
let mut maybe_parent: Option<EventPointer> = None;
let mut maybe_root: Option<EventPointer> = None;
for tag in tags.iter().rev() {
let items = tag.as_slice();
let value = items.get(1);
if tag.name() == "e" && value.is_some_and(|v| is_hex32(v)) {
let Some(pointer) = event_pointer(items) else {
continue;
};
let marker = items.get(3).map(String::as_str);
if marker == Some("root") {
root = Some(pointer);
continue;
}
if marker == Some("reply") {
reply = Some(pointer);
continue;
}
if let Some(marker) = marker
&& !marker.is_empty()
&& !is_hex32(marker)
{
mentions.push(pointer);
continue;
}
if maybe_parent.is_some() {
maybe_root = Some(pointer.clone());
} else {
maybe_parent = Some(pointer.clone());
}
mentions.push(pointer);
continue;
}
if tag.name() == "q" {
if let Some(quote) = quote_from_tag(items) {
quotes.push(quote);
}
continue;
}
if tag.name() == "p"
&& let Some(p_value) = value
&& let Ok(pubkey) = PublicKey::from_wire_hex(p_value)
{
profiles.push(ProfilePointer {
pubkey,
relays: relay_slot(items, 2),
});
}
}
let root = root
.or(maybe_root)
.or_else(|| maybe_parent.clone())
.or_else(|| reply.clone());
let reply = reply.or(maybe_parent).or_else(|| root.clone());
let drop: Vec<EventId> = [root.as_ref(), reply.as_ref()]
.into_iter()
.flatten()
.map(|p| p.id)
.collect();
mentions.retain(|m| !drop.contains(&m.id));
ThreadReferences {
root: root.map(|r| inherit_hints(r, &profiles)),
reply: reply.map(|r| inherit_hints(r, &profiles)),
mentions: mentions
.into_iter()
.map(|m| inherit_hints(m, &profiles))
.collect(),
quotes,
profiles,
}
}
fn push_positions(items: &mut Vec<String>, positions: &[Option<String>]) {
let end = positions
.iter()
.rposition(Option::is_some)
.map_or(0, |i| i + 1);
for position in positions.iter().take(end) {
items.push(position.clone().unwrap_or_default());
}
}
fn e_tag(
id: EventId,
relay: Option<String>,
marker: Option<&str>,
pubkey: Option<PublicKey>,
) -> Tag {
let mut items = alloc::vec![id.to_hex()];
push_positions(
&mut items,
&[
relay,
marker.map(String::from),
pubkey.map(PublicKey::to_hex),
],
);
Tag::custom("e", items)
}
fn p_tag(pubkey: PublicKey, relay: Option<String>) -> Tag {
let mut items = alloc::vec![pubkey.to_hex()];
push_positions(&mut items, &[relay]);
Tag::custom("p", items)
}
fn add_p_tag(
tags: &mut Vec<Tag>,
seen: &mut Vec<PublicKey>,
pubkey: PublicKey,
relay: Option<String>,
) {
if seen.contains(&pubkey) {
return;
}
seen.push(pubkey);
tags.push(p_tag(pubkey, relay));
}
struct BuiltQuote {
tag: Tag,
author: Option<PublicKey>,
relay: Option<String>,
}
fn quote_to_tag(quote: &Quote) -> BuiltQuote {
match quote {
Quote::Event(pointer) => {
let relay = pointer.relays.first().cloned();
match pointer.author {
Some(author) => BuiltQuote {
tag: Tag::custom(
"q",
[
pointer.id.to_hex(),
relay.clone().unwrap_or_default(),
author.to_hex(),
],
),
author: Some(author),
relay,
},
None => BuiltQuote {
tag: match &relay {
Some(relay) if !relay.is_empty() => {
Tag::custom("q", [pointer.id.to_hex(), relay.clone()])
}
_ => Tag::custom("q", [pointer.id.to_hex()]),
},
author: None,
relay,
},
}
}
Quote::Address(pointer) => {
let coordinate =
Coordinate::new(pointer.kind, pointer.pubkey, &pointer.identifier).to_string();
let relay = pointer.relays.first().cloned();
let tag = match &relay {
Some(relay) if !relay.is_empty() => Tag::custom("q", [coordinate, relay.clone()]),
_ => Tag::custom("q", [coordinate]),
};
BuiltQuote {
tag,
author: Some(pointer.pubkey),
relay,
}
}
}
}
pub(crate) fn reply_tags(
parent: &Event,
relay_hint: Option<&RelayUrl>,
quotes: &[Quote],
) -> Result<Tags> {
if parent.kind() != Kind::TEXT_NOTE {
return Err(Error::Validation("NIP-10 replyTo is for kind 1"));
}
let thread = parse_thread_tags(parent.tags());
let root = thread.root.unwrap_or_else(|| EventPointer {
id: parent.id(),
relays: Vec::new(),
author: Some(parent.pubkey()),
kind: None,
});
let parent_is_root = root.id == parent.id();
let mut tags = Vec::new();
let root_relay = root
.relays
.first()
.cloned()
.or_else(|| relay_hint.map(|url| String::from(url.as_str())))
.unwrap_or_default();
tags.push(e_tag(root.id, Some(root_relay), Some("root"), root.author));
if !parent_is_root {
tags.push(e_tag(
parent.id(),
Some(relay_hint.map_or_else(String::new, |url| String::from(url.as_str()))),
Some("reply"),
Some(parent.pubkey()),
));
}
let mut seen: Vec<PublicKey> = Vec::new();
if let Some(author) = root.author {
add_p_tag(&mut tags, &mut seen, author, root.relays.first().cloned());
}
add_p_tag(
&mut tags,
&mut seen,
parent.pubkey(),
relay_hint.map(|url| String::from(url.as_str())),
);
for profile in &thread.profiles {
add_p_tag(
&mut tags,
&mut seen,
profile.pubkey,
profile.relays.first().cloned(),
);
}
let mut q_tags = Vec::new();
for quote in quotes {
let built = quote_to_tag(quote);
if let Some(author) = built.author {
add_p_tag(&mut tags, &mut seen, author, built.relay.clone());
}
q_tags.push(built.tag);
}
tags.extend(q_tags);
Ok(tags.into_iter().collect())
}
impl EventBuilder {
pub fn text_reply(
parent: &Event,
content: &str,
relay_hint: Option<&RelayUrl>,
quotes: &[Quote],
) -> Result<Self> {
Ok(Self::text_note(content).tags(reply_tags(parent, relay_hint, quotes)?))
}
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, reason = "tests fail by panicking")]
use alloc::borrow::ToOwned;
use alloc::string::ToString;
use crate::{SecretKey, Timestamp};
use super::*;
const PK1: &str = "166bf3765ebd1fc55decfe395beff2ea3b2a4e0a8946e7eb578512b555737c99";
const PK2: &str = "3550510ffb21f7663873ebf343d701d871b958743cf78ff6c151fe03125e5858";
const ID1: &str = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
const ID2: &str = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
fn id(hex: &str) -> EventId {
EventId::from_hex(hex).unwrap()
}
fn pk(hex: &str) -> PublicKey {
PublicKey::from_hex(hex).unwrap()
}
fn tags(raw: &[&[&str]]) -> Tags {
raw.iter()
.map(|items| Tag::new(items.iter().map(|s| String::from(*s))).unwrap())
.collect()
}
fn note(raw: &[&[&str]], kind: u16) -> Event {
let keys = crate::Keys::new(
SecretKey::from_hex("e108399bd8424357a710b606ae0c13166d853d327e47a6e5e038197346bdbf45")
.unwrap(),
);
let unsigned = crate::UnsignedEvent::new(
keys.public_key(),
Timestamp::from_secs(1_700_000_000),
Kind::new(kind),
tags(raw),
"n",
);
crate::testutil::sign_with_aux(&keys, unsigned, [7u8; 32])
}
#[test]
fn positional_parent_and_root() {
let thread = parse_thread_tags(&tags(&[&["e", ID1], &["e", ID2]]));
assert_eq!(thread.root.map(|r| r.id), Some(id(ID1)));
assert_eq!(thread.reply.map(|r| r.id), Some(id(ID2)));
assert_eq!(thread.mentions.len(), 0);
}
#[test]
fn hex_at_marker_slot_is_a_nip01_author() {
let thread = parse_thread_tags(&tags(&[&["e", ID1, "wss://r", PK1]]));
let root = thread.root.unwrap();
assert_eq!(root.author, Some(pk(PK1)));
assert_eq!(thread.mentions.len(), 0);
}
#[test]
fn marked_reply_backfills_root() {
let thread = parse_thread_tags(&tags(&[&["e", ID1, "", "reply"]]));
assert_eq!(thread.root.map(|r| r.id), Some(id(ID1)));
assert_eq!(thread.reply.map(|r| r.id), Some(id(ID1)));
}
#[test]
fn reply_tags_rejects_non_kind1() {
let parent = note(&[], 6);
let error = reply_tags(&parent, None, &[]).unwrap_err();
assert!(matches!(error, Error::Validation(_)));
assert_eq!(error.to_string(), "NIP-10 replyTo is for kind 1");
}
#[test]
fn reply_tags_root_parent_emits_one_e_tag() {
let parent = note(&[], 1);
let out = reply_tags(&parent, None, &[]).unwrap();
let slices: Vec<Vec<String>> = out.iter().map(|t| t.as_slice().to_vec()).collect();
let parent_id = parent.id().to_hex();
let parent_pk = parent.pubkey().to_hex();
assert_eq!(
slices,
alloc::vec![
alloc::vec![
"e".to_owned(),
parent_id,
String::new(),
"root".to_owned(),
parent_pk.clone()
],
alloc::vec!["p".to_owned(), parent_pk],
]
);
}
#[test]
fn quote_address_writes_coordinate_and_author_p() {
let parent = note(&[], 1);
let quote = Quote::Address(AddressPointer {
identifier: "post".into(),
pubkey: pk(PK2),
kind: Kind::new(30023),
relays: alloc::vec!["wss://a.example".to_owned()],
});
let out = reply_tags(&parent, None, &[quote]).unwrap();
let slices: Vec<Vec<String>> = out.iter().map(|t| t.as_slice().to_vec()).collect();
assert!(slices.contains(&alloc::vec![
"q".to_owned(),
alloc::format!("30023:{PK2}:post"),
"wss://a.example".to_owned()
]));
assert!(slices.contains(&alloc::vec![
"p".to_owned(),
PK2.to_owned(),
"wss://a.example".to_owned()
]));
}
}