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 }