rhi

Coordinated trade for connected markets
git clone https://radroots.dev/git/rhi.git
Log | Files | Refs | README | LICENSE

event.rs (6833B)


      1 use core::fmt;
      2 
      3 use nostr::Event;
      4 use radroots_event_codec::decode::job::{JobEventBorrow, JobEventLike};
      5 
      6 #[derive(Clone)]
      7 pub struct NostrEventAdapter<'a> {
      8     evt: &'a Event,
      9     id_hex: String,
     10     author_hex: String,
     11 }
     12 
     13 impl fmt::Debug for NostrEventAdapter<'_> {
     14     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
     15         formatter.write_str("NostrEventAdapter([redacted])")
     16     }
     17 }
     18 
     19 impl<'a> NostrEventAdapter<'a> {
     20     #[inline]
     21     pub fn new(evt: &'a Event) -> Self {
     22         Self {
     23             evt,
     24             id_hex: evt.id.to_hex(),
     25             author_hex: evt.pubkey.to_string(),
     26         }
     27     }
     28 
     29     #[inline]
     30     fn tags_as_slices(&self) -> Vec<Vec<String>> {
     31         self.evt
     32             .tags
     33             .iter()
     34             .map(|t| t.as_slice().to_vec())
     35             .collect()
     36     }
     37 }
     38 
     39 impl<'a> JobEventBorrow<'a> for NostrEventAdapter<'a> {
     40     #[inline]
     41     fn raw_id(&'a self) -> String {
     42         self.id_hex.clone()
     43     }
     44     #[inline]
     45     fn raw_author(&'a self) -> String {
     46         self.author_hex.clone()
     47     }
     48     #[inline]
     49     fn raw_content(&'a self) -> &'a str {
     50         &self.evt.content
     51     }
     52     #[inline]
     53     fn raw_kind(&'a self) -> u32 {
     54         u32::from(self.evt.kind.as_u16())
     55     }
     56 }
     57 
     58 impl JobEventLike for NostrEventAdapter<'_> {
     59     fn raw_id(&self) -> String {
     60         self.id_hex.clone()
     61     }
     62     fn raw_author(&self) -> String {
     63         self.author_hex.clone()
     64     }
     65     fn raw_published_at(&self) -> u64 {
     66         self.evt.created_at.as_secs()
     67     }
     68     fn raw_kind(&self) -> u32 {
     69         u32::from(self.evt.kind.as_u16())
     70     }
     71     fn raw_content(&self) -> String {
     72         self.evt.content.clone()
     73     }
     74     fn raw_tags(&self) -> Vec<Vec<String>> {
     75         self.tags_as_slices()
     76     }
     77     fn raw_sig(&self) -> String {
     78         self.evt.sig.to_string()
     79     }
     80 }
     81 
     82 #[cfg(test)]
     83 #[cfg_attr(coverage_nightly, coverage(off))]
     84 mod tests {
     85     use super::NostrEventAdapter;
     86     use nostr::{Event, EventBuilder, Keys, Kind, Tag, TagKind, Timestamp};
     87     use radroots_event_codec::decode::job::{
     88         BorrowedEventAdapter, JobEventBorrow, JobEventLike, JobParseError,
     89     };
     90     use radroots_nostr::event::GenericBuilder;
     91 
     92     fn build_event(keys: &Keys, kind: Kind, tags: Vec<Tag>) -> Event {
     93         GenericBuilder::new(kind, "content")
     94             .tags(tags)
     95             .sign_with_keys(keys)
     96             .expect("event must sign")
     97     }
     98 
     99     #[test]
    100     fn adapter_exposes_borrow_and_owned_fields_for_custom_kind() {
    101         let keys = Keys::generate();
    102         let recipient = Keys::generate();
    103         let recipient_hex = recipient.public_key().to_hex();
    104         let tags = vec![Tag::custom(TagKind::p(), vec![recipient_hex.clone()])];
    105         let event = build_event(&keys, Kind::Custom(5322), tags);
    106         let adapter = NostrEventAdapter::new(&event);
    107         assert_eq!(format!("{adapter:?}"), "NostrEventAdapter([redacted])");
    108 
    109         assert_eq!(JobEventBorrow::raw_id(&adapter), event.id.to_hex());
    110         assert_eq!(
    111             JobEventBorrow::raw_author(&adapter),
    112             event.pubkey.to_string()
    113         );
    114         assert_eq!(JobEventBorrow::raw_content(&adapter), "content");
    115         assert_eq!(JobEventBorrow::raw_kind(&adapter), 5322);
    116 
    117         assert_eq!(JobEventLike::raw_id(&adapter), event.id.to_hex());
    118         assert_eq!(JobEventLike::raw_author(&adapter), event.pubkey.to_string());
    119         assert_eq!(JobEventLike::raw_content(&adapter), "content".to_string());
    120         assert_eq!(JobEventLike::raw_kind(&adapter), 5322);
    121         assert_eq!(
    122             JobEventLike::raw_tags(&adapter),
    123             vec![vec!["p".to_string(), recipient_hex]]
    124         );
    125         assert_eq!(JobEventLike::raw_sig(&adapter), event.sig.to_string());
    126     }
    127 
    128     #[test]
    129     fn adapter_preserves_named_and_custom_wire_kinds() {
    130         let keys = Keys::generate();
    131         for wire_kind in [0_u16, 1, 6, 5_001, 6_001, 7_000, u16::MAX] {
    132             let event = EventBuilder::new(Kind::from(wire_kind), "synthetic kind fixture")
    133                 .custom_created_at(Timestamp::from(1_700_000_000))
    134                 .sign_with_keys(&keys)
    135                 .expect("signed synthetic event");
    136             let adapter = NostrEventAdapter::new(&event);
    137             assert_eq!(JobEventBorrow::raw_kind(&adapter), u32::from(wire_kind));
    138             assert_eq!(JobEventLike::raw_kind(&adapter), u32::from(wire_kind));
    139             assert_eq!(
    140                 JobEventLike::raw_published_at(&adapter),
    141                 event.created_at.as_secs()
    142             );
    143             if wire_kind != 7_000 {
    144                 assert!(matches!(
    145                     adapter.to_job_feedback_metadata(),
    146                     Err(JobParseError::InvalidTag("kind (expected 7000)"))
    147                 ));
    148             }
    149         }
    150     }
    151 
    152     #[test]
    153     fn adapter_decodes_signed_named_feedback_through_both_traits() {
    154         let keys = Keys::generate();
    155         let customer = Keys::generate();
    156         let request = build_event(&customer, Kind::Custom(5_001), Vec::new());
    157         let feedback = build_event(
    158             &keys,
    159             Kind::JobFeedback,
    160             vec![
    161                 Tag::custom(TagKind::e(), vec![request.id.to_hex()]),
    162                 Tag::custom(TagKind::p(), vec![request.pubkey.to_hex()]),
    163                 Tag::parse(["status", "processing"]).expect("synthetic status tag"),
    164             ],
    165         );
    166         feedback.verify().expect("valid signed synthetic feedback");
    167         assert_eq!(feedback.kind, Kind::JobFeedback);
    168         let adapter = NostrEventAdapter::new(&feedback);
    169         let tags = JobEventLike::raw_tags(&adapter);
    170         let borrowed = BorrowedEventAdapter::new(
    171             &adapter,
    172             feedback.created_at.as_secs(),
    173             &tags,
    174             feedback.sig.to_string(),
    175         );
    176 
    177         for metadata in [
    178             adapter.to_job_feedback_metadata().expect("owned feedback"),
    179             borrowed
    180                 .to_job_feedback_metadata()
    181                 .expect("borrowed feedback"),
    182         ] {
    183             assert_eq!(metadata.kind, 7_000);
    184             assert_eq!(metadata.data.kind, 7_000);
    185             assert_eq!(metadata.data.request_event.id, request.id.to_hex());
    186             assert_eq!(metadata.data.customer_pubkey, Some(request.pubkey.to_hex()));
    187             assert_eq!(metadata.id, feedback.id.to_hex());
    188         }
    189         for parsed in [
    190             adapter.to_job_feedback_event_index().expect("owned index"),
    191             borrowed
    192                 .to_job_feedback_event_index()
    193                 .expect("borrowed index"),
    194         ] {
    195             assert_eq!(parsed.data.kind, 7_000);
    196             assert_eq!(parsed.data.data.request_event.id, request.id.to_hex());
    197             assert_eq!(parsed.event.kind_u32(), 7_000);
    198             assert_eq!(parsed.event.id_hex(), feedback.id.to_hex());
    199         }
    200     }
    201 }