lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README | LICENSE

decode.rs (2228B)

      1 #[cfg(not(feature = "std"))]
      2 use alloc::{
      3     string::{String, ToString},
      4     vec::Vec,
      5 };
      6 
      7 use radroots_events::{
      8     RadrootsNostrEvent,
      9     app_data::{KIND_APP_DATA, RadrootsAppData},
     10     tags::TAG_D,
     11 };
     12 
     13 use crate::error::EventParseError;
     14 use crate::parsed::{RadrootsParsedData, RadrootsParsedEvent};
     15 
     16 fn parse_d_tag(tags: &[Vec<String>]) -> Result<String, EventParseError> {
     17     let tag = tags
     18         .iter()
     19         .find(|t| t.first().map(|s| s.as_str()) == Some(TAG_D))
     20         .ok_or(EventParseError::MissingTag(TAG_D))?;
     21     let value = tag
     22         .get(1)
     23         .map(|s| s.to_string())
     24         .ok_or(EventParseError::InvalidTag(TAG_D))?;
     25     if value.trim().is_empty() {
     26         return Err(EventParseError::InvalidTag(TAG_D));
     27     }
     28     Ok(value)
     29 }
     30 
     31 pub fn app_data_from_tags(
     32     kind: u32,
     33     tags: &[Vec<String>],
     34     content: &str,
     35 ) -> Result<RadrootsAppData, EventParseError> {
     36     if kind != KIND_APP_DATA {
     37         return Err(EventParseError::InvalidKind {
     38             expected: "30078",
     39             got: kind,
     40         });
     41     }
     42     let d_tag = parse_d_tag(tags)?;
     43     Ok(RadrootsAppData {
     44         d_tag,
     45         content: content.to_string(),
     46     })
     47 }
     48 
     49 pub fn data_from_event(
     50     id: String,
     51     author: String,
     52     published_at: u32,
     53     kind: u32,
     54     content: String,
     55     tags: Vec<Vec<String>>,
     56 ) -> Result<RadrootsParsedData<RadrootsAppData>, EventParseError> {
     57     let app_data = app_data_from_tags(kind, &tags, &content)?;
     58     Ok(RadrootsParsedData::new(
     59         id,
     60         author,
     61         published_at,
     62         kind,
     63         app_data,
     64     ))
     65 }
     66 
     67 pub fn parsed_from_event(
     68     id: String,
     69     author: String,
     70     published_at: u32,
     71     kind: u32,
     72     content: String,
     73     tags: Vec<Vec<String>>,
     74     sig: String,
     75 ) -> Result<RadrootsParsedEvent<RadrootsAppData>, EventParseError> {
     76     let data = data_from_event(
     77         id.clone(),
     78         author.clone(),
     79         published_at,
     80         kind,
     81         content.clone(),
     82         tags.clone(),
     83     )?;
     84     Ok(RadrootsParsedEvent {
     85         event: RadrootsNostrEvent {
     86             id,
     87             author,
     88             created_at: published_at,
     89             kind,
     90             content,
     91             tags,
     92             sig,
     93         },
     94         data,
     95     })
     96 }