subscription.rs (55290B)
1 //! Bounded Nostr live-subscription adapter. 2 3 use crate::host_time::unix_time_ms; 4 use crate::{NostrTransport, RelayCursor, RelayUrl}; 5 use futures::StreamExt; 6 use nostr_sdk::prelude::{ 7 ClientMessage, ClientNotification, Filter, Kind, PublicKey, RelayMessage, ReqExitPolicy, 8 SubscribeAutoCloseOptions, SubscriptionId, Timestamp, 9 }; 10 use radroots_transport::{ 11 BoxFuture, BoxSubscription, EventSubscriber, EventSubscription, SubscriptionEnd, 12 SubscriptionEndReason, SubscriptionEvent, SubscriptionNext, SubscriptionRequest, 13 source::{EventProvenance, FetchCursor, ObservedEvent, SubscriptionCheckpoint}, 14 }; 15 use sha2::{Digest, Sha256}; 16 use std::{ 17 collections::{BTreeMap, BTreeSet}, 18 sync::{ 19 Arc, 20 atomic::{AtomicBool, Ordering}, 21 }, 22 time::Duration, 23 }; 24 25 const CURSOR_PREFIX: &str = "nostr-live-v1"; 26 const CURSOR_SCOPE_DOMAIN: &[u8] = b"radroots.transport-nostr.subscription-cursor.v1\0"; 27 const SUBSCRIPTION_ID_DOMAIN: &[u8] = b"radroots.transport-nostr.subscription-id.v1\0"; 28 29 #[derive(Clone, Debug)] 30 pub(crate) struct RelaySubscriptionQuery { 31 id: String, 32 targets: Vec<RelaySubscriptionTarget>, 33 selector: radroots_transport::source::FetchSelector, 34 connect_timeout: Duration, 35 timeout: Duration, 36 } 37 38 #[derive(Clone, Debug)] 39 struct RelaySubscriptionTarget { 40 relay: RelayUrl, 41 since_unix_seconds: Option<u64>, 42 } 43 44 #[derive(Clone, Debug, Eq, PartialEq)] 45 pub(crate) enum RelaySubscriptionItem { 46 Event { relay: RelayUrl, raw: String }, 47 Closed { relay: RelayUrl }, 48 Shutdown, 49 } 50 51 pub(crate) trait RelaySubscriptionSession: Send { 52 fn next(&mut self) -> BoxFuture<'_, Result<RelaySubscriptionItem, ()>>; 53 fn cancel(&mut self) -> BoxFuture<'_, Result<(), ()>>; 54 } 55 56 pub(crate) trait RelaySubscriptionClient: Send + Sync { 57 fn subscribe( 58 &self, 59 query: RelaySubscriptionQuery, 60 ) -> BoxFuture<'_, Result<Box<dyn RelaySubscriptionSession>, ()>>; 61 } 62 63 #[derive(Clone, Debug)] 64 pub(crate) struct LiveRelaySubscriptionClient { 65 client: nostr_sdk::client::Client, 66 connections: std::sync::Arc<crate::connections::Connections>, 67 ingress: crate::source_ingress::IngressRegistry, 68 } 69 70 impl LiveRelaySubscriptionClient { 71 pub(crate) const fn new( 72 client: nostr_sdk::client::Client, 73 connections: std::sync::Arc<crate::connections::Connections>, 74 ingress: crate::source_ingress::IngressRegistry, 75 ) -> Self { 76 Self { 77 client, 78 connections, 79 ingress, 80 } 81 } 82 83 #[cfg(test)] 84 pub(crate) fn isolated() -> Self { 85 let client = nostr_sdk::client::Client::default(); 86 Self::new( 87 client, 88 std::sync::Arc::new(crate::connections::Connections::new( 89 crate::client::MAX_RELAYS, 90 )), 91 crate::source_ingress::IngressRegistry::default(), 92 ) 93 } 94 } 95 96 impl RelaySubscriptionClient for LiveRelaySubscriptionClient { 97 #[cfg_attr(coverage_nightly, coverage(off))] 98 fn subscribe( 99 &self, 100 query: RelaySubscriptionQuery, 101 ) -> BoxFuture<'_, Result<Box<dyn RelaySubscriptionSession>, ()>> { 102 Box::pin(async move { 103 let notifications = self.client.notifications().with_gaps(); 104 let subscription_id = SubscriptionId::new(query.id); 105 let mut targeted = Vec::with_capacity(query.targets.len()); 106 let mut relay_lookup = BTreeMap::new(); 107 let originals = self 108 .ingress 109 .register_live( 110 query 111 .targets 112 .iter() 113 .map(|target| target.relay.as_str().to_owned()), 114 ) 115 .ok_or(())?; 116 let mut original_scopes = BTreeMap::new(); 117 118 for target in query.targets { 119 let url = target.relay.as_str().to_owned(); 120 let original = originals 121 .bind_originals(&url, subscription_id.as_str()) 122 .ok_or(())?; 123 let filter = subscription_filter(&query.selector, target.since_unix_seconds)?; 124 self.client 125 .add_relay(url.as_str()) 126 .connect_timeout(query.connect_timeout) 127 .await 128 .map_err(|_| ())?; 129 crate::client::connect_tracked( 130 &self.client, 131 &self.connections, 132 url.as_str(), 133 query.connect_timeout, 134 ) 135 .await 136 .map_err(|_| ())?; 137 relay_lookup.insert(url.clone(), target.relay); 138 original_scopes.insert(url.clone(), original); 139 targeted.push((url, vec![filter])); 140 } 141 142 let auto_close = SubscribeAutoCloseOptions::default() 143 .exit_policy(ReqExitPolicy::WaitDurationAfterEOSE(query.timeout)) 144 .timeout(Some(query.timeout)); 145 let output = self 146 .client 147 .subscribe(targeted) 148 .with_id(subscription_id.clone()) 149 .close_on(auto_close) 150 .await 151 .map_err(|_| ())?; 152 if !output.failed.is_empty() || output.success.len() != relay_lookup.len() { 153 let _ = self 154 .client 155 .send_msg(ClientMessage::close(subscription_id.clone())) 156 .to(relay_lookup.keys().map(String::as_str)) 157 .await; 158 let _ = self.client.unsubscribe(&subscription_id).await; 159 return Err(()); 160 } 161 162 // Keep the receiver created before REQ publication so an immediate 163 // relay event cannot race ahead of local observation. 164 let session = LiveRelaySubscriptionSession { 165 client: self.client.clone(), 166 subscription_id, 167 notifications: Some(notifications), 168 relay_lookup, 169 cancelled: false, 170 originals: Some(originals), 171 original_scopes, 172 }; 173 Ok(Box::new(session) as Box<dyn RelaySubscriptionSession>) 174 }) 175 } 176 } 177 178 struct LiveRelaySubscriptionSession { 179 client: nostr_sdk::client::Client, 180 subscription_id: SubscriptionId, 181 notifications: Option<nostr_sdk::stream::NotificationStreamWithGaps<ClientNotification>>, 182 relay_lookup: BTreeMap<String, RelayUrl>, 183 cancelled: bool, 184 originals: Option<crate::source_ingress::IngressRegistration>, 185 original_scopes: BTreeMap<String, crate::source_ingress::OriginalSubscription>, 186 } 187 188 impl RelaySubscriptionSession for LiveRelaySubscriptionSession { 189 #[cfg_attr(coverage_nightly, coverage(off))] 190 fn next(&mut self) -> BoxFuture<'_, Result<RelaySubscriptionItem, ()>> { 191 Box::pin(async move { 192 let Some(notifications) = self.notifications.as_mut() else { 193 return Ok(RelaySubscriptionItem::Shutdown); 194 }; 195 loop { 196 if self 197 .originals 198 .as_ref() 199 .is_none_or(|scope| scope.exhausted()) 200 { 201 return Err(()); 202 } 203 let originals = self.originals.as_ref().ok_or(())?; 204 let received = tokio::select! { 205 biased; 206 _ = originals.wait_exhausted() => return Err(()), 207 received = notifications.next() => received, 208 }; 209 let notification = match received { 210 Some(Ok(notification)) => notification, 211 Some(Err(_)) => return Err(()), 212 None => { 213 return Ok(RelaySubscriptionItem::Shutdown); 214 } 215 }; 216 if self 217 .originals 218 .as_ref() 219 .is_none_or(|scope| scope.exhausted()) 220 { 221 return Err(()); 222 } 223 match notification { 224 ClientNotification::Message { relay_url, message } => { 225 let Some(relay) = self.relay_lookup.get(relay_url.as_str()).cloned() else { 226 continue; 227 }; 228 match *message { 229 RelayMessage::Event { 230 subscription_id, 231 event, 232 } if subscription_id.as_ref() == &self.subscription_id => { 233 let raw = self 234 .original_scopes 235 .get(relay_url.as_str()) 236 .and_then(|scope| scope.take(&event)) 237 .ok_or(())?; 238 return Ok(RelaySubscriptionItem::Event { relay, raw }); 239 } 240 RelayMessage::Closed { 241 subscription_id, .. 242 } if subscription_id.as_ref() == &self.subscription_id => { 243 return Ok(RelaySubscriptionItem::Closed { relay }); 244 } 245 _ => {} 246 } 247 } 248 ClientNotification::Shutdown => { 249 return Ok(RelaySubscriptionItem::Shutdown); 250 } 251 ClientNotification::Event { .. } => {} 252 } 253 } 254 }) 255 } 256 257 #[cfg_attr(coverage_nightly, coverage(off))] 258 fn cancel(&mut self) -> BoxFuture<'_, Result<(), ()>> { 259 Box::pin(async move { 260 if !self.cancelled { 261 let output = self 262 .client 263 .send_msg(ClientMessage::close(self.subscription_id.clone())) 264 .to(self.relay_lookup.keys().map(String::as_str)) 265 .await 266 .map_err(|_| ())?; 267 if !output.failed.is_empty() || output.success.len() != self.relay_lookup.len() { 268 return Err(()); 269 } 270 let output = self 271 .client 272 .unsubscribe(&self.subscription_id) 273 .await 274 .map_err(|_| ())?; 275 if !output.failed.is_empty() { 276 return Err(()); 277 } 278 self.cancelled = true; 279 self.notifications = None; 280 self.original_scopes.clear(); 281 self.originals = None; 282 } 283 Ok(()) 284 }) 285 } 286 } 287 288 struct RelayEventSubscription { 289 request: SubscriptionRequest, 290 session: Option<Box<dyn RelaySubscriptionSession>>, 291 targets: BTreeMap<RelayUrl, radroots_transport::Target>, 292 active_relays: BTreeSet<RelayUrl>, 293 resume_cursors: BTreeMap<radroots_transport::target::TargetFingerprint, RelayCursor>, 294 cursors: BTreeMap<radroots_transport::target::TargetFingerprint, RelayCursor>, 295 checkpoints: BTreeMap<radroots_transport::target::TargetFingerprint, SubscriptionCheckpoint>, 296 seen_event_ids: BTreeSet<String>, 297 event_count: u16, 298 terminal: Option<SubscriptionEnd>, 299 cancellation_requested: Arc<AtomicBool>, 300 status: Arc<crate::status::StatusTracker>, 301 } 302 303 impl RelayEventSubscription { 304 fn ended( 305 request: SubscriptionRequest, 306 reason: SubscriptionEndReason, 307 status: Arc<crate::status::StatusTracker>, 308 ) -> Result<Self, ()> { 309 let terminal = SubscriptionEnd::for_request(&request, 0, [], reason).map_err(|_| ())?; 310 Ok(Self { 311 request, 312 session: None, 313 targets: BTreeMap::new(), 314 active_relays: BTreeSet::new(), 315 resume_cursors: BTreeMap::new(), 316 cursors: BTreeMap::new(), 317 checkpoints: BTreeMap::new(), 318 seen_event_ids: BTreeSet::new(), 319 event_count: 0, 320 terminal: Some(terminal), 321 cancellation_requested: Arc::new(AtomicBool::new(false)), 322 status, 323 }) 324 } 325 326 async fn next_inner(&mut self) -> Result<SubscriptionNext, radroots_transport::Error> { 327 if let Some(terminal) = &self.terminal { 328 return Ok(SubscriptionNext::End(terminal.clone())); 329 } 330 if self.cancellation_requested.swap(false, Ordering::SeqCst) { 331 return self 332 .terminate(SubscriptionEndReason::Cancelled) 333 .await 334 .map(SubscriptionNext::End); 335 } 336 if self.event_count >= self.request.bounds().event_limit() { 337 return self 338 .terminate(SubscriptionEndReason::EventLimit) 339 .await 340 .map(SubscriptionNext::End); 341 } 342 343 loop { 344 let remaining = remaining_duration(self.request.bounds().deadline_unix_ms()); 345 if remaining.is_zero() { 346 return self 347 .terminate(SubscriptionEndReason::Deadline) 348 .await 349 .map(SubscriptionNext::End); 350 } 351 let item = { 352 let session = self 353 .session 354 .as_mut() 355 .ok_or(radroots_transport::Error::SubscriptionUnavailable)?; 356 crate::host_time::timeout(remaining, session.next()).await 357 }; 358 let item = match item { 359 Ok(Ok(item)) => item, 360 Ok(Err(())) => return Err(radroots_transport::Error::SubscriptionUnavailable), 361 Err(_) => { 362 return self 363 .terminate(SubscriptionEndReason::Deadline) 364 .await 365 .map(SubscriptionNext::End); 366 } 367 }; 368 match item { 369 RelaySubscriptionItem::Event { relay, raw } => { 370 if let Some(event) = self.admit_event(&relay, raw.as_str())? { 371 return Ok(SubscriptionNext::Event(Box::new(event))); 372 } 373 } 374 RelaySubscriptionItem::Closed { relay } => { 375 if !self.active_relays.remove(&relay) { 376 return Err(radroots_transport::Error::SubscriptionUnavailable); 377 } 378 if self.active_relays.is_empty() { 379 return self 380 .terminate(SubscriptionEndReason::SourceClosed) 381 .await 382 .map(SubscriptionNext::End); 383 } 384 } 385 RelaySubscriptionItem::Shutdown => { 386 return self 387 .terminate(SubscriptionEndReason::SourceClosed) 388 .await 389 .map(SubscriptionNext::End); 390 } 391 } 392 } 393 } 394 395 fn admit_event( 396 &mut self, 397 relay: &RelayUrl, 398 raw: &str, 399 ) -> Result<Option<SubscriptionEvent>, radroots_transport::Error> { 400 let target = self 401 .targets 402 .get(relay) 403 .ok_or(radroots_transport::Error::UnexpectedSubscriptionEvent)?; 404 let event = radroots_event_codec::decode::signed_event_with_limits( 405 raw, 406 crate::source::observed_limits(), 407 ) 408 .map_err(|_| radroots_transport::Error::UnexpectedSubscriptionEvent)?; 409 if !self.request.selector().matches(&event) { 410 return Err(radroots_transport::Error::UnexpectedSubscriptionEvent); 411 } 412 let event_id = event.id_str().to_owned(); 413 let created_at = event.created_at(); 414 if self.seen_event_ids.contains(event_id.as_str()) { 415 return Ok(None); 416 } 417 if self 418 .resume_cursors 419 .get(target.fingerprint()) 420 .is_some_and(|cursor| { 421 created_at < cursor.created_at_unix_s() 422 || (created_at == cursor.created_at_unix_s() 423 && event_id.as_str() == cursor.event_id()) 424 }) 425 { 426 return Ok(None); 427 } 428 429 let cursor = RelayCursor::new(created_at, event_id.clone()) 430 .map_err(|_| radroots_transport::Error::UnexpectedSubscriptionEvent)?; 431 let cursor_advances = self 432 .cursors 433 .get(target.fingerprint()) 434 .is_none_or(|current| cursor > *current); 435 if cursor_advances { 436 self.cursors 437 .insert(target.fingerprint().clone(), cursor.clone()); 438 let opaque = encode_cursor(&self.request, target.fingerprint(), &cursor)?; 439 self.checkpoints.insert( 440 target.fingerprint().clone(), 441 SubscriptionCheckpoint::new(target.fingerprint().clone(), opaque), 442 ); 443 } 444 let checkpoint = self 445 .checkpoints 446 .get(target.fingerprint()) 447 .cloned() 448 .ok_or(radroots_transport::Error::UnexpectedSubscriptionEvent)?; 449 let provenance = EventProvenance::new( 450 radroots_transport::TransportId::NOSTR, 451 target.fingerprint().clone(), 452 unix_time_ms().max(1), 453 )? 454 .with_cursor(checkpoint.cursor().clone()); 455 let observed = ObservedEvent::new(event, provenance); 456 let subscription_event = 457 SubscriptionEvent::for_request(&self.request, observed, checkpoint.clone())?; 458 459 self.seen_event_ids.insert(event_id); 460 self.event_count = self.event_count.saturating_add(1); 461 self.status 462 .record_read(relay, true, false, unix_time_ms().max(1)); 463 Ok(Some(subscription_event)) 464 } 465 466 async fn terminate( 467 &mut self, 468 mut reason: SubscriptionEndReason, 469 ) -> Result<SubscriptionEnd, radroots_transport::Error> { 470 if let Some(terminal) = &self.terminal { 471 return Ok(terminal.clone()); 472 } 473 if matches!( 474 reason, 475 SubscriptionEndReason::EventLimit | SubscriptionEndReason::Cancelled 476 ) { 477 let remaining = remaining_duration(self.request.bounds().deadline_unix_ms()); 478 if remaining.is_zero() { 479 reason = SubscriptionEndReason::Deadline; 480 } else if let Some(session) = self.session.as_mut() { 481 match crate::host_time::timeout(remaining, session.cancel()).await { 482 Ok(Ok(())) => {} 483 Ok(Err(())) => { 484 return Err(radroots_transport::Error::SubscriptionUnavailable); 485 } 486 Err(_) => reason = SubscriptionEndReason::Deadline, 487 } 488 } 489 } 490 self.session = None; 491 let terminal = SubscriptionEnd::for_request( 492 &self.request, 493 self.event_count, 494 self.checkpoints.values().cloned(), 495 reason, 496 )?; 497 self.terminal = Some(terminal.clone()); 498 Ok(terminal) 499 } 500 } 501 502 impl EventSubscription for RelayEventSubscription { 503 fn request(&self) -> &SubscriptionRequest { 504 &self.request 505 } 506 507 fn next(&mut self) -> BoxFuture<'_, Result<SubscriptionNext, radroots_transport::Error>> { 508 let cancellation = CancellationOnDrop::new(Arc::clone(&self.cancellation_requested)); 509 Box::pin(async move { 510 let result = self.next_inner().await; 511 cancellation.complete(); 512 result 513 }) 514 } 515 516 fn cancel(&mut self) -> BoxFuture<'_, Result<SubscriptionEnd, radroots_transport::Error>> { 517 let cancellation = CancellationOnDrop::new(Arc::clone(&self.cancellation_requested)); 518 Box::pin(async move { 519 let result = self.terminate(SubscriptionEndReason::Cancelled).await; 520 cancellation.complete(); 521 result 522 }) 523 } 524 } 525 526 impl EventSubscriber for NostrTransport { 527 fn subscribe( 528 &self, 529 request: SubscriptionRequest, 530 ) -> BoxFuture<'_, Result<BoxSubscription, radroots_transport::Error>> { 531 Box::pin(async move { 532 let _operation = self.connections.begin()?; 533 let remaining = remaining_duration(request.bounds().deadline_unix_ms()); 534 if remaining.is_zero() { 535 return RelayEventSubscription::ended( 536 request, 537 SubscriptionEndReason::Deadline, 538 Arc::clone(&self.status), 539 ) 540 .map(|subscription| Box::new(subscription) as BoxSubscription) 541 .map_err(|()| radroots_transport::Error::SubscriptionUnavailable); 542 } 543 if !selector_is_representable(request.selector()) { 544 return RelayEventSubscription::ended( 545 request, 546 SubscriptionEndReason::SourceClosed, 547 Arc::clone(&self.status), 548 ) 549 .map(|subscription| Box::new(subscription) as BoxSubscription) 550 .map_err(|()| radroots_transport::Error::SubscriptionUnavailable); 551 } 552 553 let now_ms = unix_time_ms(); 554 let mut targets = BTreeMap::new(); 555 let mut active_relays = BTreeSet::new(); 556 for target in request.target_set().targets() { 557 let endpoint = self 558 .config() 559 .endpoint_for_target(target) 560 .filter(|endpoint| endpoint.access().can_read()) 561 .ok_or(radroots_transport::Error::SubscriptionUnavailable)?; 562 if !self.status.may_read(endpoint.url(), now_ms) 563 || targets 564 .insert(endpoint.url().clone(), target.clone()) 565 .is_some() 566 { 567 return Err(radroots_transport::Error::SubscriptionUnavailable); 568 } 569 active_relays.insert(endpoint.url().clone()); 570 } 571 572 let mut cursors = BTreeMap::new(); 573 let mut checkpoints = BTreeMap::new(); 574 let mut target_queries = Vec::with_capacity(targets.len()); 575 for (relay, target) in &targets { 576 let checkpoint = request 577 .checkpoints() 578 .iter() 579 .find(|checkpoint| checkpoint.target() == target.fingerprint()); 580 let cursor = checkpoint 581 .map(|checkpoint| parse_cursor(&request, checkpoint)) 582 .transpose()?; 583 let since = cursor 584 .as_ref() 585 .map(RelayCursor::created_at_unix_s) 586 .or(request.selector().since_unix_seconds()); 587 if let Some(cursor) = cursor { 588 cursors.insert(target.fingerprint().clone(), cursor); 589 } 590 if let Some(checkpoint) = checkpoint { 591 checkpoints.insert(target.fingerprint().clone(), checkpoint.clone()); 592 } 593 target_queries.push(RelaySubscriptionTarget { 594 relay: relay.clone(), 595 since_unix_seconds: since, 596 }); 597 } 598 599 let timeout = remaining.min(Duration::from_millis(self.config().request_timeout_ms())); 600 let id = subscription_id(&request, self.next_subscription_sequence()?); 601 for relay in &active_relays { 602 self.status.begin_read(relay, now_ms); 603 } 604 let query = RelaySubscriptionQuery { 605 id, 606 targets: target_queries, 607 selector: request.selector().clone(), 608 connect_timeout: timeout 609 .min(Duration::from_millis(self.config().connect_timeout_ms())), 610 timeout: remaining, 611 }; 612 let session = 613 match crate::host_time::timeout(timeout, self.subscription_client.subscribe(query)) 614 .await 615 { 616 Ok(Ok(session)) => session, 617 Ok(Err(())) | Err(_) => { 618 let observed_at = unix_time_ms().max(1); 619 for relay in &active_relays { 620 self.status.record_read(relay, false, true, observed_at); 621 } 622 return Err(radroots_transport::Error::SubscriptionUnavailable); 623 } 624 }; 625 626 let resume_cursors = cursors.clone(); 627 Ok(Box::new(RelayEventSubscription { 628 request, 629 session: Some(session), 630 targets, 631 active_relays, 632 resume_cursors, 633 cursors, 634 checkpoints, 635 seen_event_ids: BTreeSet::new(), 636 event_count: 0, 637 terminal: None, 638 cancellation_requested: Arc::new(AtomicBool::new(false)), 639 status: Arc::clone(&self.status), 640 }) as BoxSubscription) 641 }) 642 } 643 } 644 645 struct CancellationOnDrop { 646 requested: Arc<AtomicBool>, 647 completed: AtomicBool, 648 } 649 650 impl CancellationOnDrop { 651 fn new(requested: Arc<AtomicBool>) -> Arc<Self> { 652 Arc::new(Self { 653 requested, 654 completed: AtomicBool::new(false), 655 }) 656 } 657 658 fn complete(&self) { 659 self.completed.store(true, Ordering::SeqCst); 660 } 661 } 662 663 impl Drop for CancellationOnDrop { 664 fn drop(&mut self) { 665 if !self.completed.load(Ordering::SeqCst) { 666 self.requested.store(true, Ordering::SeqCst); 667 } 668 } 669 } 670 671 fn subscription_filter( 672 selector: &radroots_transport::source::FetchSelector, 673 since: Option<u64>, 674 ) -> Result<Filter, ()> { 675 let kinds = selector 676 .kinds() 677 .iter() 678 .filter_map(|kind| u16::try_from(*kind).ok()) 679 .map(Kind::from) 680 .collect::<Vec<_>>(); 681 if !selector.kinds().is_empty() && kinds.is_empty() { 682 return Err(()); 683 } 684 let authors = selector 685 .authors() 686 .iter() 687 .map(|author| PublicKey::from_slice(author.as_bytes()).map_err(|_| ())) 688 .collect::<Result<Vec<_>, _>>()?; 689 let mut filter = Filter::new(); 690 if !kinds.is_empty() { 691 filter = filter.kinds(kinds); 692 } 693 if !authors.is_empty() { 694 filter = filter.authors(authors); 695 } 696 filter = crate::source::apply_exact_tag_filters(filter, selector)?; 697 if let Some(since) = since { 698 filter = filter.since(Timestamp::from_secs(since)); 699 } 700 if let Some(until) = selector.until_unix_seconds() { 701 filter = filter.until(Timestamp::from_secs(until)); 702 } 703 Ok(filter) 704 } 705 706 fn selector_is_representable(selector: &radroots_transport::source::FetchSelector) -> bool { 707 selector.kinds().is_empty() 708 || selector 709 .kinds() 710 .iter() 711 .any(|kind| u16::try_from(*kind).is_ok()) 712 } 713 714 fn subscription_id(request: &SubscriptionRequest, sequence: u64) -> String { 715 let mut hasher = Sha256::new(); 716 hasher.update(SUBSCRIPTION_ID_DOMAIN); 717 hasher.update(request.request_id().as_str().as_bytes()); 718 hasher.update([0]); 719 hasher.update(sequence.to_be_bytes()); 720 hex_encode(&hasher.finalize()) 721 } 722 723 fn encode_cursor( 724 request: &SubscriptionRequest, 725 target: &radroots_transport::target::TargetFingerprint, 726 cursor: &RelayCursor, 727 ) -> Result<FetchCursor, radroots_transport::Error> { 728 FetchCursor::parse(format!( 729 "{CURSOR_PREFIX}:{}:{}:{}", 730 cursor.created_at_unix_s(), 731 cursor.event_id(), 732 cursor_scope(request, target), 733 )) 734 } 735 736 fn parse_cursor( 737 request: &SubscriptionRequest, 738 checkpoint: &SubscriptionCheckpoint, 739 ) -> Result<RelayCursor, radroots_transport::Error> { 740 let mut parts = checkpoint.cursor().as_str().split(':'); 741 let valid = parts.next() == Some(CURSOR_PREFIX); 742 let created_at = parts.next().and_then(|value| value.parse::<u64>().ok()); 743 let event_id = parts.next(); 744 let scope = parts.next(); 745 if !valid || parts.next().is_some() { 746 return Err(radroots_transport::Error::InvalidFetchCursor); 747 } 748 let (Some(created_at), Some(event_id), Some(scope)) = (created_at, event_id, scope) else { 749 return Err(radroots_transport::Error::InvalidFetchCursor); 750 }; 751 if scope != cursor_scope(request, checkpoint.target()) { 752 return Err(radroots_transport::Error::InvalidFetchCursor); 753 } 754 RelayCursor::new(created_at, event_id) 755 .map_err(|_| radroots_transport::Error::InvalidFetchCursor) 756 } 757 758 fn cursor_scope( 759 request: &SubscriptionRequest, 760 target: &radroots_transport::target::TargetFingerprint, 761 ) -> String { 762 let mut hasher = Sha256::new(); 763 hasher.update(CURSOR_SCOPE_DOMAIN); 764 hasher.update(target.as_str().as_bytes()); 765 hasher.update([0]); 766 for kind in request.selector().kinds() { 767 hasher.update(kind.to_be_bytes()); 768 } 769 hasher.update([0]); 770 for author in request.selector().authors() { 771 hasher.update(author.as_bytes()); 772 } 773 hasher.update([0]); 774 crate::source::hash_exact_tag_filters(&mut hasher, request.selector()); 775 hash_optional_u64(&mut hasher, request.selector().since_unix_seconds()); 776 hash_optional_u64(&mut hasher, request.selector().until_unix_seconds()); 777 hex_encode(&hasher.finalize()) 778 } 779 780 fn hash_optional_u64(hasher: &mut Sha256, value: Option<u64>) { 781 match value { 782 Some(value) => { 783 hasher.update([1]); 784 hasher.update(value.to_be_bytes()); 785 } 786 None => hasher.update([0]), 787 } 788 } 789 790 fn remaining_duration(deadline_unix_ms: u64) -> Duration { 791 Duration::from_millis(deadline_unix_ms.saturating_sub(unix_time_ms())) 792 } 793 794 fn hex_encode(bytes: &[u8]) -> String { 795 const HEX: &[u8; 16] = b"0123456789abcdef"; 796 let mut encoded = String::with_capacity(bytes.len() * 2); 797 for byte in bytes { 798 encoded.push(HEX[(byte >> 4) as usize] as char); 799 encoded.push(HEX[(byte & 0x0f) as usize] as char); 800 } 801 encoded 802 } 803 804 #[cfg(test)] 805 mod tests { 806 use super::*; 807 use crate::{ 808 Config, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind, RelayUrlPolicy, 809 }; 810 use nostr_sdk::prelude::{EventBuilder, FinalizeEvent, Keys}; 811 use radroots_transport::{ 812 EventSubscriber, Target, TargetSet, 813 source::{FetchSelector, SubscriptionBounds, SubscriptionCheckpoint}, 814 }; 815 use std::{ 816 collections::VecDeque, 817 sync::{ 818 Arc, Mutex, 819 atomic::{AtomicBool, AtomicUsize, Ordering as AtomicOrdering}, 820 }, 821 }; 822 823 const FIXTURE_SECRET_KEY: &str = 824 "0000000000000000000000000000000000000000000000000000000000000001"; 825 826 #[derive(Clone, Debug)] 827 enum ScriptedItem { 828 Item(RelaySubscriptionItem), 829 Error, 830 } 831 832 #[derive(Debug)] 833 struct MockSubscriptionSession { 834 items: VecDeque<ScriptedItem>, 835 cancellations: Arc<AtomicUsize>, 836 } 837 838 impl RelaySubscriptionSession for MockSubscriptionSession { 839 fn next(&mut self) -> BoxFuture<'_, Result<RelaySubscriptionItem, ()>> { 840 match self.items.pop_front() { 841 Some(ScriptedItem::Item(item)) => Box::pin(async move { Ok(item) }), 842 Some(ScriptedItem::Error) => Box::pin(async { Err(()) }), 843 None => Box::pin(core::future::pending()), 844 } 845 } 846 847 fn cancel(&mut self) -> BoxFuture<'_, Result<(), ()>> { 848 self.cancellations.fetch_add(1, AtomicOrdering::SeqCst); 849 Box::pin(async { Ok(()) }) 850 } 851 } 852 853 #[derive(Debug)] 854 struct MockSubscriptionClient { 855 queries: Mutex<Vec<RelaySubscriptionQuery>>, 856 items: Mutex<Option<VecDeque<ScriptedItem>>>, 857 cancellations: Arc<AtomicUsize>, 858 fail: AtomicBool, 859 } 860 861 impl MockSubscriptionClient { 862 fn new(items: impl IntoIterator<Item = ScriptedItem>) -> Self { 863 Self { 864 queries: Mutex::new(Vec::new()), 865 items: Mutex::new(Some(items.into_iter().collect())), 866 cancellations: Arc::new(AtomicUsize::new(0)), 867 fail: AtomicBool::new(false), 868 } 869 } 870 871 fn failing() -> Self { 872 let client = Self::new([]); 873 client.fail.store(true, AtomicOrdering::SeqCst); 874 client 875 } 876 877 fn query(&self) -> RelaySubscriptionQuery { 878 self.queries.lock().expect("queries")[0].clone() 879 } 880 } 881 882 impl RelaySubscriptionClient for MockSubscriptionClient { 883 fn subscribe( 884 &self, 885 query: RelaySubscriptionQuery, 886 ) -> BoxFuture<'_, Result<Box<dyn RelaySubscriptionSession>, ()>> { 887 self.queries.lock().expect("queries").push(query); 888 if self.fail.load(AtomicOrdering::SeqCst) { 889 return Box::pin(async { Err(()) }); 890 } 891 let items = self.items.lock().expect("items").take().unwrap_or_default(); 892 let session = MockSubscriptionSession { 893 items, 894 cancellations: Arc::clone(&self.cancellations), 895 }; 896 Box::pin(async move { Ok(Box::new(session) as Box<dyn RelaySubscriptionSession>) }) 897 } 898 } 899 900 fn configured(relays: &[&str]) -> Config { 901 let endpoints = relays 902 .iter() 903 .map(|relay| { 904 RelayEndpoint::new(relay, RelayUrlPolicy::Public, RelayAccess::ReadWrite) 905 .expect("endpoint") 906 }) 907 .collect::<Vec<_>>(); 908 Config::from_profile( 909 RelayProfile::explicit(RelayProfileKind::Public, endpoints).expect("profile"), 910 ) 911 } 912 913 fn target_set(relays: &[&str]) -> TargetSet { 914 TargetSet::new( 915 relays 916 .iter() 917 .map(|relay| Target::nostr_relay(relay).expect("target")) 918 .collect::<Vec<_>>(), 919 ) 920 .expect("target set") 921 } 922 923 fn request(relays: &[&str], event_limit: u16) -> SubscriptionRequest { 924 SubscriptionRequest::new( 925 "nostr-live", 926 target_set(relays), 927 SubscriptionBounds::new(event_limit, unix_time_ms() + 60_000).expect("bounds"), 928 ) 929 .expect("request") 930 } 931 932 fn signed_event(content: &str, created_at: u64) -> String { 933 EventBuilder::new(Kind::TextNote, content) 934 .custom_created_at(Timestamp::from_secs(created_at)) 935 .finalize(&Keys::parse(FIXTURE_SECRET_KEY).expect("fixture keys")) 936 .expect("signed event") 937 .as_json() 938 } 939 940 fn event_id(raw: &str) -> String { 941 radroots_event_codec::decode::signed_event(raw) 942 .expect("signed event") 943 .id_str() 944 .to_owned() 945 } 946 947 #[tokio::test] 948 async fn subscription_translates_targets_selector_and_unique_ids() { 949 let relay = "wss://one.example"; 950 let client = Arc::new(MockSubscriptionClient::new([ScriptedItem::Item( 951 RelaySubscriptionItem::Shutdown, 952 )])); 953 let transport = 954 NostrTransport::with_subscription_client(configured(&[relay]), client.clone()); 955 let selector = FetchSelector::all() 956 .with_kinds(vec![1]) 957 .expect("kind") 958 .with_authors(vec![ 959 *radroots_event_codec::decode::signed_event(&signed_event( 960 "subscription-author", 961 1_800_000_000, 962 )) 963 .expect("signed author event") 964 .pubkey(), 965 ]) 966 .expect("author") 967 .with_exact_tag_value('d', "trade-1") 968 .expect("tag") 969 .with_since_unix_seconds(1_700_000_000) 970 .expect("since") 971 .with_until_unix_seconds(1_800_000_000) 972 .expect("until"); 973 let first = transport 974 .subscribe(request(&[relay], 2).with_selector(selector.clone())) 975 .await 976 .expect("first subscription"); 977 drop(first); 978 let second = transport 979 .subscribe(request(&[relay], 2).with_selector(selector.clone())) 980 .await 981 .expect("second subscription"); 982 drop(second); 983 984 let queries = client.queries.lock().expect("queries"); 985 assert_eq!(queries.len(), 2); 986 assert_ne!(queries[0].id, queries[1].id); 987 assert_eq!(queries[0].targets.len(), 1); 988 assert_eq!(queries[0].targets[0].relay.as_str(), relay); 989 assert_eq!( 990 queries[0].targets[0].since_unix_seconds, 991 Some(1_700_000_000) 992 ); 993 assert_eq!(queries[0].selector, selector); 994 assert!(queries[0].connect_timeout <= queries[0].timeout); 995 996 let filter = subscription_filter(&queries[0].selector, Some(1_700_000_000)) 997 .expect("filter") 998 .as_json(); 999 assert!(filter.contains("\"kinds\":[1]")); 1000 assert!(filter.contains("\"#d\":[\"trade-1\"]")); 1001 assert!(filter.contains("\"since\":1700000000")); 1002 assert!(filter.contains("\"until\":1800000000")); 1003 } 1004 1005 #[tokio::test] 1006 async fn reconnect_checkpoint_is_equal_timestamp_safe_and_request_bound() { 1007 let relay = "wss://one.example"; 1008 let mut events = [ 1009 signed_event("equal-a", 1_800_000_000), 1010 signed_event("equal-b", 1_800_000_000), 1011 signed_event("equal-c", 1_800_000_000), 1012 ]; 1013 events.sort_by_key(|event| event_id(event)); 1014 let base_request = request(&[relay], 3); 1015 let target = base_request.target_set().targets()[0].fingerprint().clone(); 1016 let middle_cursor = RelayCursor::new(1_800_000_000, event_id(&events[1])).expect("cursor"); 1017 let checkpoint = SubscriptionCheckpoint::new( 1018 target, 1019 encode_cursor( 1020 &base_request, 1021 base_request.target_set().targets()[0].fingerprint(), 1022 &middle_cursor, 1023 ) 1024 .expect("opaque cursor"), 1025 ); 1026 let resumed = base_request 1027 .with_checkpoints([checkpoint]) 1028 .expect("checkpointed request"); 1029 let relay_url = RelayUrl::parse(relay, RelayUrlPolicy::Public).expect("relay"); 1030 let older = signed_event("older", 1_799_999_999); 1031 let later = signed_event("later", 1_800_000_001); 1032 let client = Arc::new(MockSubscriptionClient::new([ 1033 ScriptedItem::Item(RelaySubscriptionItem::Event { 1034 relay: relay_url.clone(), 1035 raw: older, 1036 }), 1037 ScriptedItem::Item(RelaySubscriptionItem::Event { 1038 relay: relay_url.clone(), 1039 raw: events[0].clone(), 1040 }), 1041 ScriptedItem::Item(RelaySubscriptionItem::Event { 1042 relay: relay_url.clone(), 1043 raw: events[1].clone(), 1044 }), 1045 ScriptedItem::Item(RelaySubscriptionItem::Event { 1046 relay: relay_url.clone(), 1047 raw: events[2].clone(), 1048 }), 1049 ScriptedItem::Item(RelaySubscriptionItem::Event { 1050 relay: relay_url, 1051 raw: later.clone(), 1052 }), 1053 ])); 1054 let transport = 1055 NostrTransport::with_subscription_client(configured(&[relay]), client.clone()); 1056 let mut subscription = transport.subscribe(resumed).await.expect("subscription"); 1057 let SubscriptionNext::Event(event) = subscription.next().await.expect("next event") else { 1058 panic!("event expected"); 1059 }; 1060 assert_eq!(event.observed().event().id_str(), event_id(&events[0])); 1061 assert_eq!( 1062 event.checkpoint().cursor().as_str().split(':').nth(2), 1063 Some(event_id(&events[1]).as_str()) 1064 ); 1065 let SubscriptionNext::Event(event) = subscription.next().await.expect("next event") else { 1066 panic!("event expected"); 1067 }; 1068 assert_eq!(event.observed().event().id_str(), event_id(&events[2])); 1069 assert_eq!( 1070 event.checkpoint().cursor().as_str().split(':').nth(2), 1071 Some(event_id(&events[2]).as_str()) 1072 ); 1073 let SubscriptionNext::Event(event) = subscription.next().await.expect("next event") else { 1074 panic!("event expected"); 1075 }; 1076 assert_eq!(event.observed().event().id_str(), event_id(&later)); 1077 assert_eq!( 1078 client.query().targets[0].since_unix_seconds, 1079 Some(1_800_000_000) 1080 ); 1081 } 1082 1083 #[tokio::test] 1084 async fn live_subscription_accepts_same_second_events_in_relay_arrival_order() { 1085 let relay = "wss://one.example"; 1086 let relay_url = RelayUrl::parse(relay, RelayUrlPolicy::Public).expect("relay"); 1087 let mut events = [ 1088 signed_event("same-second-a", 1_800_000_000), 1089 signed_event("same-second-b", 1_800_000_000), 1090 ]; 1091 events.sort_by_key(|event| event_id(event)); 1092 let client = Arc::new(MockSubscriptionClient::new([ 1093 ScriptedItem::Item(RelaySubscriptionItem::Event { 1094 relay: relay_url.clone(), 1095 raw: events[1].clone(), 1096 }), 1097 ScriptedItem::Item(RelaySubscriptionItem::Event { 1098 relay: relay_url.clone(), 1099 raw: events[1].clone(), 1100 }), 1101 ScriptedItem::Item(RelaySubscriptionItem::Event { 1102 relay: relay_url, 1103 raw: events[0].clone(), 1104 }), 1105 ])); 1106 let transport = NostrTransport::with_subscription_client(configured(&[relay]), client); 1107 let mut subscription = transport 1108 .subscribe(request(&[relay], 2)) 1109 .await 1110 .expect("subscription"); 1111 1112 for expected in [&events[1], &events[0]] { 1113 let SubscriptionNext::Event(event) = subscription.next().await.expect("next event") 1114 else { 1115 panic!("event expected"); 1116 }; 1117 assert_eq!(event.observed().event().id_str(), event_id(expected)); 1118 assert_eq!( 1119 event.checkpoint().cursor().as_str().split(':').nth(2), 1120 Some(event_id(&events[1]).as_str()) 1121 ); 1122 } 1123 } 1124 1125 #[tokio::test] 1126 async fn malformed_or_mismatched_checkpoint_fails_before_backend_work() { 1127 let relay = "wss://one.example"; 1128 let client = Arc::new(MockSubscriptionClient::new([])); 1129 let transport = 1130 NostrTransport::with_subscription_client(configured(&[relay]), client.clone()); 1131 let base = request(&[relay], 1); 1132 let target = base.target_set().targets()[0].fingerprint().clone(); 1133 let malformed = base 1134 .clone() 1135 .with_checkpoints([SubscriptionCheckpoint::new( 1136 target.clone(), 1137 FetchCursor::parse("not-a-live-cursor").expect("opaque cursor"), 1138 )]) 1139 .expect("request checkpoint"); 1140 assert_eq!( 1141 transport.subscribe(malformed).await.err(), 1142 Some(radroots_transport::Error::InvalidFetchCursor) 1143 ); 1144 1145 let other_selector = FetchSelector::all() 1146 .with_exact_tag_value('d', "trade-1") 1147 .expect("selector"); 1148 let scoped = encode_cursor( 1149 &base, 1150 &target, 1151 &RelayCursor::new(10, "a".repeat(64)).expect("cursor"), 1152 ) 1153 .expect("scoped cursor"); 1154 for malformed_cursor in [ 1155 FetchCursor::parse("nostr-live-v1:10").expect("opaque missing-field cursor"), 1156 FetchCursor::parse(format!("{}:extra", scoped.as_str())) 1157 .expect("opaque extra-field cursor"), 1158 ] { 1159 let checkpoint = SubscriptionCheckpoint::new(target.clone(), malformed_cursor); 1160 assert_eq!( 1161 parse_cursor(&base, &checkpoint), 1162 Err(radroots_transport::Error::InvalidFetchCursor) 1163 ); 1164 } 1165 let mismatched = base 1166 .with_selector(other_selector) 1167 .with_checkpoints([SubscriptionCheckpoint::new(target, scoped)]) 1168 .expect("request checkpoint"); 1169 assert_eq!( 1170 transport.subscribe(mismatched).await.err(), 1171 Some(radroots_transport::Error::InvalidFetchCursor) 1172 ); 1173 assert!(client.queries.lock().expect("queries").is_empty()); 1174 } 1175 1176 #[test] 1177 fn dropping_an_unpolled_subscription_start_performs_no_backend_work() { 1178 let relay = "wss://one.example"; 1179 let client = Arc::new(MockSubscriptionClient::new([])); 1180 let transport = 1181 NostrTransport::with_subscription_client(configured(&[relay]), client.clone()); 1182 let future = transport.subscribe(request(&[relay], 1)); 1183 drop(future); 1184 assert!(client.queries.lock().expect("queries").is_empty()); 1185 } 1186 1187 #[tokio::test] 1188 async fn event_limit_and_explicit_cancellation_are_stable_and_idempotent() { 1189 let relay = "wss://one.example"; 1190 let relay_url = RelayUrl::parse(relay, RelayUrlPolicy::Public).expect("relay"); 1191 let client = Arc::new(MockSubscriptionClient::new([ScriptedItem::Item( 1192 RelaySubscriptionItem::Event { 1193 relay: relay_url, 1194 raw: signed_event("bounded", 1_800_000_001), 1195 }, 1196 )])); 1197 let transport = 1198 NostrTransport::with_subscription_client(configured(&[relay]), client.clone()); 1199 let mut subscription = transport 1200 .subscribe(request(&[relay], 1)) 1201 .await 1202 .expect("subscription"); 1203 assert!(matches!( 1204 subscription.next().await.expect("event"), 1205 SubscriptionNext::Event(_) 1206 )); 1207 let SubscriptionNext::End(limit) = subscription.next().await.expect("limit") else { 1208 panic!("terminal expected"); 1209 }; 1210 assert_eq!(limit.reason(), SubscriptionEndReason::EventLimit); 1211 assert_eq!(limit.event_count(), 1); 1212 assert_eq!(limit.checkpoints().len(), 1); 1213 assert_eq!(subscription.cancel().await.expect("stable cancel"), limit); 1214 assert_eq!(client.cancellations.load(AtomicOrdering::SeqCst), 1); 1215 1216 let cancel_client = Arc::new(MockSubscriptionClient::new([])); 1217 let cancel_transport = 1218 NostrTransport::with_subscription_client(configured(&[relay]), cancel_client.clone()); 1219 let mut cancelled = cancel_transport 1220 .subscribe(request(&[relay], 2)) 1221 .await 1222 .expect("subscription"); 1223 let terminal = cancelled.cancel().await.expect("cancel"); 1224 assert_eq!(terminal.reason(), SubscriptionEndReason::Cancelled); 1225 assert_eq!(cancelled.cancel().await.expect("repeat cancel"), terminal); 1226 assert_eq!(cancel_client.cancellations.load(AtomicOrdering::SeqCst), 1); 1227 } 1228 1229 #[tokio::test] 1230 async fn dropping_pending_next_requests_cancellation_on_the_next_call() { 1231 let relay = "wss://one.example"; 1232 let client = Arc::new(MockSubscriptionClient::new([])); 1233 let transport = 1234 NostrTransport::with_subscription_client(configured(&[relay]), client.clone()); 1235 let mut subscription = transport 1236 .subscribe(request(&[relay], 2)) 1237 .await 1238 .expect("subscription"); 1239 let mut pending = subscription.next(); 1240 assert!(futures::poll!(pending.as_mut()).is_pending()); 1241 drop(pending); 1242 let SubscriptionNext::End(terminal) = subscription.next().await.expect("cancelled") else { 1243 panic!("terminal expected"); 1244 }; 1245 assert_eq!(terminal.reason(), SubscriptionEndReason::Cancelled); 1246 assert_eq!(client.cancellations.load(AtomicOrdering::SeqCst), 1); 1247 } 1248 1249 #[tokio::test] 1250 async fn an_admitted_subscription_that_expires_before_next_is_deadline_bounded() { 1251 let relay = "wss://one.example"; 1252 let client = Arc::new(MockSubscriptionClient::new([])); 1253 let transport = NostrTransport::with_subscription_client(configured(&[relay]), client); 1254 let request = SubscriptionRequest::new( 1255 "expires-after-admission", 1256 target_set(&[relay]), 1257 SubscriptionBounds::new(1, unix_time_ms() + 50).expect("bounds"), 1258 ) 1259 .expect("request"); 1260 let mut subscription = transport.subscribe(request).await.expect("subscription"); 1261 tokio::time::sleep(Duration::from_millis(75)).await; 1262 1263 let SubscriptionNext::End(terminal) = subscription.next().await.expect("deadline") else { 1264 panic!("terminal expected"); 1265 }; 1266 assert_eq!(terminal.reason(), SubscriptionEndReason::Deadline); 1267 } 1268 1269 #[tokio::test] 1270 async fn expired_unrepresentable_closed_and_failed_sources_are_bounded() { 1271 let relay = "wss://one.example"; 1272 let client = Arc::new(MockSubscriptionClient::new([])); 1273 let transport = 1274 NostrTransport::with_subscription_client(configured(&[relay]), client.clone()); 1275 let expired = SubscriptionRequest::new( 1276 "expired", 1277 target_set(&[relay]), 1278 SubscriptionBounds::new(1, 1).expect("bounds"), 1279 ) 1280 .expect("request"); 1281 let mut expired = transport 1282 .subscribe(expired) 1283 .await 1284 .expect("expired capability"); 1285 let SubscriptionNext::End(terminal) = expired.next().await.expect("deadline") else { 1286 panic!("terminal expected"); 1287 }; 1288 assert_eq!(terminal.reason(), SubscriptionEndReason::Deadline); 1289 1290 let unsupported = request(&[relay], 1).with_selector( 1291 FetchSelector::all() 1292 .with_kinds(vec![u32::MAX]) 1293 .expect("selector"), 1294 ); 1295 let mut unsupported = transport 1296 .subscribe(unsupported) 1297 .await 1298 .expect("closed capability"); 1299 let SubscriptionNext::End(terminal) = unsupported.next().await.expect("source closed") 1300 else { 1301 panic!("terminal expected"); 1302 }; 1303 assert_eq!(terminal.reason(), SubscriptionEndReason::SourceClosed); 1304 assert!(client.queries.lock().expect("queries").is_empty()); 1305 1306 let deadline_request = SubscriptionRequest::new( 1307 "pending-deadline", 1308 target_set(&[relay]), 1309 SubscriptionBounds::new(1, unix_time_ms() + 100).expect("bounds"), 1310 ) 1311 .expect("request"); 1312 let mut deadline = transport 1313 .subscribe(deadline_request) 1314 .await 1315 .expect("deadline capability"); 1316 let SubscriptionNext::End(terminal) = deadline.next().await.expect("deadline") else { 1317 panic!("terminal expected"); 1318 }; 1319 assert_eq!(terminal.reason(), SubscriptionEndReason::Deadline); 1320 assert_eq!(client.cancellations.load(AtomicOrdering::SeqCst), 0); 1321 1322 let failed = Arc::new(MockSubscriptionClient::failing()); 1323 let failed_transport = 1324 NostrTransport::with_subscription_client(configured(&[relay]), failed.clone()); 1325 assert_eq!( 1326 failed_transport.subscribe(request(&[relay], 1)).await.err(), 1327 Some(radroots_transport::Error::SubscriptionUnavailable) 1328 ); 1329 assert_eq!(failed.queries.lock().expect("queries").len(), 1); 1330 } 1331 1332 #[tokio::test] 1333 async fn source_closure_backend_failure_and_event_admission_are_explicit() { 1334 let relays = ["wss://one.example", "wss://two.example"]; 1335 let one = RelayUrl::parse(relays[0], RelayUrlPolicy::Public).expect("one"); 1336 let two = RelayUrl::parse(relays[1], RelayUrlPolicy::Public).expect("two"); 1337 let client = Arc::new(MockSubscriptionClient::new([ 1338 ScriptedItem::Item(RelaySubscriptionItem::Closed { relay: one }), 1339 ScriptedItem::Item(RelaySubscriptionItem::Closed { relay: two }), 1340 ])); 1341 let transport = 1342 NostrTransport::with_subscription_client(configured(&relays), client.clone()); 1343 let mut subscription = transport 1344 .subscribe(request(&relays, 2)) 1345 .await 1346 .expect("subscription"); 1347 let SubscriptionNext::End(terminal) = subscription.next().await.expect("closed") else { 1348 panic!("terminal expected"); 1349 }; 1350 assert_eq!(terminal.reason(), SubscriptionEndReason::SourceClosed); 1351 assert_eq!(client.cancellations.load(AtomicOrdering::SeqCst), 0); 1352 1353 let unexpected_close = Arc::new(MockSubscriptionClient::new([ScriptedItem::Item( 1354 RelaySubscriptionItem::Closed { 1355 relay: RelayUrl::parse("wss://unexpected.example", RelayUrlPolicy::Public) 1356 .expect("unexpected relay"), 1357 }, 1358 )])); 1359 let unexpected_transport = 1360 NostrTransport::with_subscription_client(configured(&[relays[0]]), unexpected_close); 1361 let mut unexpected = unexpected_transport 1362 .subscribe(request(&[relays[0]], 1)) 1363 .await 1364 .expect("subscription"); 1365 assert_eq!( 1366 unexpected.next().await, 1367 Err(radroots_transport::Error::SubscriptionUnavailable) 1368 ); 1369 1370 let error_client = Arc::new(MockSubscriptionClient::new([ScriptedItem::Error])); 1371 let error_transport = 1372 NostrTransport::with_subscription_client(configured(&[relays[0]]), error_client); 1373 let mut subscription = error_transport 1374 .subscribe(request(&[relays[0]], 1)) 1375 .await 1376 .expect("subscription"); 1377 assert_eq!( 1378 subscription.next().await, 1379 Err(radroots_transport::Error::SubscriptionUnavailable) 1380 ); 1381 1382 let mismatch_client = Arc::new(MockSubscriptionClient::new([ScriptedItem::Item( 1383 RelaySubscriptionItem::Event { 1384 relay: RelayUrl::parse(relays[0], RelayUrlPolicy::Public).expect("relay"), 1385 raw: signed_event("wrong-kind", 1_800_000_002), 1386 }, 1387 )])); 1388 let mismatch_transport = 1389 NostrTransport::with_subscription_client(configured(&[relays[0]]), mismatch_client); 1390 let selector = FetchSelector::all().with_kinds(vec![2]).expect("selector"); 1391 let mut subscription = mismatch_transport 1392 .subscribe(request(&[relays[0]], 1).with_selector(selector)) 1393 .await 1394 .expect("subscription"); 1395 assert_eq!( 1396 subscription.next().await, 1397 Err(radroots_transport::Error::UnexpectedSubscriptionEvent) 1398 ); 1399 } 1400 1401 #[test] 1402 fn empty_and_unrepresentable_selectors_never_gain_implicit_wire_filters() { 1403 assert_eq!( 1404 subscription_filter(&FetchSelector::all(), None).unwrap(), 1405 Filter::new() 1406 ); 1407 let unsupported = FetchSelector::all().with_kinds(vec![u32::MAX]).unwrap(); 1408 assert!(!selector_is_representable(&unsupported)); 1409 assert!(subscription_filter(&unsupported, None).is_err()); 1410 let partial = FetchSelector::all().with_kinds(vec![1, u32::MAX]).unwrap(); 1411 assert!(selector_is_representable(&partial)); 1412 assert_eq!( 1413 subscription_filter(&partial, None).unwrap(), 1414 Filter::new().kind(Kind::TextNote) 1415 ); 1416 } 1417 }