exact_delivery.rs (20411B)
1 use futures::{FutureExt, SinkExt, StreamExt}; 2 use nostr_sdk::prelude::{EventBuilder, FinalizeEvent, Keys, Kind, Tag, Timestamp}; 3 use radroots_transport::{ 4 DeliveryRequest, EventSink, EventSource, FetchRequest, TargetSet, 5 policy::{SatisfactionClass, SatisfactionPolicy, TargetPolicy}, 6 sink::DeliveryPayload, 7 source::FetchBounds, 8 }; 9 use radroots_transport_nostr::{ 10 Config, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind, RelayUrlPolicy, 11 }; 12 use serde_json::{Value, json}; 13 use std::time::{Duration, SystemTime, UNIX_EPOCH}; 14 use tokio::net::{TcpListener, TcpStream}; 15 use tokio_tungstenite::{WebSocketStream, accept_async, tungstenite::Message}; 16 17 const KEY: &str = "0000000000000000000000000000000000000000000000000000000000000001"; 18 19 fn now() -> u64 { 20 SystemTime::now() 21 .duration_since(UNIX_EPOCH) 22 .unwrap() 23 .as_millis() 24 .try_into() 25 .unwrap() 26 } 27 28 fn raw_event() -> String { 29 let event = EventBuilder::new(Kind::TextNote, "harvest café\n🌱") 30 .custom_created_at(Timestamp::from_secs(1_800_000_000)) 31 .finalize(&Keys::parse(KEY).unwrap()) 32 .unwrap(); 33 let mut value: Value = serde_json::from_str(&event.as_json()).unwrap(); 34 value["extension"] = json!({"retained": true}); 35 format!(" \n{} \t", serde_json::to_string_pretty(&value).unwrap()) 36 } 37 38 fn config(url: &str, timeout: u64) -> Config { 39 Config::from_profile( 40 RelayProfile::explicit( 41 RelayProfileKind::Simulator, 42 [RelayEndpoint::new(url, RelayUrlPolicy::Local, RelayAccess::ReadWrite).unwrap()], 43 ) 44 .unwrap(), 45 ) 46 .with_timeouts(1_000, timeout, 500) 47 .unwrap() 48 } 49 50 fn targets(config: &Config) -> TargetSet { 51 TargetSet::new( 52 config 53 .relays() 54 .iter() 55 .map(|relay| relay.to_target().unwrap()) 56 .collect(), 57 ) 58 .unwrap() 59 } 60 61 fn request(config: &Config, raw: &str) -> DeliveryRequest { 62 DeliveryRequest::new( 63 "exact-wire", 64 DeliveryPayload::new(radroots_event_codec::decode::signed_event(raw).unwrap()), 65 targets(config), 66 SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()), 67 now() + 5_000, 68 ) 69 .unwrap() 70 } 71 72 async fn text(socket: &mut WebSocketStream<TcpStream>) -> String { 73 tokio::time::timeout(Duration::from_secs(5), async { 74 loop { 75 if let Message::Text(text) = socket.next().await.unwrap().unwrap() { 76 return text.to_string(); 77 } 78 } 79 }) 80 .await 81 .unwrap() 82 } 83 84 async fn reply(socket: &mut WebSocketStream<TcpStream>, value: Value) { 85 socket 86 .send(Message::Text(value.to_string().into())) 87 .await 88 .unwrap(); 89 } 90 91 #[tokio::test] 92 async fn selected_delivery_never_connects_to_held_target_and_preserves_full_request() { 93 let a = TcpListener::bind("127.0.0.1:0").await.unwrap(); 94 let b = TcpListener::bind("127.0.0.1:0").await.unwrap(); 95 let config = Config::from_profile( 96 RelayProfile::explicit( 97 RelayProfileKind::Simulator, 98 [a.local_addr().unwrap(), b.local_addr().unwrap()].map(|address| { 99 RelayEndpoint::new( 100 format!("ws://{address}"), 101 RelayUrlPolicy::Local, 102 RelayAccess::ReadWrite, 103 ) 104 .unwrap() 105 }), 106 ) 107 .unwrap(), 108 ) 109 .with_timeouts(1_000, 2_000, 500) 110 .unwrap(); 111 let raw = raw_event(); 112 let expected = format!("[\"EVENT\",{raw}]"); 113 let server = tokio::spawn(async move { 114 let (tcp, _) = a.accept().await.unwrap(); 115 let mut socket = accept_async(tcp).await.unwrap(); 116 let wire = text(&mut socket).await; 117 assert_eq!(wire, expected); 118 let event: Value = serde_json::from_str(&wire).unwrap(); 119 reply(&mut socket, json!(["OK", event[1]["id"], true, ""])).await; 120 }); 121 let transport = radroots_transport_nostr_native::create_transport(config.clone()); 122 let request = request(&config, &raw); 123 let selected = TargetSet::new(vec![request.target_set().targets()[0].clone()]).unwrap(); 124 let result = transport 125 .deliver_selected(request.clone(), selected) 126 .await 127 .unwrap(); 128 result.validate_for_request(&request).unwrap(); 129 assert!(result.target_receipts()[0].was_attempted()); 130 assert!( 131 result.target_receipts()[0] 132 .outcome() 133 .satisfies(SatisfactionClass::Accepted) 134 ); 135 assert!(!result.target_receipts()[1].was_attempted()); 136 assert_eq!( 137 result.target_receipts()[1].outcome().code(), 138 Some("target_not_selected") 139 ); 140 assert!(!result.is_satisfied(&request).unwrap()); 141 server.await.unwrap(); 142 assert!( 143 tokio::time::timeout(Duration::from_millis(150), b.accept()) 144 .await 145 .is_err() 146 ); 147 } 148 149 #[tokio::test] 150 async fn exact_signed_bytes_read_requests_and_auth_use_the_same_connection() { 151 let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); 152 let config = config(&format!("ws://{}", listener.local_addr().unwrap()), 2_000); 153 let raw = raw_event(); 154 let expected = format!("[\"EVENT\",{raw}]"); 155 let (auth_sent, auth_seen) = tokio::sync::oneshot::channel(); 156 let server = tokio::spawn(async move { 157 let (tcp, _) = listener.accept().await.unwrap(); 158 let mut socket = accept_async(tcp).await.unwrap(); 159 let req: Value = serde_json::from_str(&text(&mut socket).await).unwrap(); 160 assert_eq!(req[0], "REQ"); 161 reply(&mut socket, json!(["EOSE", req[1]])).await; 162 loop { 163 let message: Value = serde_json::from_str(&text(&mut socket).await).unwrap(); 164 if message[0] == "AUTH" { 165 assert_eq!(message[1]["kind"], 22242); 166 auth_sent.send(()).unwrap(); 167 break; 168 } 169 assert_eq!(message[0], "CLOSE"); 170 } 171 let wire = text(&mut socket).await; 172 assert_eq!(wire, expected); 173 let event: Value = serde_json::from_str(&wire).unwrap(); 174 reply( 175 &mut socket, 176 json!(["OK", "11".repeat(32), true, "unrelated event"]), 177 ) 178 .await; 179 reply(&mut socket, json!(["OK", event[1]["id"], true, ""])).await; 180 }); 181 let transport = radroots_transport_nostr_native::create_transport(config.clone()); 182 let page = transport 183 .fetch( 184 FetchRequest::new( 185 "same-socket-read", 186 targets(&config), 187 FetchBounds::new(1, now() + 5_000).unwrap(), 188 ) 189 .unwrap(), 190 ) 191 .await 192 .unwrap(); 193 assert!(page.events().is_empty()); 194 let relay = &config.relays()[0]; 195 let at = now() / 1_000 * 1_000; 196 transport 197 .begin_authentication(relay, "challenge", at, at + 5_000) 198 .unwrap(); 199 let auth = EventBuilder::new(Kind::Authentication, "") 200 .tags([ 201 Tag::parse(["relay", relay.as_str()]).unwrap(), 202 Tag::parse(["challenge", "challenge"]).unwrap(), 203 ]) 204 .custom_created_at(Timestamp::from_secs(at / 1_000)) 205 .finalize(&Keys::parse(KEY).unwrap()) 206 .unwrap(); 207 transport 208 .complete_authentication(relay, "challenge", Some(&auth.as_json()), at) 209 .await 210 .unwrap(); 211 tokio::time::timeout(Duration::from_secs(5), auth_seen) 212 .await 213 .unwrap() 214 .unwrap(); 215 let receipt = transport.deliver(request(&config, &raw)).await.unwrap(); 216 assert!( 217 receipt.target_receipts()[0] 218 .outcome() 219 .satisfies(SatisfactionClass::Accepted) 220 ); 221 server.await.unwrap(); 222 } 223 224 #[tokio::test] 225 async fn an_overlong_ack_identifier_never_accepts_the_matching_prefix() { 226 let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); 227 let config = config(&format!("ws://{}", listener.local_addr().unwrap()), 250); 228 let raw = raw_event(); 229 let (done, wait) = tokio::sync::oneshot::channel(); 230 let server = tokio::spawn(async move { 231 let (tcp, _) = listener.accept().await.unwrap(); 232 let mut socket = accept_async(tcp).await.unwrap(); 233 let event: Value = serde_json::from_str(&text(&mut socket).await).unwrap(); 234 let overlong = format!("{}00", event[1]["id"].as_str().unwrap()); 235 reply(&mut socket, json!(["OK", overlong, true, ""])).await; 236 wait.await.unwrap(); 237 }); 238 let request = request(&config, &raw); 239 let receipt = tokio::time::timeout( 240 Duration::from_secs(5), 241 radroots_transport_nostr_native::create_transport(config).deliver(request.clone()), 242 ) 243 .await 244 .unwrap() 245 .unwrap(); 246 done.send(()).unwrap(); 247 server.await.unwrap(); 248 assert!(!receipt.is_satisfied(&request).unwrap()); 249 } 250 251 #[tokio::test] 252 async fn binary_acknowledgements_never_invent_acceptance_for_exact_or_overlong_ids() { 253 for canonical in [true, false] { 254 let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); 255 let config = config(&format!("ws://{}", listener.local_addr().unwrap()), 250); 256 let raw = raw_event(); 257 let (done, wait) = tokio::sync::oneshot::channel(); 258 let server = tokio::spawn(async move { 259 let (tcp, _) = listener.accept().await.unwrap(); 260 let mut socket = accept_async(tcp).await.unwrap(); 261 let event: Value = serde_json::from_str(&text(&mut socket).await).unwrap(); 262 let id = event[1]["id"].as_str().unwrap(); 263 let id = if canonical { 264 id.to_owned() 265 } else { 266 format!("{id}00") 267 }; 268 socket 269 .send(Message::Binary( 270 json!(["OK", id, true, ""]).to_string().into_bytes().into(), 271 )) 272 .await 273 .unwrap(); 274 wait.await.unwrap(); 275 }); 276 let request = request(&config, &raw); 277 let transport = radroots_transport_nostr_native::create_transport(config); 278 let receipt = 279 tokio::time::timeout(Duration::from_secs(5), transport.deliver(request.clone())) 280 .await 281 .unwrap() 282 .unwrap(); 283 done.send(()).unwrap(); 284 server.await.unwrap(); 285 transport.shutdown().await; 286 assert!(!receipt.is_satisfied(&request).unwrap()); 287 } 288 } 289 290 #[tokio::test] 291 async fn relay_challenge_never_creates_an_implicit_authentication_response() { 292 let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); 293 let config = config(&format!("ws://{}", listener.local_addr().unwrap()), 2_000); 294 let raw = raw_event(); 295 let expected = format!("[\"EVENT\",{raw}]"); 296 let server = tokio::spawn(async move { 297 let (tcp, _) = listener.accept().await.unwrap(); 298 let mut socket = accept_async(tcp).await.unwrap(); 299 let wire = text(&mut socket).await; 300 assert_eq!(wire, expected); 301 let event: Value = serde_json::from_str(&wire).unwrap(); 302 reply(&mut socket, json!(["AUTH", "explicit-signer-required"])).await; 303 assert!( 304 tokio::time::timeout(Duration::from_millis(100), text(&mut socket)) 305 .await 306 .is_err() 307 ); 308 reply(&mut socket, json!(["OK", event[1]["id"], true, ""])).await; 309 }); 310 let transport = radroots_transport_nostr_native::create_transport(config.clone()); 311 let request = request(&config, &raw); 312 let receipt = tokio::time::timeout(Duration::from_secs(5), transport.deliver(request.clone())) 313 .await 314 .unwrap() 315 .unwrap(); 316 server.await.unwrap(); 317 assert!(receipt.is_satisfied(&request).unwrap()); 318 } 319 320 #[tokio::test] 321 async fn rejection_lost_ack_and_disconnect_never_invent_acceptance() { 322 for mode in ["reject", "lost", "disconnect"] { 323 let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); 324 let config = config(&format!("ws://{}", listener.local_addr().unwrap()), 250); 325 let raw = raw_event(); 326 let expected = format!("[\"EVENT\",{raw}]"); 327 let server = tokio::spawn(async move { 328 let (tcp, _) = listener.accept().await.unwrap(); 329 let mut socket = accept_async(tcp).await.unwrap(); 330 let wire = text(&mut socket).await; 331 assert_eq!(wire, expected); 332 let event: Value = serde_json::from_str(&wire).unwrap(); 333 match mode { 334 "reject" => { 335 reply( 336 &mut socket, 337 json!(["OK", event[1]["id"], false, "blocked: fixture"]), 338 ) 339 .await 340 } 341 "lost" => { 342 reply( 343 &mut socket, 344 json!(["OK", "22".repeat(32), true, "wrong ID"]), 345 ) 346 .await; 347 tokio::time::sleep(Duration::from_millis(500)).await; 348 } 349 "disconnect" => socket.close(None).await.unwrap(), 350 _ => unreachable!(), 351 } 352 }); 353 let receipt = radroots_transport_nostr_native::create_transport(config.clone()) 354 .deliver(request(&config, &raw)) 355 .await 356 .unwrap(); 357 assert!( 358 !receipt.target_receipts()[0] 359 .outcome() 360 .satisfies(SatisfactionClass::Accepted), 361 "{mode}" 362 ); 363 assert!(receipt.target_receipts()[0].was_attempted()); 364 server.await.unwrap(); 365 } 366 } 367 368 #[tokio::test] 369 async fn matching_negative_ack_never_accepts_duplicate_text() { 370 for message in [ 371 "blocked: not a duplicate; event was rejected", 372 "duplicate: already have this event", 373 "already have this event", 374 "error: duplicate detector unavailable", 375 "auth-required: duplicate path requires login", 376 "rate-limited: duplicate retries", 377 "invalid: duplicate event format", 378 ] { 379 let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); 380 let config = config(&format!("ws://{}", listener.local_addr().unwrap()), 2_000); 381 let raw = raw_event(); 382 let expected = format!("[\"EVENT\",{raw}]"); 383 let (done, wait) = tokio::sync::oneshot::channel(); 384 let server = tokio::spawn(async move { 385 let (tcp, _) = listener.accept().await.unwrap(); 386 let mut socket = accept_async(tcp).await.unwrap(); 387 let wire = text(&mut socket).await; 388 assert_eq!(wire, expected); 389 let event: Value = serde_json::from_str(&wire).unwrap(); 390 reply(&mut socket, json!(["OK", event[1]["id"], false, message])).await; 391 tokio::time::timeout(Duration::from_secs(5), wait) 392 .await 393 .unwrap() 394 .unwrap(); 395 }); 396 let transport = radroots_transport_nostr_native::create_transport(config.clone()); 397 let request = request(&config, &raw); 398 let receipt = 399 tokio::time::timeout(Duration::from_secs(5), transport.deliver(request.clone())) 400 .await 401 .unwrap() 402 .unwrap(); 403 done.send(()).unwrap(); 404 server.await.unwrap(); 405 receipt.validate_for_request(&request).unwrap(); 406 assert!(receipt.target_receipts()[0].was_attempted()); 407 assert!(!receipt.is_satisfied(&request).unwrap(), "{message}"); 408 assert!( 409 !receipt.target_receipts()[0] 410 .outcome() 411 .satisfies(SatisfactionClass::Accepted), 412 "{message}" 413 ); 414 } 415 } 416 417 #[tokio::test] 418 async fn matching_positive_ack_accepts_existing_duplicate_and_empty_messages() { 419 for message in ["", "duplicate: already have this event"] { 420 let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); 421 let config = config(&format!("ws://{}", listener.local_addr().unwrap()), 2_000); 422 let raw = raw_event(); 423 let (done, wait) = tokio::sync::oneshot::channel(); 424 let server = tokio::spawn(async move { 425 let (tcp, _) = listener.accept().await.unwrap(); 426 let mut socket = accept_async(tcp).await.unwrap(); 427 let event: Value = serde_json::from_str(&text(&mut socket).await).unwrap(); 428 assert_eq!(event[0], "EVENT"); 429 reply(&mut socket, json!(["OK", event[1]["id"], true, message])).await; 430 tokio::time::timeout(Duration::from_secs(5), wait) 431 .await 432 .unwrap() 433 .unwrap(); 434 }); 435 let request = request(&config, &raw); 436 let receipt = tokio::time::timeout( 437 Duration::from_secs(5), 438 radroots_transport_nostr_native::create_transport(config).deliver(request.clone()), 439 ) 440 .await 441 .unwrap() 442 .unwrap(); 443 done.send(()).unwrap(); 444 server.await.unwrap(); 445 receipt.validate_for_request(&request).unwrap(); 446 assert!(receipt.is_satisfied(&request).unwrap(), "{message}"); 447 } 448 } 449 450 #[tokio::test] 451 async fn quota_refusal_is_terminal_and_redacted_at_the_receipt_boundary() { 452 let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); 453 let config = config(&format!("ws://{}", listener.local_addr().unwrap()), 2_000); 454 let server = tokio::spawn(async move { 455 let (tcp, _) = listener.accept().await.unwrap(); 456 let mut socket = accept_async(tcp).await.unwrap(); 457 let event: Value = serde_json::from_str(&text(&mut socket).await).unwrap(); 458 reply( 459 &mut socket, 460 json!([ 461 "OK", 462 event[1]["id"], 463 false, 464 "quota exceeded: private-account-detail" 465 ]), 466 ) 467 .await; 468 }); 469 let transport = radroots_transport_nostr_native::create_transport(config.clone()); 470 let receipt = transport 471 .deliver(request(&config, &raw_event())) 472 .await 473 .unwrap(); 474 let target = &receipt.target_receipts()[0]; 475 assert!(target.was_attempted()); 476 assert_eq!(target.outcome().code(), Some("quota_exceeded")); 477 assert_eq!( 478 target.outcome().retryability(), 479 radroots_transport::outcome::Retryability::Terminal 480 ); 481 assert_eq!( 482 target.outcome().kind(), 483 radroots_transport::outcome::DeliveryOutcomeKind::Rejected 484 ); 485 assert_eq!( 486 target.outcome().message(), 487 Some("relay quota was exhausted") 488 ); 489 assert_eq!( 490 transport.relay_status().relays()[0] 491 .write() 492 .last_failure_retryable(), 493 Some(false) 494 ); 495 server.await.unwrap(); 496 } 497 498 #[tokio::test] 499 async fn queued_delivery_targets_cannot_start_after_the_shared_deadline() { 500 let first = TcpListener::bind("127.0.0.1:0").await.unwrap(); 501 let second = TcpListener::bind("127.0.0.1:0").await.unwrap(); 502 let endpoints = [&first, &second].map(|listener| { 503 RelayEndpoint::new( 504 format!("ws://{}", listener.local_addr().unwrap()), 505 RelayUrlPolicy::Local, 506 RelayAccess::ReadWrite, 507 ) 508 .unwrap() 509 }); 510 let config = Config::from_profile( 511 RelayProfile::explicit(RelayProfileKind::Simulator, endpoints).unwrap(), 512 ) 513 .with_timeouts(1_000, 250, 500) 514 .unwrap() 515 .with_max_connections(1) 516 .unwrap(); 517 let server = tokio::spawn(async move { 518 let (tcp, _) = first.accept().await.unwrap(); 519 let mut socket = accept_async(tcp).await.unwrap(); 520 let _published = text(&mut socket).await; 521 futures::future::pending::<()>().await; 522 }); 523 let transport = radroots_transport_nostr_native::create_transport(config.clone()); 524 let receipt = transport 525 .deliver(request(&config, &raw_event())) 526 .await 527 .unwrap(); 528 assert_eq!(receipt.target_receipts().len(), 2); 529 assert!( 530 receipt 531 .target_receipts() 532 .iter() 533 .all(|target| !target.outcome().satisfies(SatisfactionClass::Accepted)) 534 ); 535 assert!(second.accept().now_or_never().is_none()); 536 assert!(receipt.target_receipts()[0].was_attempted()); 537 assert!( 538 !receipt.target_receipts()[1].was_attempted(), 539 "a target expired while queued never entered remote publication" 540 ); 541 server.abort(); 542 assert!(server.await.unwrap_err().is_cancelled()); 543 }