lib

event_ref.rs (5788B)

---

 #[cfg(not(feature = "std"))]
 use alloc::{
     string::{String, ToString},
     vec,
     vec::Vec,
 };
 
 use radroots_event::{
     id::{DTag, EventId, RelayUrl},
     tag::EventRef,
 };
 use radroots_identity::PublicKey;
 
 use crate::error::EventParseError;
 
 pub fn build_event_ref_tag(tag: &str, event: &EventRef) -> Vec<String> {
     let relays_len = event.relays.as_ref().map(|r| r.len()).unwrap_or(0);
     let mut out = Vec::with_capacity(5 + relays_len);
     out.push(tag.to_string());
     out.push(event.id.clone());
     out.push(event.author.to_hex());
     out.push(event.kind.to_string());
     out.push(event.d_tag.clone().unwrap_or_default());
     if let Some(relays) = &event.relays {
         out.extend(relays.iter().cloned());
     }
     out
 }
 
 pub fn parse_event_ref_tag(
     tag: &[String],
     tag_name: &'static str,
 ) -> Result<EventRef, EventParseError> {
     if tag.first().map(|s| s.as_str()) != Some(tag_name) {
         return Err(EventParseError::InvalidTag(tag_name));
     }
     if tag.len() < 5 {
         return Err(EventParseError::InvalidTag(tag_name));
     }
     let id = &tag[1];
     EventId::parse(id).map_err(|_| EventParseError::InvalidTag(tag_name))?;
     let author = &tag[2];
     let author = PublicKey::from_hex(author).map_err(|_| EventParseError::InvalidTag(tag_name))?;
     let kind_s = &tag[3];
     let kind: u32 = kind_s
         .parse()
         .map_err(|e| EventParseError::InvalidNumber(tag_name, e))?;
 
     let d_tag_value = &tag[4];
     let d_tag = if d_tag_value.is_empty() {
         None
     } else {
         if RelayUrl::parse(d_tag_value).is_ok() {
             return Err(EventParseError::InvalidTag(tag_name));
         }
         DTag::parse(d_tag_value).map_err(|_| EventParseError::InvalidTag(tag_name))?;
         Some(d_tag_value.clone())
     };
 
     let relays = if tag.len() > 5 {
         for relay in &tag[5..] {
             RelayUrl::parse(relay).map_err(|_| EventParseError::InvalidTag(tag_name))?;
         }
         Some(tag[5..].to_vec())
     } else {
         None
     };
 
     Ok(EventRef {
         id: id.clone(),
         author,
         kind,
         d_tag,
         relays,
     })
 }
 
 pub fn find_event_ref_tag<'a>(
     tags: &'a [Vec<String>],
     tag_name: &'static str,
 ) -> Option<&'a Vec<String>> {
     tags.iter()
         .find(|t| t.first().map(|s| s.as_str()) == Some(tag_name))
 }
 
 pub fn push_nip10_ref_tags(
     tags: &mut Vec<Vec<String>>,
     event: &EventRef,
     tag_e: &'static str,
     tag_p: &'static str,
     tag_k: &'static str,
     tag_a: &'static str,
 ) {
     let relays_len = event.relays.as_ref().map(|r| r.len()).unwrap_or(0);
     let kind_str = event.kind.to_string();
 
     let mut e_tag = Vec::with_capacity(2 + relays_len);
     e_tag.push(tag_e.to_string());
     e_tag.push(event.id.clone());
     if let Some(relays) = &event.relays {
         e_tag.extend(relays.iter().cloned());
     }
     tags.push(e_tag);
 
     let author = event.author.to_hex();
     let p_tag = vec![tag_p.to_string(), author.clone()];
     tags.push(p_tag);
 
     let k_tag = vec![tag_k.to_string(), kind_str.clone()];
     tags.push(k_tag);
 
     if let Some(d_tag) = event.d_tag.as_deref().filter(|v| !v.is_empty()) {
         let mut addr = String::with_capacity(kind_str.len() + author.len() + d_tag.len() + 2);
         addr.push_str(&kind_str);
         addr.push(':');
         addr.push_str(&author);
         addr.push(':');
         addr.push_str(d_tag);
 
         let mut a_tag = Vec::with_capacity(2 + relays_len);
         a_tag.push(tag_a.to_string());
         a_tag.push(addr);
         if let Some(relays) = &event.relays {
             a_tag.extend(relays.iter().cloned());
         }
         tags.push(a_tag);
     }
 }
 
 pub fn parse_nip10_ref_tags(
     tags: &[Vec<String>],
     tag_e: &'static str,
     tag_p: &'static str,
     tag_k: &'static str,
     tag_a: &'static str,
 ) -> Result<EventRef, EventParseError> {
     let e_tag = find_event_ref_tag(tags, tag_e).ok_or(EventParseError::MissingTag(tag_e))?;
     let id = e_tag.get(1).ok_or(EventParseError::InvalidTag(tag_e))?;
     if id.trim().is_empty() {
         return Err(EventParseError::InvalidTag(tag_e));
     }
     let relays = if e_tag.len() > 2 {
         Some(e_tag[2..].to_vec())
     } else {
         None
     };
 
     let p_tag = find_event_ref_tag(tags, tag_p).ok_or(EventParseError::MissingTag(tag_p))?;
     let author = p_tag.get(1).ok_or(EventParseError::InvalidTag(tag_p))?;
     let author = PublicKey::from_hex(author).map_err(|_| EventParseError::InvalidTag(tag_p))?;
     let author_hex = author.to_hex();
 
     let k_tag = find_event_ref_tag(tags, tag_k).ok_or(EventParseError::MissingTag(tag_k))?;
     let kind_key = k_tag.get(1).ok_or(EventParseError::InvalidTag(tag_k))?;
     let kind: u32 = kind_key
         .parse()
         .map_err(|e| EventParseError::InvalidNumber(tag_k, e))?;
 
     let mut d_tag: Option<String> = None;
     let mut addr_relays: Option<Vec<String>> = None;
     for tag in tags
         .iter()
         .filter(|t| t.first().map(|s| s.as_str()) == Some(tag_a))
     {
         let value = match tag.get(1) {
             Some(v) => v,
             None => continue,
         };
         let mut parts = value.splitn(3, ':');
         let kind_part = parts.next();
         let author_part = parts.next();
         let d_part = parts.next();
         if kind_part != Some(kind_key.as_str()) || author_part != Some(author_hex.as_str()) {
             continue;
         }
         if let Some(d) = d_part
             && !d.is_empty()
         {
             d_tag = Some(d.to_string());
         }
         if tag.len() > 2 {
             addr_relays = Some(tag[2..].to_vec());
         }
         break;
     }
 
     let relays = relays.or(addr_relays);
 
     Ok(EventRef {
         id: id.clone(),
         author,
         kind,
         d_tag,
         relays,
     })
 }