lib

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

decode.rs (2031B)


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