lib

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

decode.rs (2809B)

      1 use radroots_events::{
      2     RadrootsNostrEvent,
      3     job_request::{RadrootsJobInput, RadrootsJobParam, RadrootsJobRequest},
      4     kinds::is_request_kind,
      5 };
      6 
      7 #[cfg(not(feature = "std"))]
      8 use alloc::{string::String, vec::Vec};
      9 
     10 use crate::job::{
     11     error::JobParseError,
     12     util::{parse_bid_tag_sat, parse_bool_encrypted, parse_i_tags, parse_params},
     13 };
     14 use crate::parsed::{RadrootsParsedData, RadrootsParsedEvent};
     15 
     16 pub fn job_request_from_tags(
     17     kind: u32,
     18     tags: &[Vec<String>],
     19 ) -> Result<RadrootsJobRequest, JobParseError> {
     20     let inputs: Vec<RadrootsJobInput> = parse_i_tags(tags);
     21 
     22     let output = tags
     23         .iter()
     24         .find(|t| t.first().map(|s| s.as_str()) == Some("output"))
     25         .and_then(|t| t.get(1).cloned());
     26 
     27     let params: Vec<RadrootsJobParam> = parse_params(tags);
     28 
     29     let bid_sat = parse_bid_tag_sat(tags)?;
     30 
     31     let relays = tags
     32         .iter()
     33         .filter(|t| t.first().map(|s| s.as_str()) == Some("relays"))
     34         .filter_map(|t| t.get(1).cloned())
     35         .collect::<Vec<_>>();
     36 
     37     let providers = tags
     38         .iter()
     39         .filter(|t| t.first().map(|s| s.as_str()) == Some("p"))
     40         .filter_map(|t| t.get(1).cloned())
     41         .collect::<Vec<_>>();
     42 
     43     let topics = tags
     44         .iter()
     45         .filter(|t| t.first().map(|s| s.as_str()) == Some("t"))
     46         .filter_map(|t| t.get(1).cloned())
     47         .collect::<Vec<_>>();
     48 
     49     let encrypted = parse_bool_encrypted(tags);
     50 
     51     if encrypted && providers.is_empty() {
     52         return Err(JobParseError::MissingTag("p"));
     53     }
     54 
     55     Ok(RadrootsJobRequest {
     56         kind: kind as u16,
     57         inputs,
     58         output,
     59         params,
     60         bid_sat,
     61         relays,
     62         providers,
     63         topics,
     64         encrypted,
     65     })
     66 }
     67 
     68 pub fn data_from_event(
     69     id: String,
     70     author: String,
     71     published_at: u32,
     72     kind: u32,
     73     tags: Vec<Vec<String>>,
     74 ) -> Result<RadrootsParsedData<RadrootsJobRequest>, JobParseError> {
     75     if !is_request_kind(kind) {
     76         return Err(JobParseError::InvalidTag("kind (expected 5000-5999)"));
     77     }
     78     let job_request = job_request_from_tags(kind, &tags)?;
     79     Ok(RadrootsParsedData::new(
     80         id,
     81         author,
     82         published_at,
     83         kind,
     84         job_request,
     85     ))
     86 }
     87 
     88 pub fn parsed_from_event(
     89     id: String,
     90     author: String,
     91     published_at: u32,
     92     kind: u32,
     93     content: String,
     94     tags: Vec<Vec<String>>,
     95     sig: String,
     96 ) -> Result<RadrootsParsedEvent<RadrootsJobRequest>, JobParseError> {
     97     let data = data_from_event(id.clone(), author.clone(), published_at, kind, tags.clone())?;
     98     Ok(RadrootsParsedEvent {
     99         event: RadrootsNostrEvent {
    100             id,
    101             author,
    102             created_at: published_at,
    103             kind,
    104             content,
    105             tags,
    106             sig,
    107         },
    108         data,
    109     })
    110 }