lib

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

decode.rs (2079B)


      1 #[cfg(not(feature = "std"))]
      2 use alloc::{string::String, vec::Vec};
      3 
      4 use radroots_event::{
      5     social::http_auth::{HttpAuth, KIND_HTTP_AUTH},
      6     tag::name::{TAG_METHOD, TAG_PAYLOAD, TAG_URL_AUTH},
      7 };
      8 
      9 use crate::error::EventParseError;
     10 use crate::field_helpers::{
     11     optional_unique_tag_value, require_empty_content, required_unique_tag_value,
     12     validate_lowercase_hex_64_tag,
     13 };
     14 use crate::parsed::{RadrootsParsedData, RadrootsParsedEvent};
     15 
     16 const EXPECTED_KIND: &str = "27235";
     17 
     18 pub fn http_auth_from_event(
     19     kind: u32,
     20     tags: &[Vec<String>],
     21     content: &str,
     22 ) -> Result<HttpAuth, EventParseError> {
     23     if kind != KIND_HTTP_AUTH {
     24         return Err(EventParseError::InvalidKind {
     25             expected: EXPECTED_KIND,
     26             got: kind,
     27         });
     28     }
     29     require_empty_content(content, "content")?;
     30     let payload_sha256 = optional_unique_tag_value(tags, TAG_PAYLOAD)?;
     31     if let Some(payload) = payload_sha256.as_deref() {
     32         validate_lowercase_hex_64_tag(payload, TAG_PAYLOAD)?;
     33     }
     34     Ok(HttpAuth {
     35         url: required_unique_tag_value(tags, TAG_URL_AUTH)?,
     36         method: required_unique_tag_value(tags, TAG_METHOD)?,
     37         payload_sha256,
     38     })
     39 }
     40 
     41 pub fn data_from_event(
     42     id: String,
     43     author: String,
     44     published_at: u64,
     45     kind: u32,
     46     content: String,
     47     tags: Vec<Vec<String>>,
     48 ) -> Result<RadrootsParsedData<HttpAuth>, EventParseError> {
     49     let auth = http_auth_from_event(kind, &tags, &content)?;
     50     Ok(RadrootsParsedData::new(
     51         id,
     52         author,
     53         published_at,
     54         kind,
     55         auth,
     56     ))
     57 }
     58 
     59 pub fn parsed_from_event(
     60     id: String,
     61     author: String,
     62     published_at: u64,
     63     kind: u32,
     64     content: String,
     65     tags: Vec<Vec<String>>,
     66     sig: String,
     67 ) -> Result<RadrootsParsedEvent<HttpAuth>, EventParseError> {
     68     let data = data_from_event(
     69         id.clone(),
     70         author.clone(),
     71         published_at,
     72         kind,
     73         content.clone(),
     74         tags.clone(),
     75     )?;
     76     RadrootsParsedEvent::from_event_parts(id, author, published_at, kind, content, tags, sig, data)
     77 }