lib

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

codec_adapters.rs (2914B)

      1 extern crate alloc;
      2 use alloc::{string::String, vec::Vec};
      3 
      4 use crate::types::RadrootsNostrEvent;
      5 
      6 use crate::util::created_at_u32_saturating;
      7 use radroots_events::{
      8     job_feedback::RadrootsJobFeedback, job_request::RadrootsJobRequest,
      9     job_result::RadrootsJobResult,
     10 };
     11 use radroots_events_codec::job::{
     12     error::JobParseError, feedback::decode as fb_decode, request::decode as req_decode,
     13     result::decode as res_decode,
     14 };
     15 use radroots_events_codec::parsed::{RadrootsParsedData, RadrootsParsedEvent};
     16 
     17 fn event_id(e: &RadrootsNostrEvent) -> String {
     18     e.id.to_hex()
     19 }
     20 
     21 fn author(e: &RadrootsNostrEvent) -> String {
     22     e.pubkey.to_hex()
     23 }
     24 
     25 fn published_at(e: &RadrootsNostrEvent) -> u32 {
     26     created_at_u32_saturating(e.created_at)
     27 }
     28 
     29 fn kind_u32(e: &RadrootsNostrEvent) -> u32 {
     30     e.kind.as_u16() as u32
     31 }
     32 
     33 fn content(e: &RadrootsNostrEvent) -> String {
     34     e.content.clone()
     35 }
     36 
     37 fn tags_vec(e: &RadrootsNostrEvent) -> Vec<Vec<String>> {
     38     e.tags.iter().map(|t| t.as_slice().to_vec()).collect()
     39 }
     40 
     41 fn sig_hex(e: &RadrootsNostrEvent) -> String {
     42     e.sig.to_string()
     43 }
     44 
     45 pub fn to_job_request_metadata(
     46     e: &RadrootsNostrEvent,
     47 ) -> Result<RadrootsParsedData<RadrootsJobRequest>, JobParseError> {
     48     req_decode::data_from_event(
     49         event_id(e),
     50         author(e),
     51         published_at(e),
     52         kind_u32(e),
     53         tags_vec(e),
     54     )
     55 }
     56 
     57 pub fn to_job_result_metadata(
     58     e: &RadrootsNostrEvent,
     59 ) -> Result<RadrootsParsedData<RadrootsJobResult>, JobParseError> {
     60     res_decode::data_from_event(
     61         event_id(e),
     62         author(e),
     63         published_at(e),
     64         kind_u32(e),
     65         content(e),
     66         tags_vec(e),
     67     )
     68 }
     69 
     70 pub fn to_job_feedback_metadata(
     71     e: &RadrootsNostrEvent,
     72 ) -> Result<RadrootsParsedData<RadrootsJobFeedback>, JobParseError> {
     73     fb_decode::data_from_event(
     74         event_id(e),
     75         author(e),
     76         published_at(e),
     77         kind_u32(e),
     78         content(e),
     79         tags_vec(e),
     80     )
     81 }
     82 
     83 pub fn to_job_request_index(
     84     e: &RadrootsNostrEvent,
     85 ) -> Result<RadrootsParsedEvent<RadrootsJobRequest>, JobParseError> {
     86     req_decode::parsed_from_event(
     87         event_id(e),
     88         author(e),
     89         published_at(e),
     90         kind_u32(e),
     91         content(e),
     92         tags_vec(e),
     93         sig_hex(e),
     94     )
     95 }
     96 
     97 pub fn to_job_result_index(
     98     e: &RadrootsNostrEvent,
     99 ) -> Result<RadrootsParsedEvent<RadrootsJobResult>, JobParseError> {
    100     res_decode::parsed_from_event(
    101         event_id(e),
    102         author(e),
    103         published_at(e),
    104         kind_u32(e),
    105         content(e),
    106         tags_vec(e),
    107         sig_hex(e),
    108     )
    109 }
    110 
    111 pub fn to_job_feedback_index(
    112     e: &RadrootsNostrEvent,
    113 ) -> Result<RadrootsParsedEvent<RadrootsJobFeedback>, JobParseError> {
    114     fb_decode::parsed_from_event(
    115         event_id(e),
    116         author(e),
    117         published_at(e),
    118         kind_u32(e),
    119         content(e),
    120         tags_vec(e),
    121         sig_hex(e),
    122     )
    123 }