lib

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

decode.rs (2260B)

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