lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

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 }