lib

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

decode.rs (2712B)

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