lib

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

source.rs (81363B)


      1 //! Nostr implementation of the transport event source.
      2 
      3 use crate::host_time::unix_time_ms;
      4 use crate::{NostrTransport, RelayCursor, RelayUrl, status};
      5 use core::cmp::Ordering;
      6 use core::time::Duration;
      7 use futures::{Stream, StreamExt, stream};
      8 use nostr_sdk::prelude::{
      9     Filter, Kind, PublicKey, RelayMessage, RelayNotification, ReqExitPolicy, SingleLetterTag,
     10     SubscribeAutoCloseOptions, SubscriptionId, Timestamp,
     11 };
     12 use radroots_transport::{
     13     BoxFuture, EventSource, FetchPage, FetchRequest,
     14     outcome::{FetchTargetOutcome, FetchTargetState},
     15     source::{EventProvenance, FetchCursor, NextPage, ObservedEvent, SourceStatus},
     16 };
     17 use sha2::{Digest, Sha256};
     18 use std::collections::{BTreeMap, BTreeSet};
     19 use std::sync::Arc;
     20 
     21 #[path = "source_budget.rs"]
     22 pub(crate) mod budget;
     23 use budget::FetchBudget;
     24 
     25 #[path = "source_window.rs"]
     26 mod window;
     27 
     28 #[cfg(test)]
     29 #[path = "source_paging_tests.rs"]
     30 mod paging_tests;
     31 
     32 #[cfg(test)]
     33 #[path = "source_original_tests.rs"]
     34 mod original_tests;
     35 
     36 const UPSTREAM_FETCH_LIMIT: usize = 1_000;
     37 
     38 pub(crate) fn observed_limits() -> radroots_event_codec::decode::EventWireLimits {
     39     let maximum = radroots_protocol::profile::SIGNED_EVENT_MAX_BYTES;
     40     radroots_event_codec::decode::EventWireLimits {
     41         max_raw_json_bytes: maximum,
     42         max_content_bytes: maximum,
     43         max_tag_element_bytes: maximum,
     44         max_total_tag_bytes: maximum,
     45         ..Default::default()
     46     }
     47 }
     48 const CURSOR_PREFIX: &str = "nostr-v2";
     49 const CURSOR_SCOPE_DOMAIN: &[u8] = b"radroots.transport-nostr.fetch-cursor.v2\0";
     50 
     51 #[derive(Clone, Debug)]
     52 pub(crate) struct SourceQuery {
     53     relays: Vec<RelayUrl>,
     54     selector: radroots_transport::source::FetchSelector,
     55     until_unix_seconds: Option<u64>,
     56     connect_timeout: Duration,
     57     deadline: crate::host_time::Instant,
     58     max_connections: usize,
     59 }
     60 
     61 #[derive(Clone, Debug)]
     62 pub(crate) struct RelayFetchBatch {
     63     relay: RelayUrl,
     64     result: RelayFetchResult,
     65 }
     66 
     67 #[derive(Clone, Debug, PartialEq, Eq)]
     68 pub(crate) enum RelayFetchResult {
     69     Complete(Vec<String>),
     70     Timeout(Vec<String>),
     71     ResourceLimit(Vec<String>),
     72     Failed(String),
     73 }
     74 
     75 pub(crate) trait RelaySourceClient: Send + Sync {
     76     fn fetch<'a>(&'a self, query: SourceQuery) -> BoxFuture<'a, Vec<RelayFetchBatch>>;
     77 }
     78 
     79 #[derive(Clone, Debug)]
     80 pub(crate) struct LiveRelaySourceClient {
     81     client: nostr_sdk::client::Client,
     82     ingress: crate::source_ingress::IngressRegistry,
     83     connections: Arc<crate::connections::Connections>,
     84 }
     85 
     86 impl LiveRelaySourceClient {
     87     pub(crate) const fn new(
     88         client: nostr_sdk::client::Client,
     89         ingress: crate::source_ingress::IngressRegistry,
     90         connections: Arc<crate::connections::Connections>,
     91     ) -> Self {
     92         Self {
     93             client,
     94             ingress,
     95             connections,
     96         }
     97     }
     98 
     99     #[cfg(test)]
    100     pub(crate) fn isolated() -> Self {
    101         let client = nostr_sdk::client::Client::default();
    102         Self::new(
    103             client,
    104             crate::source_ingress::IngressRegistry::default(),
    105             Arc::new(crate::connections::Connections::new(
    106                 crate::client::MAX_RELAYS,
    107             )),
    108         )
    109     }
    110 }
    111 
    112 impl RelaySourceClient for LiveRelaySourceClient {
    113     // The live SDK loop is exercised by bounded loopback regressions; injected
    114     // source tests independently cover selection and normalized results.
    115     #[cfg_attr(coverage_nightly, coverage(off))]
    116     fn fetch<'a>(&'a self, query: SourceQuery) -> BoxFuture<'a, Vec<RelayFetchBatch>> {
    117         Box::pin(async move {
    118             let SourceQuery {
    119                 relays,
    120                 selector,
    121                 until_unix_seconds,
    122                 connect_timeout,
    123                 deadline,
    124                 max_connections,
    125             } = query;
    126             let budget = Arc::new(FetchBudget::default());
    127             // An unencodable selector has no network work or ingress to admit.
    128             if !selector.kinds().is_empty()
    129                 && selector
    130                     .kinds()
    131                     .iter()
    132                     .all(|kind| u16::try_from(*kind).is_err())
    133             {
    134                 return relays
    135                     .into_iter()
    136                     .map(|relay| RelayFetchBatch {
    137                         relay,
    138                         result: RelayFetchResult::Complete(Vec::new()),
    139                     })
    140                     .collect();
    141             }
    142             let connections = match admit_fetch_connections(&self.client, &relays, deadline).await {
    143                 Ok(connections) => connections,
    144                 Err(result) => {
    145                     return relays
    146                         .into_iter()
    147                         .map(|relay| RelayFetchBatch {
    148                             relay,
    149                             result: result.clone(),
    150                         })
    151                         .collect();
    152                 }
    153             };
    154             let registration = self.ingress.register(
    155                 relays.iter().map(|relay| relay.as_str().to_owned()),
    156                 Arc::clone(&budget),
    157             );
    158             let Some(registration) = registration else {
    159                 // No ingress or query I/O was admitted, so existing shared
    160                 // connections retain their previous operation ownership.
    161                 connections.finish();
    162                 return relays
    163                     .into_iter()
    164                     .map(|relay| RelayFetchBatch {
    165                         relay,
    166                         result: RelayFetchResult::ResourceLimit(Vec::new()),
    167                     })
    168                     .collect();
    169             };
    170             let mut batches: Vec<RelayFetchBatch> = stream::iter(relays.into_iter().map(|relay| {
    171                 let selector = selector.clone();
    172                 let budget = Arc::clone(&budget);
    173                 let registration = &registration;
    174                 async move {
    175                     let url = relay.as_str().to_owned();
    176                     let result = async {
    177                         if budget.exhausted() {
    178                             return Ok(RelayFetchResult::ResourceLimit(Vec::new()));
    179                         }
    180                         if crate::host_time::Instant::now() >= deadline {
    181                             return Ok(RelayFetchResult::Timeout(Vec::new()));
    182                         }
    183                         let kinds = selector
    184                             .kinds()
    185                             .iter()
    186                             .filter_map(|kind| u16::try_from(*kind).ok())
    187                             .map(Kind::from)
    188                             .collect::<Vec<_>>();
    189                         let authors = selector
    190                             .authors()
    191                             .iter()
    192                             .filter_map(|author| PublicKey::from_slice(author.as_bytes()).ok())
    193                             .collect::<Vec<_>>();
    194                         if authors.len() != selector.authors().len() {
    195                             return Ok(RelayFetchResult::Complete(Vec::new()));
    196                         }
    197                         let mut filter = Filter::new().limit(UPSTREAM_FETCH_LIMIT);
    198                         if !kinds.is_empty() {
    199                             filter = filter.kinds(kinds);
    200                         }
    201                         if !authors.is_empty() {
    202                             filter = filter.authors(authors);
    203                         }
    204                         filter = apply_exact_tag_filters(filter, &selector).map_err(|()| {
    205                             String::from("validated indexed tag cannot be encoded")
    206                         })?;
    207                         if let Some(since) = selector.since_unix_seconds() {
    208                             filter = filter.since(Timestamp::from_secs(since));
    209                         }
    210                         if let Some(until) = until_unix_seconds {
    211                             filter = filter.until(Timestamp::from_secs(until));
    212                         }
    213                         let connected = crate::host_time::timeout_at(deadline, async {
    214                             crate::client::connect_tracked(
    215                                     &self.client,
    216                                     &self.connections,
    217                                     url.as_str(),
    218                                     connect_timeout.min(deadline.saturating_duration_since(
    219                                         crate::host_time::Instant::now(),
    220                                     )),
    221                                 )
    222                                 .await
    223                                 .map_err(|error| error.to_string())
    224                         })
    225                         .await;
    226                         let relay = match connected {
    227                             Ok(result) => result?,
    228                             Err(_) => return Ok(RelayFetchResult::Timeout(Vec::new())),
    229                         };
    230                         let mut notifications = relay
    231                             .notifications()
    232                             .with_gaps()
    233                             .map(|item| item.map_err(|_| ()));
    234                         let subscription_id = SubscriptionId::generate();
    235                         let Some(originals) =
    236                             registration.bind_originals(&url, subscription_id.as_str())
    237                         else {
    238                             return Ok(RelayFetchResult::ResourceLimit(Vec::new()));
    239                         };
    240                         let remaining =
    241                             deadline.saturating_duration_since(crate::host_time::Instant::now());
    242                         if remaining.is_zero() {
    243                             return Ok(RelayFetchResult::Timeout(Vec::new()));
    244                         }
    245                         let options = SubscribeAutoCloseOptions::default()
    246                             .exit_policy(ReqExitPolicy::ExitOnEOSE)
    247                             .timeout(Some(remaining));
    248                         match crate::host_time::timeout_at(
    249                             deadline,
    250                             relay
    251                                 .subscribe(filter)
    252                                 .with_id(subscription_id.clone())
    253                                 .close_on(options),
    254                         )
    255                         .await
    256                         {
    257                             Ok(result) => {
    258                                 result.map_err(|error| error.to_string())?;
    259                             }
    260                             Err(_) => return Ok(RelayFetchResult::Timeout(Vec::new())),
    261                         }
    262                         let result = collect_until_eose(
    263                             &mut notifications,
    264                             &subscription_id,
    265                             deadline,
    266                             &budget,
    267                             |event| originals.take(event),
    268                         )
    269                         .await;
    270                         Ok(result)
    271                     }
    272                     .await;
    273                     RelayFetchBatch {
    274                         relay,
    275                         result: match result {
    276                             Err(_) if budget.exhausted() => {
    277                                 RelayFetchResult::ResourceLimit(Vec::new())
    278                             }
    279                             Ok(RelayFetchResult::Timeout(events)) if budget.exhausted() => {
    280                                 RelayFetchResult::ResourceLimit(events)
    281                             }
    282                             result => result.unwrap_or_else(RelayFetchResult::Failed),
    283                         },
    284                     }
    285                 }
    286             }))
    287             .buffered(max_connections)
    288             .collect()
    289             .await;
    290             if finish_fetch(&mut batches, registration) {
    291                 connections.finish();
    292             }
    293             batches
    294         })
    295     }
    296 }
    297 
    298 async fn admit_fetch_connections(
    299     client: &nostr_sdk::client::Client,
    300     relays: &[RelayUrl],
    301     deadline: crate::host_time::Instant,
    302 ) -> Result<FetchConnections, RelayFetchResult> {
    303     let connections = FetchConnections::default();
    304     let admitted = crate::host_time::timeout_at(deadline, async {
    305         for relay in relays {
    306             if crate::host_time::Instant::now() >= deadline {
    307                 return Err(RelayFetchResult::Timeout(Vec::new()));
    308             }
    309             // Adding a relay is inert SDK metadata admission, not connection
    310             // work. Own even preexisting queued sockets before ingress can be
    311             // revoked by this fetch's registration.
    312             client
    313                 .add_relay(relay.as_str())
    314                 .await
    315                 .map_err(|error| RelayFetchResult::Failed(error.to_string()))?;
    316             connections
    317                 .retain(
    318                     client
    319                         .relay(relay.as_str())
    320                         .await
    321                         .map_err(|error| RelayFetchResult::Failed(error.to_string()))?
    322                         .ok_or_else(|| {
    323                             RelayFetchResult::Failed(String::from(
    324                                 "configured relay is unavailable",
    325                             ))
    326                         })?,
    327                 )
    328                 .map_err(RelayFetchResult::Failed)?;
    329         }
    330         if crate::host_time::Instant::now() >= deadline {
    331             Err(RelayFetchResult::Timeout(Vec::new()))
    332         } else {
    333             Ok(())
    334         }
    335     })
    336     .await;
    337     match admitted {
    338         Ok(Ok(())) => Ok(connections),
    339         Ok(Err(result)) => Err(result),
    340         Err(_) => Err(RelayFetchResult::Timeout(Vec::new())),
    341     }
    342 }
    343 
    344 fn finish_fetch(
    345     batches: &mut [RelayFetchBatch],
    346     registration: crate::source_ingress::IngressRegistration,
    347 ) -> bool {
    348     if !batches
    349         .iter()
    350         .all(|batch| matches!(batch.result, RelayFetchResult::Complete(_)))
    351     {
    352         return false;
    353     }
    354     if registration.finish() {
    355         return true;
    356     }
    357     // Earlier EOSE evidence remains useful, but finalization cannot declare
    358     // an entirely complete fetch after ingress exhausted its shared budget.
    359     if let Some(last) = batches.last_mut()
    360         && let RelayFetchResult::Complete(events) = &mut last.result
    361     {
    362         last.result = RelayFetchResult::ResourceLimit(std::mem::take(events));
    363     }
    364     false
    365 }
    366 
    367 // The SDK owns its socket tasks. Its synchronous disconnect signal disables
    368 // reconnect and tears down those tasks, including when the fetch future drops.
    369 #[derive(Default)]
    370 struct FetchConnections(std::sync::Mutex<Vec<nostr_sdk::relay::Relay>>);
    371 
    372 impl FetchConnections {
    373     fn retain(&self, relay: nostr_sdk::relay::Relay) -> Result<(), String> {
    374         self.0
    375             .lock()
    376             .map_err(|_| String::from("fetch connection state unavailable"))?
    377             .push(relay);
    378         Ok(())
    379     }
    380 
    381     fn finish(&self) {
    382         if let Ok(mut relays) = self.0.lock() {
    383             relays.clear();
    384         }
    385     }
    386 }
    387 
    388 impl Drop for FetchConnections {
    389     fn drop(&mut self) {
    390         let relays = self
    391             .0
    392             .get_mut()
    393             .unwrap_or_else(std::sync::PoisonError::into_inner);
    394         for relay in relays {
    395             relay.disconnect();
    396         }
    397     }
    398 }
    399 
    400 async fn collect_until_eose(
    401     notifications: &mut (impl Stream<Item = Result<RelayNotification, ()>> + Unpin),
    402     subscription_id: &SubscriptionId,
    403     deadline: crate::host_time::Instant,
    404     budget: &FetchBudget,
    405     mut original: impl FnMut(&nostr_sdk::prelude::Event) -> Option<String>,
    406 ) -> RelayFetchResult {
    407     let mut events = Vec::new();
    408     loop {
    409         if budget.exhausted() {
    410             return RelayFetchResult::ResourceLimit(events);
    411         }
    412         if crate::host_time::Instant::now() >= deadline {
    413             return RelayFetchResult::Timeout(events);
    414         }
    415         let received = tokio::select! {
    416             biased;
    417             _ = budget.wait_exhausted() => return RelayFetchResult::ResourceLimit(events),
    418             received = crate::host_time::timeout_at(deadline, notifications.next()) => received,
    419         };
    420         let notification = match received {
    421             Ok(Some(Ok(notification))) => notification,
    422             Ok(Some(Err(()))) => {
    423                 return RelayFetchResult::Failed(String::from("relay notification gap"));
    424             }
    425             Ok(None) => {
    426                 return RelayFetchResult::Failed(String::from("relay notifications unavailable"));
    427             }
    428             Err(_) => return RelayFetchResult::Timeout(events),
    429         };
    430         if !budget.notification() {
    431             return RelayFetchResult::ResourceLimit(events);
    432         }
    433         match notification {
    434             RelayNotification::Message { message } => match *message {
    435                 RelayMessage::Event {
    436                     subscription_id: observed_subscription,
    437                     event,
    438                 } if observed_subscription.as_ref() == subscription_id => {
    439                     if events.len() >= UPSTREAM_FETCH_LIMIT {
    440                         return RelayFetchResult::ResourceLimit(events);
    441                     }
    442                     let Some(raw) = original(event.as_ref()) else {
    443                         // A parsed notification cannot recreate lost original
    444                         // evidence. Preserve partial results and require recovery.
    445                         return RelayFetchResult::ResourceLimit(events);
    446                     };
    447                     if !budget.event(raw.len()) {
    448                         return RelayFetchResult::ResourceLimit(events);
    449                     }
    450                     events.push(raw);
    451                 }
    452                 RelayMessage::EndOfStoredEvents(observed_subscription)
    453                     if observed_subscription.as_ref() == subscription_id =>
    454                 {
    455                     return if budget.exhausted() {
    456                         RelayFetchResult::ResourceLimit(events)
    457                     } else if crate::host_time::Instant::now() < deadline {
    458                         RelayFetchResult::Complete(events)
    459                     } else {
    460                         RelayFetchResult::Timeout(events)
    461                     };
    462                 }
    463                 RelayMessage::Closed {
    464                     subscription_id: observed_subscription,
    465                     message,
    466                 } if observed_subscription.as_ref() == subscription_id => {
    467                     return RelayFetchResult::Failed(message.into_owned());
    468                 }
    469                 _ => {}
    470             },
    471             RelayNotification::RelayStatus {
    472                 status:
    473                     nostr_sdk::prelude::RelayStatus::Disconnected
    474                     | nostr_sdk::prelude::RelayStatus::Idle
    475                     | nostr_sdk::prelude::RelayStatus::Banned,
    476             } => {
    477                 return RelayFetchResult::Failed(String::from("relay disconnected"));
    478             }
    479             RelayNotification::AuthenticationFailed => {
    480                 return RelayFetchResult::Failed(String::from("relay authentication failed"));
    481             }
    482             RelayNotification::RelayStatus {
    483                 status: nostr_sdk::prelude::RelayStatus::Shutdown,
    484             } => {
    485                 return RelayFetchResult::Failed(String::from("relay shutdown"));
    486             }
    487             _ => {}
    488         }
    489     }
    490 }
    491 
    492 #[derive(Debug)]
    493 struct Candidate {
    494     relay: RelayUrl,
    495     raw: String,
    496     created_at: u64,
    497     event_id: String,
    498 }
    499 
    500 impl EventSource for NostrTransport {
    501     fn status(&self) -> BoxFuture<'_, Result<SourceStatus, radroots_transport::Error>> {
    502         Box::pin(async move {
    503             self.require_open()?;
    504             Ok(status::source_status(&self.status))
    505         })
    506     }
    507 
    508     fn fetch(
    509         &self,
    510         request: FetchRequest,
    511     ) -> BoxFuture<'_, Result<FetchPage, radroots_transport::Error>> {
    512         Box::pin(async move {
    513             let _operation = self.connections.begin()?;
    514             let cursor_scope = request_scope(&request);
    515             let cursor = request
    516                 .cursor()
    517                 .map(|cursor| window::Position::parse(cursor, cursor_scope.as_str()))
    518                 .transpose()?;
    519             let effective_until =
    520                 window::effective_until(request.selector().until_unix_seconds(), cursor.as_ref());
    521             let now_ms = unix_time_ms();
    522             let remaining_ms = request.bounds().deadline_unix_ms().saturating_sub(now_ms);
    523             let timeout_ms = remaining_ms.min(self.config().request_timeout_ms());
    524             let deadline = crate::host_time::Instant::now() + Duration::from_millis(timeout_ms);
    525 
    526             let mut targets = BTreeMap::new();
    527             let mut outcomes = Vec::new();
    528             for target in request.target_set().targets() {
    529                 match self.config().endpoint_for_target(target) {
    530                     Some(endpoint) if endpoint.access().can_read() => {
    531                         let relay = endpoint.url().clone();
    532                         if self.status.may_read(&relay, now_ms) {
    533                             targets.insert(relay, target.clone());
    534                         } else {
    535                             outcomes.push(
    536                                 FetchTargetOutcome::new(
    537                                     target.fingerprint().clone(),
    538                                     FetchTargetState::FailedRetryable,
    539                                 )
    540                                 .with_message("relay reconnect backoff is active"),
    541                             );
    542                         }
    543                     }
    544                     None | Some(_) => outcomes.push(
    545                         FetchTargetOutcome::new(
    546                             target.fingerprint().clone(),
    547                             FetchTargetState::FailedTerminal,
    548                         )
    549                         .with_message("target is not configured for this source"),
    550                     ),
    551                 }
    552             }
    553 
    554             if timeout_ms == 0 {
    555                 for relay in targets.keys() {
    556                     self.status.record_read(relay, false, true, now_ms);
    557                 }
    558                 outcomes.extend(targets.values().map(|target| {
    559                     FetchTargetOutcome::new(
    560                         target.fingerprint().clone(),
    561                         FetchTargetState::Cancelled,
    562                     )
    563                     .with_message("fetch deadline elapsed before relay access")
    564                 }));
    565                 return FetchPage::for_request(&request, Vec::new(), outcomes, NextPage::Complete);
    566             }
    567 
    568             for relay in targets.keys() {
    569                 self.status.begin_read(relay, now_ms);
    570             }
    571             let batches = self
    572                 .source_client
    573                 .fetch(SourceQuery {
    574                     relays: targets.keys().cloned().collect(),
    575                     selector: request.selector().clone(),
    576                     until_unix_seconds: effective_until,
    577                     connect_timeout: Duration::from_millis(
    578                         timeout_ms.min(self.config().connect_timeout_ms()),
    579                     ),
    580                     deadline,
    581                     max_connections: self.config().max_connections(),
    582                 })
    583                 .await;
    584             let mut candidates = Vec::new();
    585             let mut capped_window = false;
    586             let mut older_boundary = None;
    587             let parse_budget = FetchBudget::default();
    588             let mut malformed_by_relay = BTreeMap::<RelayUrl, usize>::new();
    589             let mut reported = BTreeSet::new();
    590             let observed_at_unix_ms = unix_time_ms().max(now_ms);
    591             for batch in batches {
    592                 let RelayFetchBatch { relay, result } = batch;
    593                 let Some(target) = targets.get(&relay) else {
    594                     return Err(radroots_transport::Error::UnexpectedFetchTargetOutcome);
    595                 };
    596                 if !reported.insert(relay.clone()) {
    597                     return Err(radroots_transport::Error::DuplicateFetchTargetOutcome);
    598                 }
    599                 let (raw_events, mut terminal) = match result {
    600                     RelayFetchResult::Complete(events) => (events, FetchTargetState::Complete),
    601                     RelayFetchResult::Timeout(events) => (events, FetchTargetState::Cancelled),
    602                     RelayFetchResult::ResourceLimit(events) => (events, FetchTargetState::Partial),
    603                     RelayFetchResult::Failed(message) => {
    604                         let (state, safe) = status::fetch_failure(message.as_str());
    605                         self.status.record_read(
    606                             &relay,
    607                             false,
    608                             state.is_retryable(),
    609                             observed_at_unix_ms,
    610                         );
    611                         outcomes.push(
    612                             FetchTargetOutcome::new(target.fingerprint().clone(), state)
    613                                 .with_message(safe),
    614                         );
    615                         continue;
    616                     }
    617                 };
    618                 let capped_eose = terminal == FetchTargetState::Complete
    619                     && raw_events.len() >= UPSTREAM_FETCH_LIMIT;
    620                 capped_window |= capped_eose;
    621                 let mut oldest_matching = None;
    622                 for (index, raw) in raw_events.into_iter().enumerate() {
    623                     if index >= UPSTREAM_FETCH_LIMIT || !parse_budget.event(raw.len()) {
    624                         if terminal != FetchTargetState::Cancelled {
    625                             terminal = FetchTargetState::Partial;
    626                         }
    627                         break;
    628                     }
    629                     match radroots_event_codec::decode::signed_event_with_limits(
    630                         raw.as_str(),
    631                         observed_limits(),
    632                     ) {
    633                         Ok(event)
    634                             if request.selector().matches(&event)
    635                                 && effective_until
    636                                     .is_none_or(|until| event.created_at() <= until) =>
    637                         {
    638                             oldest_matching =
    639                                 Some(oldest_matching.map_or(event.created_at(), |oldest: u64| {
    640                                     oldest.min(event.created_at())
    641                                 }));
    642                             candidates.push(Candidate {
    643                                 relay: relay.clone(),
    644                                 created_at: event.created_at(),
    645                                 event_id: event.id_str().to_owned(),
    646                                 raw,
    647                             })
    648                         }
    649                         Ok(_) => {}
    650                         Err(_) => {
    651                             *malformed_by_relay.entry(relay.clone()).or_default() += 1;
    652                         }
    653                     }
    654                 }
    655                 if capped_eose && let Some(oldest) = oldest_matching {
    656                     older_boundary =
    657                         Some(older_boundary.map_or(oldest, |boundary: u64| boundary.max(oldest)));
    658                 }
    659                 // A capped EOSE proves relay availability, while the page's
    660                 // coverage stays partial. It must not start reconnect backoff.
    661                 self.status.record_read(
    662                     &relay,
    663                     terminal == FetchTargetState::Complete,
    664                     terminal != FetchTargetState::Complete,
    665                     observed_at_unix_ms,
    666                 );
    667                 let malformed = malformed_by_relay.get(&relay).copied().unwrap_or_default();
    668                 let outcome = if terminal == FetchTargetState::Cancelled {
    669                     FetchTargetOutcome::new(
    670                         target.fingerprint().clone(),
    671                         FetchTargetState::Cancelled,
    672                     )
    673                     .with_message("relay fetch deadline elapsed before EOSE")
    674                 } else if terminal == FetchTargetState::Partial || capped_eose {
    675                     FetchTargetOutcome::new(target.fingerprint().clone(), FetchTargetState::Partial)
    676                         .with_message("relay result reached the bounded fetch inventory")
    677                 } else if malformed == 0 {
    678                     FetchTargetOutcome::new(
    679                         target.fingerprint().clone(),
    680                         FetchTargetState::Complete,
    681                     )
    682                 } else {
    683                     FetchTargetOutcome::new(target.fingerprint().clone(), FetchTargetState::Partial)
    684                         .with_message(format!("ignored {malformed} malformed relay event(s)"))
    685                 };
    686                 outcomes.push(outcome);
    687             }
    688             for (relay, target) in &targets {
    689                 if !reported.contains(relay) {
    690                     self.status
    691                         .record_read(relay, false, true, observed_at_unix_ms);
    692                     outcomes.push(
    693                         FetchTargetOutcome::new(
    694                             target.fingerprint().clone(),
    695                             FetchTargetState::FailedRetryable,
    696                         )
    697                         .with_message("relay returned no fetch result"),
    698                     );
    699                 }
    700             }
    701             candidates.sort_by(compare_candidate);
    702             if let Some(cursor) = &cursor {
    703                 candidates.retain(|candidate| cursor.includes(candidate));
    704             }
    705             let mut seen = BTreeSet::new();
    706             candidates.retain(|candidate| seen.insert(candidate.event_id.clone()));
    707 
    708             let has_more = candidates.len() > usize::from(request.bounds().limit());
    709             candidates.truncate(usize::from(request.bounds().limit()));
    710             let next_page = if has_more {
    711                 let last = candidates.last().expect("non-empty bounded page");
    712                 NextPage::Cursor(FetchCursor::parse(format!(
    713                     "{CURSOR_PREFIX}:{}:{}:{cursor_scope}",
    714                     last.created_at, last.event_id,
    715                 ))?)
    716             } else if capped_window {
    717                 NextPage::Cancelled {
    718                     resume_from: older_boundary
    719                         .and_then(|boundary| window::before_boundary(boundary, &cursor_scope)),
    720                 }
    721             } else {
    722                 NextPage::Complete
    723             };
    724             let observed_at = unix_time_ms().max(1);
    725             let mut events = Vec::with_capacity(candidates.len());
    726             for candidate in candidates {
    727                 let target = targets
    728                     .get(&candidate.relay)
    729                     .expect("candidate relay has requested target");
    730                 let mut provenance = EventProvenance::new(
    731                     radroots_transport::TransportId::NOSTR,
    732                     target.fingerprint().clone(),
    733                     observed_at,
    734                 )?;
    735                 if let Some(request_cursor) = request.cursor().cloned() {
    736                     provenance = provenance.with_cursor(request_cursor);
    737                 }
    738                 let event = radroots_event_codec::decode::signed_event_with_limits(
    739                     candidate.raw.as_str(),
    740                     observed_limits(),
    741                 )
    742                 .map_err(|_| radroots_transport::Error::UnexpectedFetchProvenance)?;
    743                 events.push(ObservedEvent::new(event, provenance));
    744             }
    745             FetchPage::for_request(&request, events, outcomes, next_page)
    746         })
    747     }
    748 }
    749 
    750 fn parse_cursor(
    751     cursor: &FetchCursor,
    752     expected_scope: &str,
    753 ) -> Result<RelayCursor, radroots_transport::Error> {
    754     let mut parts = cursor.as_str().split(':');
    755     let valid = parts.next() == Some(CURSOR_PREFIX);
    756     let created_at = parts.next().and_then(|value| value.parse::<u64>().ok());
    757     let event_id = parts.next();
    758     let scope = parts.next();
    759     if !valid || parts.next().is_some() {
    760         return Err(radroots_transport::Error::InvalidFetchCursor);
    761     }
    762     let (Some(created_at), Some(event_id), Some(scope)) = (created_at, event_id, scope) else {
    763         return Err(radroots_transport::Error::InvalidFetchCursor);
    764     };
    765     if scope != expected_scope {
    766         return Err(radroots_transport::Error::InvalidFetchCursor);
    767     }
    768     RelayCursor::new(created_at, event_id)
    769         .map_err(|_| radroots_transport::Error::InvalidFetchCursor)
    770 }
    771 
    772 fn compare_candidate(left: &Candidate, right: &Candidate) -> Ordering {
    773     right
    774         .created_at
    775         .cmp(&left.created_at)
    776         .then_with(|| right.event_id.cmp(&left.event_id))
    777         .then_with(|| left.relay.cmp(&right.relay))
    778 }
    779 
    780 fn candidate_is_after_cursor(candidate: &Candidate, cursor: &RelayCursor) -> bool {
    781     cursor.page_precedes(candidate.created_at, candidate.event_id.as_str())
    782 }
    783 
    784 fn request_scope(request: &FetchRequest) -> String {
    785     let mut hasher = Sha256::new();
    786     hasher.update(CURSOR_SCOPE_DOMAIN);
    787     for target in request.target_set().targets() {
    788         hasher.update(target.fingerprint().as_str().as_bytes());
    789         hasher.update([0]);
    790     }
    791     for kind in request.selector().kinds() {
    792         hasher.update(kind.to_be_bytes());
    793     }
    794     hasher.update([0]);
    795     for author in request.selector().authors() {
    796         hasher.update(author.as_bytes());
    797     }
    798     hasher.update([0]);
    799     hash_exact_tag_filters(&mut hasher, request.selector());
    800     hash_optional_u64(&mut hasher, request.selector().since_unix_seconds());
    801     hash_optional_u64(&mut hasher, request.selector().until_unix_seconds());
    802     hex_encode(&hasher.finalize())
    803 }
    804 
    805 pub(crate) fn hash_exact_tag_filters(
    806     hasher: &mut Sha256,
    807     selector: &radroots_transport::source::FetchSelector,
    808 ) {
    809     let mut filters = selector.exact_tag_filters().peekable();
    810     if filters.peek().is_none() {
    811         return;
    812     }
    813     hasher.update([2]);
    814     for (key, values) in filters {
    815         hasher.update([u8::try_from(key).expect("validated ASCII tag key")]);
    816         hasher.update(
    817             u64::try_from(values.len())
    818                 .expect("bounded tag-value count")
    819                 .to_be_bytes(),
    820         );
    821         for value in values {
    822             hasher.update(
    823                 u64::try_from(value.len())
    824                     .expect("bounded tag-value length")
    825                     .to_be_bytes(),
    826             );
    827             hasher.update(value.as_bytes());
    828         }
    829     }
    830     hasher.update([0]);
    831 }
    832 
    833 pub(crate) fn apply_exact_tag_filters(
    834     mut filter: Filter,
    835     selector: &radroots_transport::source::FetchSelector,
    836 ) -> Result<Filter, ()> {
    837     for (key, values) in selector.exact_tag_filters() {
    838         let tag = SingleLetterTag::from_char(key).map_err(|_| ())?;
    839         filter = filter.custom_tags(tag, values.iter().map(String::as_str));
    840     }
    841     Ok(filter)
    842 }
    843 
    844 fn hash_optional_u64(hasher: &mut Sha256, value: Option<u64>) {
    845     match value {
    846         Some(value) => {
    847             hasher.update([1]);
    848             hasher.update(value.to_be_bytes());
    849         }
    850         None => hasher.update([0]),
    851     }
    852 }
    853 
    854 fn hex_encode(bytes: &[u8]) -> String {
    855     const HEX: &[u8; 16] = b"0123456789abcdef";
    856     let mut encoded = String::with_capacity(bytes.len() * 2);
    857     for byte in bytes {
    858         encoded.push(HEX[(byte >> 4) as usize] as char);
    859         encoded.push(HEX[(byte & 0x0f) as usize] as char);
    860     }
    861     encoded
    862 }
    863 
    864 #[cfg(test)]
    865 mod tests {
    866     use super::*;
    867     use crate::{Config, RelayUrlPolicy};
    868     use radroots_transport::{
    869         FetchRequest, Target, TargetSet,
    870         source::{FetchBounds, FetchSelector, NextPage},
    871     };
    872     use std::borrow::Cow;
    873     use std::sync::{
    874         Arc,
    875         atomic::{AtomicUsize, Ordering as AtomicOrdering},
    876     };
    877 
    878     async fn collect_until_eose_test(
    879         notifications: &mut (impl Stream<Item = Result<RelayNotification, ()>> + Unpin),
    880         subscription_id: &SubscriptionId,
    881         deadline: crate::host_time::Instant,
    882         budget: &FetchBudget,
    883     ) -> RelayFetchResult {
    884         collect_until_eose(notifications, subscription_id, deadline, budget, |event| {
    885             Some(event.as_json())
    886         })
    887         .await
    888     }
    889 
    890     const FIRST: &str = r#"{"id":"762bee187e9e645b81ec26ade05a69b5e8398caf527be8de0d9a45311ed0c7a0","pubkey":"585591529da0bab31b3b1b1f986611cf5f435dca84f978c89ee8a40cca7103df","created_at":1800000100,"kind":0,"tags":[],"content":"{\"display_name\":\"Moss Street Farm\",\"bot\":false,\"website\":\"https://mossstreet.example\",\"picture\":42}","sig":"4290da0bb6422986647bc8cd5f63bd52d49f41e7b665d3b47105b8109183e8d596f322c531d4061df53e1d2b70fda12d5d1c14f3720d7a56d9d0a03746af5109"}"#;
    891     const SECOND: &str = r#"{"id":"56bfc78223bb2221bad82b539efdec1ade0f56d0eb0e1f592fd387df4b2ceee0","pubkey":"585591529da0bab31b3b1b1f986611cf5f435dca84f978c89ee8a40cca7103df","created_at":1700000001,"kind":0,"tags":[],"content":"{}","sig":"dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"}"#;
    892 
    893     #[derive(Debug)]
    894     struct MockSourceClient;
    895 
    896     impl RelaySourceClient for MockSourceClient {
    897         fn fetch<'a>(&'a self, query: SourceQuery) -> BoxFuture<'a, Vec<RelayFetchBatch>> {
    898             Box::pin(async move {
    899                 query
    900                     .relays
    901                     .into_iter()
    902                     .map(|relay| RelayFetchBatch {
    903                         relay,
    904                         result: RelayFetchResult::Complete(vec![
    905                             FIRST.to_owned(),
    906                             SECOND.to_owned(),
    907                             "{".to_owned(),
    908                         ]),
    909                     })
    910                     .collect()
    911             })
    912         }
    913     }
    914 
    915     fn transport() -> NostrTransport {
    916         let config = Config::from_profile(
    917             crate::profile::test_profile(
    918                 crate::RelayProfileKind::Public,
    919                 RelayUrlPolicy::Public,
    920                 ["wss://one.example", "wss://two.example"],
    921             )
    922             .expect("profile"),
    923         );
    924         NostrTransport::with_source_client(config, Arc::new(MockSourceClient))
    925     }
    926 
    927     fn request(limit: u16) -> FetchRequest {
    928         FetchRequest::new(
    929             "nostr-fetch",
    930             TargetSet::new(vec![
    931                 Target::nostr_relay("wss://one.example").expect("one"),
    932                 Target::nostr_relay("wss://two.example").expect("two"),
    933             ])
    934             .expect("targets"),
    935             FetchBounds::new(limit, u64::MAX).expect("bounds"),
    936         )
    937         .expect("request")
    938     }
    939 
    940     fn single_request(limit: u16) -> FetchRequest {
    941         FetchRequest::new(
    942             "nostr-fetch-one",
    943             TargetSet::new(vec![Target::nostr_relay("wss://one.example").expect("one")])
    944                 .expect("targets"),
    945             FetchBounds::new(limit, u64::MAX).expect("bounds"),
    946         )
    947         .expect("request")
    948     }
    949 
    950     #[test]
    951     fn source_deduplicates_relays_reports_malformed_and_paginates() {
    952         let transport = transport();
    953         let first_request = request(1);
    954         let first =
    955             futures::executor::block_on(transport.fetch(first_request)).expect("first page");
    956         assert_eq!(first.events().len(), 1);
    957         assert!(
    958             first
    959                 .target_outcomes()
    960                 .iter()
    961                 .all(|outcome| outcome.state() == FetchTargetState::Partial)
    962         );
    963         let NextPage::Cursor(cursor) = first.next_page() else {
    964             panic!("cursor expected");
    965         };
    966 
    967         let second_request = request(2).with_cursor(cursor.clone());
    968         let second =
    969             futures::executor::block_on(transport.fetch(second_request)).expect("second page");
    970         assert_eq!(second.events().len(), 1);
    971         assert!(matches!(second.next_page(), NextPage::Complete));
    972         assert_ne!(
    973             first.events()[0].event().id(),
    974             second.events()[0].event().id()
    975         );
    976     }
    977 
    978     #[test]
    979     fn source_applies_kind_author_and_time_selectors_before_page_bounds() {
    980         let event = radroots_event_codec::decode::signed_event(FIRST).expect("fixture event");
    981         let selector = FetchSelector::all()
    982             .with_kinds(vec![0])
    983             .expect("kind")
    984             .with_authors(vec![*event.pubkey()])
    985             .expect("author")
    986             .with_since_unix_seconds(1_750_000_000)
    987             .expect("since");
    988         let selected =
    989             futures::executor::block_on(transport().fetch(request(10).with_selector(selector)))
    990                 .expect("selected page");
    991         assert_eq!(selected.events().len(), 1);
    992         assert_eq!(selected.events()[0].event().id_str(), event.id_str());
    993 
    994         let excluded = FetchSelector::all()
    995             .with_kinds(vec![1])
    996             .expect("excluded kind");
    997         let selected =
    998             futures::executor::block_on(transport().fetch(request(10).with_selector(excluded)))
    999                 .expect("empty selected page");
   1000         assert!(selected.events().is_empty());
   1001     }
   1002 
   1003     #[test]
   1004     fn malformed_cursor_fails_before_relay_access() {
   1005         let request = request(1).with_cursor(FetchCursor::parse("other:1:value").expect("opaque"));
   1006         let error = futures::executor::block_on(transport().fetch(request)).expect_err("cursor");
   1007         assert_eq!(error, radroots_transport::Error::InvalidFetchCursor);
   1008     }
   1009 
   1010     #[test]
   1011     fn dropping_an_unpolled_fetch_performs_no_relay_work() {
   1012         #[derive(Debug)]
   1013         struct CountingSourceClient(Arc<AtomicUsize>);
   1014 
   1015         impl RelaySourceClient for CountingSourceClient {
   1016             fn fetch<'a>(&'a self, _query: SourceQuery) -> BoxFuture<'a, Vec<RelayFetchBatch>> {
   1017                 self.0.fetch_add(1, AtomicOrdering::SeqCst);
   1018                 Box::pin(async { Vec::new() })
   1019             }
   1020         }
   1021 
   1022         let calls = Arc::new(AtomicUsize::new(0));
   1023         let config = Config::from_profile(
   1024             crate::profile::test_profile(
   1025                 crate::RelayProfileKind::Public,
   1026                 RelayUrlPolicy::Public,
   1027                 ["wss://one.example"],
   1028             )
   1029             .expect("profile"),
   1030         );
   1031         let transport = NostrTransport::with_source_client(
   1032             config,
   1033             Arc::new(CountingSourceClient(Arc::clone(&calls))),
   1034         );
   1035         let target_set = TargetSet::new(vec![
   1036             Target::nostr_relay("wss://one.example").expect("target"),
   1037         ])
   1038         .expect("targets");
   1039         let fetch = transport.fetch(
   1040             FetchRequest::new(
   1041                 "cancel-before-poll",
   1042                 target_set,
   1043                 FetchBounds::new(1, u64::MAX).expect("bounds"),
   1044             )
   1045             .expect("request"),
   1046         );
   1047         drop(fetch);
   1048         assert_eq!(calls.load(AtomicOrdering::SeqCst), 0);
   1049     }
   1050 
   1051     #[test]
   1052     fn adapter_and_generic_page_limits_are_identical() {
   1053         assert_eq!(UPSTREAM_FETCH_LIMIT, 1_000);
   1054         assert_eq!(
   1055             UPSTREAM_FETCH_LIMIT,
   1056             usize::from(radroots_transport::source::FETCH_PAGE_MAX_EVENTS)
   1057         );
   1058         assert!(FetchBounds::new(1_001, u64::MAX).is_err());
   1059     }
   1060 
   1061     #[derive(Debug)]
   1062     struct ScriptedSourceClient(Vec<RelayFetchBatch>);
   1063 
   1064     impl RelaySourceClient for ScriptedSourceClient {
   1065         fn fetch<'a>(&'a self, _query: SourceQuery) -> BoxFuture<'a, Vec<RelayFetchBatch>> {
   1066             Box::pin(async move { self.0.clone() })
   1067         }
   1068     }
   1069 
   1070     fn scripted(batches: Vec<RelayFetchBatch>) -> NostrTransport {
   1071         let config = Config::from_profile(
   1072             crate::profile::test_profile(
   1073                 crate::RelayProfileKind::Public,
   1074                 RelayUrlPolicy::Public,
   1075                 ["wss://one.example", "wss://two.example"],
   1076             )
   1077             .expect("profile"),
   1078         );
   1079         NostrTransport::with_source_client(config, Arc::new(ScriptedSourceClient(batches)))
   1080     }
   1081 
   1082     #[test]
   1083     fn source_handles_failed_missing_duplicate_and_unexpected_batches() {
   1084         let one = RelayUrl::parse("wss://one.example", RelayUrlPolicy::Public).expect("one");
   1085         let two = RelayUrl::parse("wss://two.example", RelayUrlPolicy::Public).expect("two");
   1086         let failed = futures::executor::block_on(
   1087             scripted(vec![RelayFetchBatch {
   1088                 relay: one.clone(),
   1089                 result: RelayFetchResult::Failed("connection timeout".into()),
   1090             }])
   1091             .fetch(request(10)),
   1092         )
   1093         .expect("failed page");
   1094         assert_eq!(failed.target_outcomes().len(), 2);
   1095         assert!(failed.events().is_empty());
   1096 
   1097         let duplicate = scripted(vec![
   1098             RelayFetchBatch {
   1099                 relay: one.clone(),
   1100                 result: RelayFetchResult::Complete(vec![]),
   1101             },
   1102             RelayFetchBatch {
   1103                 relay: one,
   1104                 result: RelayFetchResult::Complete(vec![]),
   1105             },
   1106         ]);
   1107         assert_eq!(
   1108             futures::executor::block_on(duplicate.fetch(request(10))),
   1109             Err(radroots_transport::Error::DuplicateFetchTargetOutcome)
   1110         );
   1111 
   1112         let other = RelayUrl::parse("wss://other.example", RelayUrlPolicy::Public).expect("other");
   1113         let unexpected = scripted(vec![RelayFetchBatch {
   1114             relay: other,
   1115             result: RelayFetchResult::Complete(vec![]),
   1116         }]);
   1117         assert_eq!(
   1118             futures::executor::block_on(unexpected.fetch(request(10))),
   1119             Err(radroots_transport::Error::UnexpectedFetchTargetOutcome)
   1120         );
   1121 
   1122         let complete = futures::executor::block_on(
   1123             scripted(vec![RelayFetchBatch {
   1124                 relay: two,
   1125                 result: RelayFetchResult::Complete(vec![]),
   1126             }])
   1127             .fetch(request(10)),
   1128         )
   1129         .expect("partial reporting");
   1130         assert_eq!(complete.target_outcomes().len(), 2);
   1131     }
   1132 
   1133     #[test]
   1134     fn eose_timeout_and_resource_exhaustion_remain_distinct() {
   1135         let relay = RelayUrl::parse("wss://one.example", RelayUrlPolicy::Public).expect("relay");
   1136         let fetch = |result| {
   1137             futures::executor::block_on(
   1138                 scripted(vec![RelayFetchBatch {
   1139                     relay: relay.clone(),
   1140                     result,
   1141                 }])
   1142                 .fetch(single_request(10)),
   1143             )
   1144             .expect("page")
   1145         };
   1146 
   1147         let complete = fetch(RelayFetchResult::Complete(vec![FIRST.to_owned()]));
   1148         assert_eq!(
   1149             complete.target_outcomes()[0].state(),
   1150             FetchTargetState::Complete
   1151         );
   1152         assert!(matches!(complete.next_page(), NextPage::Complete));
   1153 
   1154         let timeout = fetch(RelayFetchResult::Timeout(vec![FIRST.to_owned()]));
   1155         assert_eq!(timeout.events().len(), 1);
   1156         assert_eq!(
   1157             timeout.target_outcomes()[0].state(),
   1158             FetchTargetState::Cancelled
   1159         );
   1160 
   1161         let exhausted = fetch(RelayFetchResult::ResourceLimit(vec![FIRST.to_owned()]));
   1162         assert_eq!(exhausted.events().len(), 1);
   1163         assert_eq!(
   1164             exhausted.target_outcomes()[0].state(),
   1165             FetchTargetState::Partial
   1166         );
   1167     }
   1168 
   1169     #[tokio::test]
   1170     async fn live_completion_requires_eose_strictly_before_deadline() {
   1171         let subscription_id = SubscriptionId::generate();
   1172         let (sender, mut receiver) = tokio::sync::broadcast::channel(2);
   1173         sender
   1174             .send(RelayNotification::Message {
   1175                 message: Box::new(RelayMessage::EndOfStoredEvents(Cow::Owned(
   1176                     subscription_id.clone(),
   1177                 ))),
   1178             })
   1179             .expect("EOSE");
   1180         assert_eq!(
   1181             collect_until_eose_test(
   1182                 &mut test_notifications(&mut receiver),
   1183                 &subscription_id,
   1184                 crate::host_time::Instant::now() + Duration::from_secs(1),
   1185                 &FetchBudget::default(),
   1186             )
   1187             .await,
   1188             RelayFetchResult::Complete(Vec::new())
   1189         );
   1190 
   1191         let (_sender, mut receiver) = tokio::sync::broadcast::channel(2);
   1192         assert_eq!(
   1193             collect_until_eose_test(
   1194                 &mut test_notifications(&mut receiver),
   1195                 &subscription_id,
   1196                 crate::host_time::Instant::now(),
   1197                 &FetchBudget::default()
   1198             )
   1199             .await,
   1200             RelayFetchResult::Timeout(Vec::new())
   1201         );
   1202     }
   1203 
   1204     #[tokio::test]
   1205     async fn exhausted_ingress_wins_over_queued_eose() {
   1206         let subscription_id = SubscriptionId::generate();
   1207         let (sender, mut receiver) = tokio::sync::broadcast::channel(1);
   1208         sender
   1209             .send(RelayNotification::Message {
   1210                 message: Box::new(RelayMessage::EndOfStoredEvents(Cow::Owned(
   1211                     subscription_id.clone(),
   1212                 ))),
   1213             })
   1214             .unwrap();
   1215         let budget = FetchBudget::default();
   1216         assert!(!budget.wire(budget::MAX_FETCH_BYTES + 1, 0, 0));
   1217         assert_eq!(
   1218             collect_until_eose_test(
   1219                 &mut test_notifications(&mut receiver),
   1220                 &subscription_id,
   1221                 crate::host_time::Instant::now() + Duration::from_secs(1),
   1222                 &budget
   1223             )
   1224             .await,
   1225             RelayFetchResult::ResourceLimit(Vec::new())
   1226         );
   1227     }
   1228 
   1229     #[tokio::test]
   1230     async fn receiver_gap_cannot_turn_a_retained_eose_into_complete_evidence() {
   1231         let id = SubscriptionId::generate();
   1232         let (sender, mut receiver) = tokio::sync::broadcast::channel(1);
   1233         sender
   1234             .send(RelayNotification::RelayStatus {
   1235                 status: nostr_sdk::prelude::RelayStatus::Connected,
   1236             })
   1237             .unwrap();
   1238         sender
   1239             .send(RelayNotification::Message {
   1240                 message: Box::new(RelayMessage::EndOfStoredEvents(Cow::Owned(id.clone()))),
   1241             })
   1242             .unwrap();
   1243         assert_eq!(
   1244             collect_until_eose_test(
   1245                 &mut test_notifications(&mut receiver),
   1246                 &id,
   1247                 crate::host_time::Instant::now() + Duration::from_secs(1),
   1248                 &FetchBudget::default(),
   1249             )
   1250             .await,
   1251             RelayFetchResult::Failed(String::from("relay notification gap"))
   1252         );
   1253     }
   1254 
   1255     #[tokio::test]
   1256     async fn exhaustion_after_eose_before_finalization_retains_events_and_earlier_evidence() {
   1257         let relays = ["wss://one.example", "wss://two.example"];
   1258         let registry =
   1259             crate::source_ingress::IngressRegistry::new(relays.into_iter().map(str::to_owned));
   1260         let budget = Arc::new(FetchBudget::default());
   1261         let registration = registry
   1262             .register(relays.into_iter().map(str::to_owned), Arc::clone(&budget))
   1263             .unwrap();
   1264         let connection = registry.connection(relays[1]).unwrap();
   1265         let mut batches = Vec::new();
   1266         for url in relays {
   1267             let id = SubscriptionId::generate();
   1268             let (sender, mut receiver) = tokio::sync::broadcast::channel(2);
   1269             sender
   1270                 .send(RelayNotification::Message {
   1271                     message: Box::new(RelayMessage::Event {
   1272                         subscription_id: Cow::Owned(id.clone()),
   1273                         event: Cow::Owned(nostr_sdk::prelude::Event::from_json(FIRST).unwrap()),
   1274                     }),
   1275                 })
   1276                 .unwrap();
   1277             sender
   1278                 .send(RelayNotification::Message {
   1279                     message: Box::new(RelayMessage::EndOfStoredEvents(Cow::Owned(id.clone()))),
   1280                 })
   1281                 .unwrap();
   1282             batches.push(RelayFetchBatch {
   1283                 relay: RelayUrl::parse(url, RelayUrlPolicy::Public).unwrap(),
   1284                 result: collect_until_eose_test(
   1285                     &mut test_notifications(&mut receiver),
   1286                     &id,
   1287                     crate::host_time::Instant::now() + Duration::from_secs(1),
   1288                     &budget,
   1289                 )
   1290                 .await,
   1291             });
   1292         }
   1293         let before = batches.clone();
   1294         assert!(before.iter().all(
   1295             |batch| matches!(&batch.result, RelayFetchResult::Complete(events) if events.len() == 1)
   1296         ));
   1297         assert!(!connection.charge(budget::MAX_FETCH_BYTES + 1, 0, 0));
   1298         assert!(!finish_fetch(&mut batches, registration));
   1299         assert_eq!(batches[0].result, before[0].result);
   1300         let RelayFetchResult::Complete(expected) = &before[1].result else {
   1301             panic!("completed collection");
   1302         };
   1303         assert_eq!(
   1304             batches[1].result,
   1305             RelayFetchResult::ResourceLimit(expected.clone())
   1306         );
   1307     }
   1308 
   1309     #[test]
   1310     fn finalization_preserves_success_partial_and_empty_results() {
   1311         for (result, exhausted, expected_complete) in [
   1312             (
   1313                 Some(RelayFetchResult::Complete(vec![FIRST.to_owned()])),
   1314                 false,
   1315                 true,
   1316             ),
   1317             (
   1318                 Some(RelayFetchResult::Timeout(vec![FIRST.to_owned()])),
   1319                 false,
   1320                 false,
   1321             ),
   1322             (None, false, true),
   1323             (None, true, false),
   1324         ] {
   1325             let registry = crate::source_ingress::IngressRegistry::new(
   1326                 ["wss://one.example".to_owned()].into_iter(),
   1327             );
   1328             let budget = Arc::new(FetchBudget::default());
   1329             let registration = registry
   1330                 .register(
   1331                     ["wss://one.example".to_owned()].into_iter(),
   1332                     Arc::clone(&budget),
   1333                 )
   1334                 .unwrap();
   1335             let connection = registry.connection("wss://one.example").unwrap();
   1336             let mut batches = result
   1337                 .map(|result| RelayFetchBatch {
   1338                     relay: RelayUrl::parse("wss://one.example", RelayUrlPolicy::Public).unwrap(),
   1339                     result,
   1340                 })
   1341                 .into_iter()
   1342                 .collect::<Vec<_>>();
   1343             let before = batches
   1344                 .iter()
   1345                 .map(|batch| batch.result.clone())
   1346                 .collect::<Vec<_>>();
   1347             if exhausted {
   1348                 assert!(!connection.charge(budget::MAX_FETCH_BYTES + 1, 0, 0));
   1349             }
   1350             assert_eq!(finish_fetch(&mut batches, registration), expected_complete);
   1351             assert_eq!(
   1352                 batches
   1353                     .iter()
   1354                     .map(|batch| batch.result.clone())
   1355                     .collect::<Vec<_>>(),
   1356                 before
   1357             );
   1358             assert_eq!(
   1359                 connection.admitted(&std::task::Context::from_waker(
   1360                     futures::task::noop_waker_ref()
   1361                 )),
   1362                 expected_complete
   1363             );
   1364         }
   1365     }
   1366 
   1367     #[tokio::test]
   1368     async fn completed_connection_ownership_is_retained_until_the_whole_query_finishes() {
   1369         let client = nostr_sdk::client::Client::default();
   1370         client.add_relay("wss://one.example").await.unwrap();
   1371         let relay = client.relay("wss://one.example").await.unwrap().unwrap();
   1372         let connections = FetchConnections::default();
   1373         connections.retain(relay.clone()).unwrap();
   1374         assert_eq!(connections.0.lock().unwrap().len(), 1);
   1375         connections.finish();
   1376         assert!(connections.0.lock().unwrap().is_empty());
   1377         connections.retain(relay).unwrap();
   1378         drop(connections);
   1379     }
   1380 
   1381     #[tokio::test]
   1382     async fn complete_connection_inventory_is_inert_and_preserves_shared_sockets_on_success() {
   1383         let client = nostr_sdk::client::Client::default();
   1384         let relays = ["wss://one.example", "wss://two.example"]
   1385             .map(|url| RelayUrl::parse(url, RelayUrlPolicy::Public).unwrap());
   1386         let connections = admit_fetch_connections(
   1387             &client,
   1388             &relays,
   1389             crate::host_time::Instant::now() + Duration::from_secs(1),
   1390         )
   1391         .await
   1392         .unwrap();
   1393         assert_eq!(connections.0.lock().unwrap().len(), 2);
   1394         for relay in &relays {
   1395             assert_eq!(
   1396                 client
   1397                     .relay(relay.as_str())
   1398                     .await
   1399                     .unwrap()
   1400                     .unwrap()
   1401                     .status(),
   1402                 nostr_sdk::prelude::RelayStatus::Initialized
   1403             );
   1404         }
   1405         connections.finish();
   1406         drop(connections);
   1407         for relay in &relays {
   1408             assert_eq!(
   1409                 client
   1410                     .relay(relay.as_str())
   1411                     .await
   1412                     .unwrap()
   1413                     .unwrap()
   1414                     .status(),
   1415                 nostr_sdk::prelude::RelayStatus::Initialized
   1416             );
   1417         }
   1418     }
   1419 
   1420     #[tokio::test]
   1421     async fn expired_inventory_performs_no_sdk_admission() {
   1422         let client = nostr_sdk::client::Client::default();
   1423         let relay = RelayUrl::parse("wss://one.example", RelayUrlPolicy::Public).unwrap();
   1424         for relays in [vec![relay], Vec::new()] {
   1425             assert!(matches!(
   1426                 admit_fetch_connections(&client, &relays, crate::host_time::Instant::now()).await,
   1427                 Err(RelayFetchResult::Timeout(_))
   1428             ));
   1429             assert!(client.relays().await.is_empty());
   1430         }
   1431     }
   1432 
   1433     #[tokio::test]
   1434     async fn failed_inventory_releases_every_handle_already_admitted() {
   1435         let client = nostr_sdk::client::Client::builder()
   1436             .max_relays(std::num::NonZeroUsize::new(1))
   1437             .build();
   1438         let relays = ["wss://one.example", "wss://two.example"]
   1439             .map(|url| RelayUrl::parse(url, RelayUrlPolicy::Public).unwrap());
   1440         assert!(matches!(
   1441             admit_fetch_connections(
   1442                 &client,
   1443                 &relays,
   1444                 crate::host_time::Instant::now() + Duration::from_secs(1)
   1445             )
   1446             .await,
   1447             Err(RelayFetchResult::Failed(_))
   1448         ));
   1449         assert_eq!(client.relays().await.len(), 1);
   1450         assert_eq!(
   1451             client
   1452                 .relay(relays[0].as_str())
   1453                 .await
   1454                 .unwrap()
   1455                 .unwrap()
   1456                 .status(),
   1457             nostr_sdk::prelude::RelayStatus::Idle
   1458         );
   1459     }
   1460 
   1461     #[derive(Clone, Copy)]
   1462     enum QueuedCleanup {
   1463         Cancel,
   1464         Deadline,
   1465         Resource,
   1466     }
   1467 
   1468     async fn queued_connection_cleanup(mode: QueuedCleanup) {
   1469         use futures::SinkExt;
   1470         use tokio_tungstenite::{accept_async, tungstenite::Message};
   1471         let first = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
   1472         let second = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
   1473         let urls = [
   1474             format!("ws://{}", first.local_addr().unwrap()),
   1475             format!("ws://{}", second.local_addr().unwrap()),
   1476         ];
   1477         let endpoints = urls
   1478             .iter()
   1479             .map(|url| {
   1480                 crate::RelayEndpoint::new(url, RelayUrlPolicy::Local, crate::RelayAccess::ReadOnly)
   1481                     .unwrap()
   1482             })
   1483             .collect::<Vec<_>>();
   1484         let connector = crate::session_socket::SessionWebsocketTransport::new(
   1485             &endpoints,
   1486             Duration::from_secs(1),
   1487             std::sync::Arc::new(crate::test_host::LoopbackConnector),
   1488         );
   1489         let ingress = connector.ingress.clone();
   1490         let client = nostr_sdk::client::Client::builder()
   1491             .websocket_transport(connector)
   1492             .build();
   1493         let (started, observed) = tokio::sync::oneshot::channel();
   1494         let first_server = tokio::spawn(async move {
   1495             let (tcp, _) = first.accept().await.unwrap();
   1496             let mut socket = accept_async(tcp).await.unwrap();
   1497             let mut started = Some(started);
   1498             while let Some(message) = socket.next().await {
   1499                 match message {
   1500                     Ok(Message::Text(text)) => {
   1501                         let value: serde_json::Value = serde_json::from_str(&text).unwrap();
   1502                         if value[0] == "REQ" {
   1503                             if let Some(started) = started.take() {
   1504                                 let _ = started.send(());
   1505                             }
   1506                             if matches!(mode, QueuedCleanup::Resource) {
   1507                                 let malformed = serde_json::to_string(&(
   1508                                     "EVENT",
   1509                                     &value[1],
   1510                                     // Keep primitive wire identities admissible so missing
   1511                                     // event fields reach the aggregate raw-ingress budget.
   1512                                     serde_json::json!({
   1513                                         "id": "00".repeat(32),
   1514                                         "pubkey": "11".repeat(32),
   1515                                         "sig": "22".repeat(64),
   1516                                         "invalid": "x".repeat(384 * 1024),
   1517                                     }),
   1518                                 ))
   1519                                 .unwrap();
   1520                                 for _ in 0..24 {
   1521                                     if socket
   1522                                         .send(Message::Text(malformed.clone().into()))
   1523                                         .await
   1524                                         .is_err()
   1525                                     {
   1526                                         return;
   1527                                     }
   1528                                 }
   1529                             }
   1530                         }
   1531                     }
   1532                     Ok(Message::Close(_)) | Err(_) => return,
   1533                     _ => {
   1534                         if socket.flush().await.is_err() {
   1535                             return;
   1536                         }
   1537                     }
   1538                 }
   1539             }
   1540         });
   1541         let queued_requests = Arc::new(AtomicUsize::new(0));
   1542         let requests = Arc::clone(&queued_requests);
   1543         let (closed, closure) = tokio::sync::oneshot::channel();
   1544         let second_server = tokio::spawn(async move {
   1545             let (tcp, _) = second.accept().await.unwrap();
   1546             let mut socket = accept_async(tcp).await.unwrap();
   1547             while let Some(message) = socket.next().await {
   1548                 match message {
   1549                     Ok(Message::Text(text)) => {
   1550                         let value: serde_json::Value = serde_json::from_str(&text).unwrap();
   1551                         if value[0] == "REQ" {
   1552                             requests.fetch_add(1, AtomicOrdering::SeqCst);
   1553                         }
   1554                     }
   1555                     Ok(Message::Close(_)) | Err(_) => break,
   1556                     _ => {
   1557                         if socket.flush().await.is_err() {
   1558                             break;
   1559                         }
   1560                     }
   1561                 }
   1562             }
   1563             let _ = closed.send(());
   1564         });
   1565         client.add_relay(urls[1].as_str()).await.unwrap();
   1566         crate::client::connect_relay(&client, urls[1].as_str(), Duration::from_secs(1))
   1567             .await
   1568             .unwrap();
   1569         let queued = client.relay(urls[1].as_str()).await.unwrap().unwrap();
   1570         let source = LiveRelaySourceClient::new(
   1571             client,
   1572             ingress,
   1573             Arc::new(crate::connections::Connections::new(2)),
   1574         );
   1575         let query = SourceQuery {
   1576             relays: urls
   1577                 .iter()
   1578                 .map(|url| RelayUrl::parse(url, RelayUrlPolicy::Local).unwrap())
   1579                 .collect(),
   1580             selector: radroots_transport::source::FetchSelector::all(),
   1581             until_unix_seconds: None,
   1582             connect_timeout: Duration::from_secs(1),
   1583             deadline: crate::host_time::Instant::now()
   1584                 + if matches!(mode, QueuedCleanup::Deadline) {
   1585                     Duration::from_millis(500)
   1586                 } else {
   1587                     Duration::from_secs(5)
   1588                 },
   1589             max_connections: 1,
   1590         };
   1591         let mut fetch = source.fetch(query);
   1592         let started = crate::host_time::timeout(Duration::from_secs(10), async {
   1593             tokio::select! {
   1594                 biased;
   1595                 result = observed => result.is_ok(),
   1596                 _ = &mut fetch => false,
   1597             }
   1598         })
   1599         .await;
   1600         let batches = if matches!(mode, QueuedCleanup::Cancel) {
   1601             None
   1602         } else {
   1603             Some(crate::host_time::timeout(Duration::from_secs(10), &mut fetch).await)
   1604         };
   1605         drop(fetch);
   1606         let status = queued.status();
   1607         let closed = crate::host_time::timeout(Duration::from_secs(2), closure).await;
   1608         for server in [first_server, second_server] {
   1609             server.abort();
   1610             let result = server.await;
   1611             assert!(result.is_ok() || result.unwrap_err().is_cancelled());
   1612         }
   1613         assert!(
   1614             started.unwrap(),
   1615             "first relay must own the only scheduled batch"
   1616         );
   1617         assert_eq!(queued_requests.load(AtomicOrdering::SeqCst), 0);
   1618         assert_eq!(
   1619             status,
   1620             nostr_sdk::prelude::RelayStatus::Idle,
   1621             "queued preexisting socket must lose automatic reconnect authority"
   1622         );
   1623         closed.unwrap().unwrap();
   1624         if let Some(batches) = batches {
   1625             let batches = batches.unwrap();
   1626             assert_eq!(batches.len(), 2);
   1627             assert!(batches.iter().all(|batch| match mode {
   1628                 QueuedCleanup::Deadline => matches!(batch.result, RelayFetchResult::Timeout(_)),
   1629                 QueuedCleanup::Resource =>
   1630                     matches!(batch.result, RelayFetchResult::ResourceLimit(_)),
   1631                 QueuedCleanup::Cancel => false,
   1632             }));
   1633         }
   1634     }
   1635 
   1636     #[tokio::test(flavor = "multi_thread")]
   1637     async fn cancellation_terminates_preexisting_queued_relay_reconnect_authority() {
   1638         queued_connection_cleanup(QueuedCleanup::Cancel).await;
   1639     }
   1640 
   1641     #[tokio::test(flavor = "multi_thread")]
   1642     async fn deadline_terminates_preexisting_queued_relay_reconnect_authority() {
   1643         queued_connection_cleanup(QueuedCleanup::Deadline).await;
   1644     }
   1645 
   1646     #[tokio::test(flavor = "multi_thread")]
   1647     async fn exhaustion_terminates_preexisting_queued_relay_reconnect_authority() {
   1648         queued_connection_cleanup(QueuedCleanup::Resource).await;
   1649     }
   1650 
   1651     #[test]
   1652     fn source_rejects_unconfigured_targets_and_expired_deadlines() {
   1653         let unconfigured_targets = TargetSet::new(vec![
   1654             Target::nostr_relay("wss://other.example").expect("other"),
   1655         ])
   1656         .expect("targets");
   1657         let unconfigured = FetchRequest::new(
   1658             "unconfigured",
   1659             unconfigured_targets,
   1660             FetchBounds::new(1, u64::MAX).expect("bounds"),
   1661         )
   1662         .expect("request");
   1663         let page = futures::executor::block_on(transport().fetch(unconfigured)).expect("page");
   1664         assert_eq!(
   1665             page.target_outcomes()[0].state(),
   1666             FetchTargetState::FailedTerminal
   1667         );
   1668 
   1669         let expired = FetchRequest::new(
   1670             "expired",
   1671             single_request(1).target_set().clone(),
   1672             FetchBounds::new(1, 1).expect("bounds"),
   1673         )
   1674         .expect("request");
   1675         let page = futures::executor::block_on(transport().fetch(expired)).expect("page");
   1676         assert!(page.events().is_empty());
   1677         assert_eq!(page.target_outcomes().len(), 1);
   1678         assert_eq!(
   1679             page.target_outcomes()[0].state(),
   1680             FetchTargetState::Cancelled
   1681         );
   1682         assert!(futures::executor::block_on(transport().status()).is_ok());
   1683     }
   1684 
   1685     #[test]
   1686     fn cursor_and_candidate_ordering_cover_boundaries() {
   1687         for invalid in [
   1688             "nostr-v1",
   1689             "nostr-v2:not-a-time:id:scope",
   1690             "nostr-v2:1",
   1691             "nostr-v2:1:id:scope:extra",
   1692             "nostr-v2:1:abc:scope",
   1693             "nostr-v2:1:gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg:scope",
   1694         ] {
   1695             let cursor = FetchCursor::parse(invalid).expect("opaque cursor");
   1696             assert!(matches!(
   1697                 parse_cursor(&cursor, &"a".repeat(64)),
   1698                 Err(radroots_transport::Error::InvalidFetchCursor)
   1699             ));
   1700         }
   1701         let cursor = RelayCursor::new(10, "b".repeat(64)).expect("cursor");
   1702         let relay = RelayUrl::parse("wss://one.example", RelayUrlPolicy::Public).expect("relay");
   1703         let older = Candidate {
   1704             relay: relay.clone(),
   1705             raw: String::new(),
   1706             created_at: 9,
   1707             event_id: "f".repeat(64),
   1708         };
   1709         let earlier_id = Candidate {
   1710             relay: relay.clone(),
   1711             raw: String::new(),
   1712             created_at: 10,
   1713             event_id: "a".repeat(64),
   1714         };
   1715         let later = Candidate {
   1716             relay,
   1717             raw: String::new(),
   1718             created_at: 11,
   1719             event_id: "0".repeat(64),
   1720         };
   1721         assert!(candidate_is_after_cursor(&older, &cursor));
   1722         assert!(candidate_is_after_cursor(&earlier_id, &cursor));
   1723         assert!(!candidate_is_after_cursor(&later, &cursor));
   1724         assert_ne!(compare_candidate(&older, &later), Ordering::Equal);
   1725     }
   1726 
   1727     #[test]
   1728     fn continuation_cursor_is_bound_to_exact_targets_and_selector() {
   1729         let first = futures::executor::block_on(transport().fetch(request(1))).expect("first page");
   1730         let NextPage::Cursor(cursor) = first.next_page() else {
   1731             panic!("cursor expected");
   1732         };
   1733         let different_selector = FetchSelector::all().with_kinds(vec![1]).expect("selector");
   1734         let error = futures::executor::block_on(
   1735             transport().fetch(
   1736                 request(1)
   1737                     .with_selector(different_selector)
   1738                     .with_cursor(cursor.clone()),
   1739             ),
   1740         )
   1741         .expect_err("scope mismatch");
   1742         assert_eq!(error, radroots_transport::Error::InvalidFetchCursor);
   1743 
   1744         let tagged_selector = FetchSelector::all()
   1745             .with_exact_tag_value('d', "trade-1")
   1746             .expect("tag selector");
   1747         let error = futures::executor::block_on(
   1748             transport().fetch(
   1749                 request(1)
   1750                     .with_selector(tagged_selector)
   1751                     .with_cursor(cursor.clone()),
   1752             ),
   1753         )
   1754         .expect_err("tag scope mismatch");
   1755         assert_eq!(error, radroots_transport::Error::InvalidFetchCursor);
   1756 
   1757         let other_targets =
   1758             TargetSet::new(vec![Target::nostr_relay("wss://one.example").expect("one")])
   1759                 .expect("targets");
   1760         let error = futures::executor::block_on(
   1761             transport().fetch(
   1762                 FetchRequest::new(
   1763                     "different-targets",
   1764                     other_targets,
   1765                     FetchBounds::new(1, u64::MAX).expect("bounds"),
   1766                 )
   1767                 .expect("request")
   1768                 .with_cursor(cursor.clone()),
   1769             ),
   1770         )
   1771         .expect_err("target scope mismatch");
   1772         assert_eq!(error, radroots_transport::Error::InvalidFetchCursor);
   1773     }
   1774 
   1775     #[test]
   1776     fn exact_tag_selector_maps_to_nostr_filter_and_is_defensively_enforced() {
   1777         let selector = FetchSelector::all()
   1778             .with_exact_tag_value('d', "trade-2")
   1779             .and_then(|selector| selector.with_exact_tag_value('d', "trade-1"))
   1780             .expect("tag selector");
   1781         let encoded = apply_exact_tag_filters(Filter::new(), &selector)
   1782             .expect("Nostr filter")
   1783             .as_json();
   1784         assert!(encoded.contains("\"#d\":[\"trade-1\",\"trade-2\"]"));
   1785 
   1786         let selected =
   1787             futures::executor::block_on(transport().fetch(request(10).with_selector(selector)))
   1788                 .expect("selected page");
   1789         assert!(selected.events().is_empty());
   1790     }
   1791 
   1792     #[test]
   1793     fn live_source_short_circuits_selectors_that_cannot_be_encoded() {
   1794         let client = LiveRelaySourceClient::isolated();
   1795         let relay = RelayUrl::parse("wss://one.example", RelayUrlPolicy::Public).expect("relay");
   1796         let selector = FetchSelector::all()
   1797             .with_kinds(vec![u32::MAX])
   1798             .expect("kind");
   1799         let batches = futures::executor::block_on(client.fetch(SourceQuery {
   1800             relays: vec![relay],
   1801             selector,
   1802             until_unix_seconds: None,
   1803             connect_timeout: Duration::from_millis(1),
   1804             deadline: crate::host_time::Instant::now() + Duration::from_millis(1),
   1805             max_connections: 1,
   1806         }));
   1807         assert_eq!(batches.len(), 1);
   1808         assert_eq!(batches[0].result, RelayFetchResult::Complete(vec![]));
   1809     }
   1810 
   1811     #[tokio::test]
   1812     async fn continuous_notifications_terminate_at_the_shared_work_limit() {
   1813         let id = SubscriptionId::generate();
   1814         let (sender, mut receiver) =
   1815             tokio::sync::broadcast::channel(budget::MAX_FETCH_NOTIFICATIONS + 1);
   1816         for _ in 0..=budget::MAX_FETCH_NOTIFICATIONS {
   1817             sender
   1818                 .send(RelayNotification::RelayStatus {
   1819                     status: nostr_sdk::prelude::RelayStatus::Connected,
   1820                 })
   1821                 .unwrap();
   1822         }
   1823         assert_eq!(
   1824             collect_until_eose_test(
   1825                 &mut test_notifications(&mut receiver),
   1826                 &id,
   1827                 crate::host_time::Instant::now() + Duration::from_secs(10),
   1828                 &FetchBudget::default()
   1829             )
   1830             .await,
   1831             RelayFetchResult::ResourceLimit(Vec::new())
   1832         );
   1833     }
   1834 
   1835     #[tokio::test]
   1836     async fn repeated_events_consume_inventory_before_deduplication() {
   1837         let id = SubscriptionId::generate();
   1838         let event = nostr_sdk::prelude::Event::from_json(FIRST).unwrap();
   1839         let (sender, mut receiver) = tokio::sync::broadcast::channel(UPSTREAM_FETCH_LIMIT + 1);
   1840         for _ in 0..=UPSTREAM_FETCH_LIMIT {
   1841             sender
   1842                 .send(RelayNotification::Message {
   1843                     message: Box::new(RelayMessage::Event {
   1844                         subscription_id: Cow::Owned(id.clone()),
   1845                         event: Cow::Owned(event.clone()),
   1846                     }),
   1847                 })
   1848                 .unwrap();
   1849         }
   1850         let result = collect_until_eose_test(
   1851             &mut test_notifications(&mut receiver),
   1852             &id,
   1853             crate::host_time::Instant::now() + Duration::from_secs(10),
   1854             &FetchBudget::default(),
   1855         )
   1856         .await;
   1857         let RelayFetchResult::ResourceLimit(events) = result else {
   1858             panic!("bounded inventory");
   1859         };
   1860         assert_eq!(events.len(), UPSTREAM_FETCH_LIMIT);
   1861     }
   1862 
   1863     #[test]
   1864     fn defensive_parse_budget_preserves_earlier_events_and_refuses_excess_work() {
   1865         let relay = RelayUrl::parse("wss://one.example", RelayUrlPolicy::Public).unwrap();
   1866         let mut records = vec![FIRST.to_owned()];
   1867         records.extend((1..UPSTREAM_FETCH_LIMIT).map(|_| "{".to_owned()));
   1868         records.push(SECOND.to_owned());
   1869         for records in [
   1870             records,
   1871             vec![
   1872                 FIRST.to_owned(),
   1873                 "x".repeat(budget::MAX_EVENT_BYTES + 1),
   1874                 SECOND.to_owned(),
   1875             ],
   1876         ] {
   1877             let page = futures::executor::block_on(
   1878                 scripted(vec![RelayFetchBatch {
   1879                     relay: relay.clone(),
   1880                     result: RelayFetchResult::Complete(records),
   1881                 }])
   1882                 .fetch(single_request(10)),
   1883             )
   1884             .unwrap();
   1885             assert_eq!(page.events().len(), 1);
   1886             assert_eq!(
   1887                 page.events()[0].event().id_str(),
   1888                 radroots_event_codec::decode::signed_event(FIRST)
   1889                     .unwrap()
   1890                     .id_str()
   1891             );
   1892             assert_eq!(page.target_outcomes()[0].state(), FetchTargetState::Partial);
   1893         }
   1894     }
   1895 
   1896     #[tokio::test]
   1897     async fn completed_relay_batches_do_not_refund_the_shared_byte_budget() {
   1898         let mut wire: serde_json::Value = serde_json::from_str(FIRST).unwrap();
   1899         wire["content"] = serde_json::json!("");
   1900         let empty = nostr_sdk::prelude::Event::from_json(wire.to_string()).unwrap();
   1901         wire["content"] =
   1902             serde_json::json!("x".repeat(budget::MAX_EVENT_BYTES - empty.as_json().len()));
   1903         // Collection bounds precede canonical event admission; the fixture only
   1904         // needs the upstream event structure and an exact serialized size.
   1905         let event = nostr_sdk::prelude::Event::from_json(wire.to_string()).unwrap();
   1906         assert_eq!(event.as_json().len(), budget::MAX_EVENT_BYTES);
   1907         let shared = FetchBudget::default();
   1908         let mut retained_bytes = 0;
   1909         for batch in 0..2 {
   1910             let id = SubscriptionId::generate();
   1911             let (sender, mut receiver) = tokio::sync::broadcast::channel(18);
   1912             for _ in 0..17 {
   1913                 sender
   1914                     .send(RelayNotification::Message {
   1915                         message: Box::new(RelayMessage::Event {
   1916                             subscription_id: Cow::Owned(id.clone()),
   1917                             event: Cow::Owned(event.clone()),
   1918                         }),
   1919                     })
   1920                     .unwrap();
   1921             }
   1922             sender
   1923                 .send(RelayNotification::Message {
   1924                     message: Box::new(RelayMessage::EndOfStoredEvents(Cow::Owned(id.clone()))),
   1925                 })
   1926                 .unwrap();
   1927             let result = collect_until_eose_test(
   1928                 &mut test_notifications(&mut receiver),
   1929                 &id,
   1930                 crate::host_time::Instant::now() + Duration::from_secs(10),
   1931                 &shared,
   1932             )
   1933             .await;
   1934             let events = match (batch, result) {
   1935                 (0, RelayFetchResult::Complete(events)) => {
   1936                     assert_eq!(events.len(), 17);
   1937                     events
   1938                 }
   1939                 (1, RelayFetchResult::ResourceLimit(events)) => {
   1940                     assert_eq!(events.len(), 15);
   1941                     events
   1942                 }
   1943                 _ => panic!("the second relay must exhaust the shared byte budget"),
   1944             };
   1945             retained_bytes += events.iter().map(String::len).sum::<usize>();
   1946         }
   1947         assert_eq!(retained_bytes, budget::MAX_FETCH_BYTES);
   1948         assert!(!shared.event(1));
   1949     }
   1950 
   1951     #[test]
   1952     fn duplicate_inventory_is_bounded_across_all_relay_batches_before_deduplication() {
   1953         let urls = (0..5)
   1954             .map(|index| format!("wss://relay{index}.example"))
   1955             .collect::<Vec<_>>();
   1956         let config = Config::from_profile(
   1957             crate::profile::test_profile(
   1958                 crate::RelayProfileKind::Public,
   1959                 RelayUrlPolicy::Public,
   1960                 urls.iter().map(String::as_str),
   1961             )
   1962             .unwrap(),
   1963         );
   1964         let targets = TargetSet::new(
   1965             config
   1966                 .read_relays()
   1967                 .map(|relay| relay.to_target().unwrap())
   1968                 .collect(),
   1969         )
   1970         .unwrap();
   1971         let request = FetchRequest::new(
   1972             "aggregate-duplicates",
   1973             targets,
   1974             FetchBounds::new(10, unix_time_ms() + 10_000).unwrap(),
   1975         )
   1976         .unwrap();
   1977         let batches = urls
   1978             .iter()
   1979             .map(|url| RelayFetchBatch {
   1980                 relay: RelayUrl::parse(url, RelayUrlPolicy::Public).unwrap(),
   1981                 result: RelayFetchResult::Complete(vec![FIRST.to_owned(); UPSTREAM_FETCH_LIMIT]),
   1982             })
   1983             .collect();
   1984         let transport =
   1985             NostrTransport::with_source_client(config, Arc::new(ScriptedSourceClient(batches)));
   1986         let page = futures::executor::block_on(transport.fetch(request)).unwrap();
   1987         assert_eq!(page.events().len(), 1);
   1988         assert_eq!(page.target_outcomes().len(), 5);
   1989         assert_eq!(
   1990             page.target_outcomes()
   1991                 .iter()
   1992                 .filter(|outcome| outcome.state() == FetchTargetState::Complete)
   1993                 .count(),
   1994             0
   1995         );
   1996         assert_eq!(
   1997             page.target_outcomes()
   1998                 .iter()
   1999                 .filter(|outcome| outcome.state() == FetchTargetState::Partial)
   2000                 .count(),
   2001             5
   2002         );
   2003         let report = transport.relay_status();
   2004         assert_eq!(
   2005             report
   2006                 .relays()
   2007                 .iter()
   2008                 .filter(|relay| relay.read().state() == crate::RelayEvidenceState::Available)
   2009                 .count(),
   2010             4
   2011         );
   2012         assert_eq!(
   2013             report
   2014                 .relays()
   2015                 .iter()
   2016                 .filter(|relay| relay.read().state() == crate::RelayEvidenceState::Unavailable)
   2017                 .count(),
   2018             1
   2019         );
   2020     }
   2021 
   2022     fn test_notifications(
   2023         receiver: &mut tokio::sync::broadcast::Receiver<RelayNotification>,
   2024     ) -> std::pin::Pin<Box<dyn Stream<Item = Result<RelayNotification, ()>> + Send + '_>> {
   2025         Box::pin(futures::stream::unfold(receiver, |receiver| async {
   2026             match receiver.recv().await {
   2027                 Ok(value) => Some((Ok(value), receiver)),
   2028                 Err(tokio::sync::broadcast::error::RecvError::Lagged(_)) => {
   2029                     Some((Err(()), receiver))
   2030                 }
   2031                 Err(tokio::sync::broadcast::error::RecvError::Closed) => None,
   2032             }
   2033         }))
   2034     }
   2035 }