delivery.rs (11407B)
1 //! Actual protected D ports using independently signed synthetic carriers. 2 use super::{WorkspaceFixture, copied, plans::BrowserRng}; 3 use core::num::NonZeroU64; 4 use futures::FutureExt; 5 use nostr::{JsonUtil, nips::nip44}; 6 use radroots_domain::{OperationId, PublicKey}; 7 use radroots_storage::command::{ 8 ClaimAttemptRequest, DeliveryAttempt, DeliveryAttemptOutcome, DeliveryAttemptRequest, 9 DeliveryIntent, EnvelopeCandidate, 10 }; 11 use radroots_transport::{ 12 Target, TargetSet, 13 policy::{SatisfactionClass, SatisfactionPolicy, TargetPolicy}, 14 sink::DeliveryRequestId, 15 }; 16 use serde_json::{Value, json}; 17 use wasm_bindgen::prelude::*; 18 19 #[wasm_bindgen] 20 pub struct ObtainedEnvelope { 21 candidate: EnvelopeCandidate, 22 } 23 #[wasm_bindgen] 24 impl ObtainedEnvelope { 25 pub fn event(&self) -> String { 26 self.candidate.event_id().to_string() 27 } 28 pub fn raw(&self) -> String { 29 self.candidate.raw_json().into() 30 } 31 } 32 fn summary(report: &DeliveryAttempt) -> Value { 33 json!({"request":report.intent().request_id().as_str(),"event":report.intent().event_id().to_string(),"transaction":report.transaction_id().to_string(),"at":report.retained_at().get(),"raw":report.raw_json(),"digest":hex::encode(report.envelope_digest()),"policy":hex::encode(report.intent().publication_policy_digest()),"targets":report.intent().targets().targets().iter().map(|target|target.uri().as_str()).collect::<Vec<_>>(),"selection":report.intent().selected_targets().map(|target|target.uri().as_str()).collect::<Vec<_>>(),"ordinals":report.target_ordinals()}) 34 } 35 fn outcome(value: DeliveryAttemptOutcome) -> Value { 36 match value { 37 DeliveryAttemptOutcome::Claimed(report) => { 38 json!({"kind":"claimed","report":summary(&report)}) 39 } 40 DeliveryAttemptOutcome::Retained(report) => { 41 json!({"kind":"retained","report":summary(&report)}) 42 } 43 DeliveryAttemptOutcome::Unknown { operation, attempt } => { 44 json!({"kind":"unknown","operation":operation.operation_id().to_string(),"command":operation.command_digest().to_string(),"transaction":operation.transaction_id().map(|tx|tx.to_string()),"request":attempt.as_str()}) 45 } 46 } 47 } 48 impl WorkspaceFixture { 49 async fn delivery_request( 50 &self, 51 n: u8, 52 id: u8, 53 selection: u16, 54 mode: u8, 55 envelope: &ObtainedEnvelope, 56 ) -> Result<DeliveryAttemptRequest, JsValue> { 57 let request = self.request(n, false).await?; 58 let mut relays = super::plans::delivery_relays(mode & 15 == 6); 59 if mode & 15 == 4 { 60 relays[1] = "wss://unapproved.fixture.example/".into(); 61 } 62 let targets = TargetSet::new( 63 relays 64 .iter() 65 .map(|relay| Target::nostr_relay(relay).unwrap()) 66 .collect(), 67 ) 68 .unwrap(); 69 let policy = SatisfactionPolicy::new( 70 SatisfactionClass::Accepted, 71 if mode & 15 == 5 { 72 TargetPolicy::any() 73 } else { 74 TargetPolicy::all() 75 }, 76 ); 77 let selected = TargetSet::new( 78 targets 79 .targets() 80 .iter() 81 .enumerate() 82 .filter(|(index, _)| selection & (1 << index) != 0) 83 .map(|(_, target)| target.clone()) 84 .collect(), 85 ) 86 .unwrap(); 87 let intent = DeliveryIntent::new( 88 &hex::encode([id; 32]), 89 envelope.candidate.event_id(), 90 &targets, 91 &policy, 92 NonZeroU64::new(1_800_000).unwrap(), 93 ) 94 .unwrap() 95 .with_selection(&selected) 96 .unwrap(); 97 DeliveryAttemptRequest::new(request.binding().clone(), envelope.candidate.work(), intent) 98 .map_err(|error| JsValue::from_str(error.code())) 99 } 100 } 101 #[wasm_bindgen] 102 impl WorkspaceFixture { 103 pub fn alternate_envelope( 104 &self, 105 original: &ObtainedEnvelope, 106 ) -> Result<ObtainedEnvelope, JsValue> { 107 let event = nostr::Event::from_json(original.candidate.raw_json()).unwrap(); 108 let context = nostr::secp256k1::Secp256k1::new(); 109 let mut scalar = [0; 32]; 110 scalar[31] = 3; 111 let keys = 112 nostr::Keys::new_with_ctx(&context, nostr::SecretKey::from_slice(&scalar).unwrap()); 113 let alternate = nostr::UnsignedEvent { 114 id: Some(event.id), 115 pubkey: event.pubkey, 116 created_at: event.created_at, 117 kind: event.kind, 118 tags: event.tags.clone(), 119 content: event.content.clone(), 120 } 121 .sign_with_ctx(&context, &mut BrowserRng, &keys) 122 .unwrap(); 123 alternate.verify_with_ctx(&context).unwrap(); 124 assert_eq!(alternate.id, event.id); 125 assert_ne!(alternate.as_json(), event.as_json()); 126 Ok(ObtainedEnvelope { 127 candidate: EnvelopeCandidate::from_obtained( 128 original.candidate.work(), 129 &alternate.as_json(), 130 &scalar, 131 ) 132 .map_err(|e| JsValue::from_str(e.code()))?, 133 }) 134 } 135 pub async fn envelope(&self, n: u8, index: u8, mode: u8) -> Result<ObtainedEnvelope, JsValue> { 136 let request = self.request(n, false).await?; 137 let snapshot = self 138 .journal() 139 .operation_snapshot( 140 request.binding().clone(), 141 OperationId::from_bytes([n; 32]), 142 Some(request.command().digest()), 143 copied(&self.proof), 144 ) 145 .await 146 .map_err(|error| JsValue::from_str(error.code()))? 147 .ok_or(JsValue::from_str("missing_operation"))?; 148 let recipient = snapshot 149 .bound_plan() 150 .unwrap() 151 .chat_plan() 152 .unwrap() 153 .seals() 154 .get(index as usize) 155 .ok_or(JsValue::from_str("invalid_recipient"))? 156 .recipient(); 157 let work = snapshot 158 .publications() 159 .iter() 160 .find(|work| work.recipient() == recipient) 161 .copied() 162 .ok_or(JsValue::from_str("missing_work"))?; 163 let retained = self 164 .journal() 165 .obtained_evidence( 166 ClaimAttemptRequest::new( 167 request.binding().clone(), 168 OperationId::from_bytes([n; 32]), 169 request.command().digest(), 170 *snapshot.bound_plan().unwrap().plan().digest(), 171 recipient, 172 ), 173 copied(&self.proof), 174 ) 175 .await 176 .map_err(|error| JsValue::from_str(error.code()))? 177 .ok_or(JsValue::from_str("missing_output"))?; 178 let context = nostr::secp256k1::Secp256k1::new(); 179 let mut scalar = [0; 32]; 180 scalar[31] = if mode == 3 { 1 } else { 3 }; 181 let keys = 182 nostr::Keys::new_with_ctx(&context, nostr::SecretKey::from_slice(&scalar).unwrap()); 183 let recipient = nostr::PublicKey::from_slice(recipient.as_bytes()).unwrap(); 184 let plain = if mode == 2 { 185 "different original seal" 186 } else { 187 retained.evidence().raw_json() 188 }; 189 let encrypted = nip44::encrypt_with_rng( 190 &mut BrowserRng, 191 keys.secret_key(), 192 &recipient, 193 plain, 194 nip44::Version::V2, 195 ) 196 .unwrap(); 197 let event = nostr::UnsignedEvent { 198 id: None, 199 pubkey: keys.public_key(), 200 created_at: nostr::Timestamp::from_secs(900), 201 kind: nostr::Kind::GiftWrap, 202 tags: nostr::Tags::from_list(vec![nostr::Tag::public_key(recipient)]), 203 content: encrypted, 204 } 205 .sign_with_ctx(&context, &mut BrowserRng, &keys) 206 .unwrap(); 207 event.verify_with_ctx(&context).unwrap(); 208 if mode == 1 { 209 scalar[31] = 4; 210 } 211 let candidate = EnvelopeCandidate::from_obtained(work, &event.as_json(), &scalar) 212 .map_err(|error| JsValue::from_str(error.code()))?; 213 Ok(ObtainedEnvelope { candidate }) 214 } 215 pub async fn store_envelope( 216 &self, 217 n: u8, 218 id: u8, 219 selection: u16, 220 mode: u8, 221 envelope: &ObtainedEnvelope, 222 ) -> Result<String, JsValue> { 223 let request = self 224 .delivery_request(n, id, selection, mode, envelope) 225 .await?; 226 self.clock.after.set(match mode & 15 { 227 1 => Some(900), 228 2 => Some(2000), 229 3 => Some(1800), 230 _ => None, 231 }); 232 self.journal() 233 .prepare_delivery_attempt( 234 request, 235 copied(&self.proof), 236 if mode & 16 != 0 { 237 None 238 } else { 239 Some(&envelope.candidate) 240 }, 241 ) 242 .await 243 .map(|value| outcome(value).to_string()) 244 .map_err(|error| JsValue::from_str(error.code())) 245 } 246 pub async fn store_envelope_unknown( 247 &self, 248 n: u8, 249 id: u8, 250 selection: u16, 251 envelope: &ObtainedEnvelope, 252 hook: js_sys::Function, 253 ) -> Result<String, JsValue> { 254 let request = self.delivery_request(n, id, selection, 0, envelope).await?; 255 hook.call0(&JsValue::NULL)?; 256 self.journal() 257 .prepare_delivery_attempt(request, copied(&self.proof), Some(&envelope.candidate)) 258 .await 259 .map(|value| outcome(value).to_string()) 260 .map_err(|error| JsValue::from_str(error.code())) 261 } 262 pub async fn abandon_envelope( 263 &self, 264 n: u8, 265 id: u8, 266 selection: u16, 267 envelope: &ObtainedEnvelope, 268 ) -> Result<(), JsValue> { 269 let request = self.delivery_request(n, id, selection, 0, envelope).await?; 270 if self 271 .journal() 272 .prepare_delivery_attempt(request, copied(&self.proof), Some(&envelope.candidate)) 273 .now_or_never() 274 .is_some() 275 { 276 return Err(JsValue::from_str("unexpected_immediate_delivery_retention")); 277 } 278 Ok(()) 279 } 280 pub async fn query_envelope(&self, n: u8, index: u8, id: u8) -> Result<String, JsValue> { 281 let request = self.request(n, false).await?; 282 let mut recipients = vec![ 283 self.input.participant(), 284 request.chat_command().unwrap().peer(), 285 ]; 286 recipients.sort_unstable(); 287 recipients.dedup(); 288 let recipient: PublicKey = *recipients 289 .get(index as usize) 290 .ok_or(JsValue::from_str("invalid_recipient"))?; 291 self.journal() 292 .delivery_attempt( 293 request.binding().clone(), 294 OperationId::from_bytes([n; 32]), 295 request.command().digest(), 296 recipient.into(), 297 DeliveryRequestId::parse(hex::encode([id; 32])).unwrap(), 298 copied(&self.proof), 299 ) 300 .await 301 .map(|value| { 302 value 303 .as_ref() 304 .map(summary) 305 .unwrap_or(Value::Null) 306 .to_string() 307 }) 308 .map_err(|error| JsValue::from_str(error.code())) 309 } 310 }