lib

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

sink.rs (30721B)


      1 //! Nostr implementation of the transport event sink.
      2 
      3 use crate::exact_delivery::ExactEvent;
      4 use crate::host_time::unix_time_ms;
      5 use crate::{NostrTransport, RelayUrl, status};
      6 use core::{fmt, time::Duration};
      7 use futures::{StreamExt, stream};
      8 use radroots_transport::{
      9     BoxFuture, DeliveryReceipt, DeliveryRequest, EventSink, SinkFailure, Target, TargetSet,
     10     outcome::DeliveryOutcome,
     11     sink::{DeliveryTargetReceipt, SinkStatus},
     12 };
     13 use std::collections::{BTreeMap, BTreeSet};
     14 
     15 #[derive(Clone, Debug)]
     16 pub(crate) struct RelayPublishResult {
     17     relay: RelayUrl,
     18     attempted: bool,
     19     outcome: DeliveryOutcome,
     20 }
     21 
     22 /// Sealed, no-I/O result of validating one delivery against this adapter.
     23 ///
     24 /// The value retains the exact request and signed event bytes. It is
     25 /// constructed only by [`NostrTransport::prepare_delivery`] and is consumed by
     26 /// [`NostrTransport::execute_prepared_delivery`]. Ordinary `Debug` never
     27 /// exposes event bytes, request identities, or relay destinations.
     28 #[must_use = "prepared delivery must be durably bound before execution or deliberately discarded"]
     29 pub struct PreparedDelivery {
     30     request: DeliveryRequest,
     31     config: crate::Config,
     32     event: ExactEvent,
     33     authorized: Vec<(RelayUrl, Target)>,
     34     skipped: Vec<DeliveryTargetReceipt>,
     35 }
     36 
     37 impl PreparedDelivery {
     38     /// Returns the exact validated request retained for persistence binding.
     39     #[must_use]
     40     pub const fn request(&self) -> &DeliveryRequest {
     41         &self.request
     42     }
     43 }
     44 
     45 impl fmt::Debug for PreparedDelivery {
     46     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
     47         formatter.write_str("PreparedDelivery([redacted])")
     48     }
     49 }
     50 
     51 pub(crate) trait RelayClient: Send + Sync {
     52     fn publish<'a>(
     53         &'a self,
     54         relays: Vec<RelayUrl>,
     55         event: ExactEvent,
     56         max_connections: usize,
     57         connect_timeout: Duration,
     58         operation_timeout: Duration,
     59     ) -> BoxFuture<'a, Vec<RelayPublishResult>>;
     60 }
     61 
     62 #[derive(Clone, Debug)]
     63 pub(crate) struct LiveRelayClient {
     64     client: nostr_sdk::client::Client,
     65     writers: crate::socket_write::WriterRegistry,
     66     connections: std::sync::Arc<crate::connections::Connections>,
     67 }
     68 
     69 impl LiveRelayClient {
     70     pub(crate) const fn new(
     71         client: nostr_sdk::client::Client,
     72         writers: crate::socket_write::WriterRegistry,
     73         connections: std::sync::Arc<crate::connections::Connections>,
     74     ) -> Self {
     75         Self {
     76             client,
     77             writers,
     78             connections,
     79         }
     80     }
     81 
     82     #[cfg(test)]
     83     pub(crate) fn isolated() -> Self {
     84         let client = nostr_sdk::client::Client::default();
     85         Self::new(
     86             client,
     87             crate::socket_write::WriterRegistry::new(std::iter::empty()),
     88             std::sync::Arc::new(crate::connections::Connections::new(
     89                 crate::client::MAX_RELAYS,
     90             )),
     91         )
     92     }
     93 }
     94 
     95 impl RelayClient for LiveRelayClient {
     96     // Socket scheduling is exercised by the real loopback suite. Deterministic
     97     // coverage owns framing, writer lifecycle and acknowledgement normalization.
     98     #[cfg_attr(coverage_nightly, coverage(off))]
     99     fn publish<'a>(
    100         &'a self,
    101         relays: Vec<RelayUrl>,
    102         event: ExactEvent,
    103         max_connections: usize,
    104         connect_timeout: Duration,
    105         operation_timeout: Duration,
    106     ) -> BoxFuture<'a, Vec<RelayPublishResult>> {
    107         Box::pin(async move {
    108             let deadline = crate::host_time::Instant::now() + operation_timeout;
    109             stream::iter(relays.into_iter().map(|relay| {
    110                 let event = event.clone();
    111                 async move {
    112                     let url = relay.as_str().to_owned();
    113                     let mut attempted = false;
    114                     let attempt = async {
    115                         if crate::host_time::Instant::now() >= deadline {
    116                             return Err("timeout".to_owned());
    117                         }
    118                         attempted = true;
    119                         self.client
    120                             .add_relay(url.as_str())
    121                             .connect_timeout(connect_timeout)
    122                             .await
    123                             .map_err(|error| error.to_string())?;
    124                         crate::client::connect_tracked(
    125                             &self.client,
    126                             &self.connections,
    127                             url.as_str(),
    128                             connect_timeout,
    129                         )
    130                         .await
    131                         .map_err(|error| error.to_string())?;
    132                         event.publish(&self.client, &self.writers, &url).await
    133                     };
    134                     let outcome = match crate::host_time::timeout_at(deadline, attempt).await {
    135                         Err(_) => status::delivery_failure("timeout"),
    136                         Ok(Err(error)) => status::delivery_failure(&error),
    137                         Ok(Ok(outcome)) => outcome,
    138                     };
    139                     RelayPublishResult {
    140                         relay,
    141                         attempted,
    142                         outcome,
    143                     }
    144                 }
    145             }))
    146             .buffered(max_connections)
    147             .collect()
    148             .await
    149         })
    150     }
    151 }
    152 
    153 impl NostrTransport {
    154     /// Validates and converts one delivery without reading a clock or performing relay I/O.
    155     pub fn prepare_delivery(
    156         &self,
    157         request: DeliveryRequest,
    158     ) -> Result<PreparedDelivery, Box<SinkFailure>> {
    159         self.prepare_delivery_inner(request, None)
    160     }
    161 
    162     /// Prepares only an exact subset, retaining the complete original request.
    163     /// Unselected targets remain explicit unattempted, retryable receipt rows.
    164     pub fn prepare_delivery_selected(
    165         &self,
    166         request: DeliveryRequest,
    167         selected: &TargetSet,
    168     ) -> Result<PreparedDelivery, Box<SinkFailure>> {
    169         request
    170             .validate_target_selection(selected)
    171             .map_err(|_| Box::new(SinkFailure::invalid_contract(&request)))?;
    172         self.prepare_delivery_inner(request, Some(selected))
    173     }
    174 
    175     fn prepare_delivery_inner(
    176         &self,
    177         request: DeliveryRequest,
    178         selected: Option<&TargetSet>,
    179     ) -> Result<PreparedDelivery, Box<SinkFailure>> {
    180         let mut authorized = Vec::new();
    181         let mut skipped = Vec::new();
    182         for target in request.target_set().targets() {
    183             if selected.is_some_and(|targets| !targets.targets().contains(target)) {
    184                 skipped.push(
    185                     DeliveryTargetReceipt::skipped(
    186                         target.clone(),
    187                         DeliveryOutcome::unavailable()
    188                             .with_detail(
    189                                 "target_not_selected",
    190                                 "target is held for a later attempt",
    191                             )
    192                             .map_err(|_| Box::new(SinkFailure::invalid_contract(&request)))?,
    193                     )
    194                     .map_err(|_| Box::new(SinkFailure::invalid_contract(&request)))?,
    195                 );
    196                 continue;
    197             }
    198             match self.config().endpoint_for_target(target) {
    199                 Some(endpoint) if endpoint.access().can_write() => {
    200                     authorized.push((endpoint.url().clone(), target.clone()));
    201                 }
    202                 None | Some(_) => skipped.push(
    203                     DeliveryTargetReceipt::skipped(
    204                         target.clone(),
    205                         DeliveryOutcome::rejected()
    206                             .with_detail("target_denied", "target is not configured for this sink")
    207                             .map_err(|_| Box::new(SinkFailure::invalid_contract(&request)))?,
    208                     )
    209                     .map_err(|_| Box::new(SinkFailure::invalid_contract(&request)))?,
    210                 ),
    211             }
    212         }
    213         let event = ExactEvent::from_request(&request)
    214             .ok_or_else(|| Box::new(SinkFailure::invalid_contract(&request)))?;
    215         Ok(PreparedDelivery {
    216             request,
    217             config: self.config().clone(),
    218             event,
    219             authorized,
    220             skipped,
    221         })
    222     }
    223 
    224     /// Performs relay I/O for one exact prepared delivery and consumes its authority.
    225     pub fn execute_prepared_delivery(
    226         &self,
    227         prepared: PreparedDelivery,
    228     ) -> BoxFuture<'_, Result<DeliveryReceipt, SinkFailure>> {
    229         Box::pin(async move {
    230             let PreparedDelivery {
    231                 request,
    232                 config,
    233                 event,
    234                 authorized,
    235                 mut skipped,
    236             } = prepared;
    237             let _operation = self.connections.begin().map_err(|error| match error {
    238                 radroots_transport::Error::TransportClosed => {
    239                     SinkFailure::transport_closed(&request)
    240                 }
    241                 _ => SinkFailure::transport_unavailable(&request),
    242             })?;
    243             if config != *self.config() {
    244                 return Err(SinkFailure::invalid_contract(&request));
    245             }
    246             let now_unix_ms = unix_time_ms();
    247             let mut requested = Vec::new();
    248             for (relay, target) in authorized {
    249                 if self.status.may_write(&relay, now_unix_ms) {
    250                     requested.push((relay, target));
    251                 } else {
    252                     skipped.push(
    253                         DeliveryTargetReceipt::skipped(
    254                             target,
    255                             DeliveryOutcome::unavailable()
    256                                 .with_detail(
    257                                     "reconnect_backoff",
    258                                     "relay reconnect backoff is active",
    259                                 )
    260                                 .map_err(|_| SinkFailure::invalid_contract(&request))?,
    261                         )
    262                         .map_err(|_| SinkFailure::invalid_contract(&request))?,
    263                     );
    264                 }
    265             }
    266             let remaining_ms = request.deadline_unix_ms().saturating_sub(now_unix_ms);
    267             let operation_timeout_ms = remaining_ms.min(self.config().request_timeout_ms());
    268             if operation_timeout_ms == 0 {
    269                 for (relay, _) in &requested {
    270                     self.status.record_write(relay, false, true, now_unix_ms);
    271                 }
    272                 let timeout = status::delivery_failure("timeout");
    273                 skipped.extend(requested.into_iter().map(|(_, target)| {
    274                     DeliveryTargetReceipt::skipped(target, timeout.clone())
    275                         .expect("normalized timeout cannot satisfy delivery")
    276                 }));
    277                 return DeliveryReceipt::for_request(&request, skipped)
    278                     .map_err(|_| SinkFailure::invalid_contract(&request));
    279             }
    280             let expected: BTreeSet<_> = requested.iter().map(|(relay, _)| relay.clone()).collect();
    281             for (relay, _) in &requested {
    282                 self.status.begin_write(relay, now_unix_ms);
    283             }
    284             let results = self
    285                 .client
    286                 .publish(
    287                     requested.iter().map(|(relay, _)| relay.clone()).collect(),
    288                     event,
    289                     self.config().max_connections(),
    290                     Duration::from_millis(self.config().connect_timeout_ms()),
    291                     Duration::from_millis(operation_timeout_ms),
    292                 )
    293                 .await;
    294             let mut by_relay = BTreeMap::new();
    295             let observed_at_unix_ms = unix_time_ms().max(now_unix_ms);
    296             for result in results {
    297                 if !expected.contains(&result.relay)
    298                     || by_relay.contains_key(&result.relay)
    299                     || (!result.attempted && status::delivery_succeeded(&result.outcome))
    300                 {
    301                     return Err(SinkFailure::invalid_contract(&request));
    302                 }
    303                 let succeeded = status::delivery_succeeded(&result.outcome);
    304                 self.status.record_write(
    305                     &result.relay,
    306                     succeeded,
    307                     result.outcome.is_retryable(),
    308                     observed_at_unix_ms,
    309                 );
    310                 by_relay.insert(result.relay, (result.outcome, result.attempted));
    311             }
    312 
    313             let mut receipts = skipped;
    314             for (relay, target) in requested {
    315                 let (outcome, attempted) = by_relay.remove(&relay).unwrap_or_else(|| {
    316                     self.status
    317                         .record_write(&relay, false, true, observed_at_unix_ms);
    318                     (
    319                         DeliveryOutcome::unavailable()
    320                             .with_detail("missing_result", "relay returned no result")
    321                             .expect("static normalized outcome"),
    322                         true,
    323                     )
    324                 });
    325                 receipts.push(if attempted {
    326                     DeliveryTargetReceipt::attempted(target, outcome)
    327                 } else {
    328                     DeliveryTargetReceipt::skipped(target, outcome)
    329                         .map_err(|_| SinkFailure::invalid_contract(&request))?
    330                 });
    331             }
    332             DeliveryReceipt::for_request(&request, receipts)
    333                 .map_err(|_| SinkFailure::invalid_contract(&request))
    334         })
    335     }
    336 }
    337 
    338 impl EventSink for NostrTransport {
    339     fn status(&self) -> BoxFuture<'_, Result<SinkStatus, radroots_transport::Error>> {
    340         Box::pin(async move {
    341             self.require_open()?;
    342             Ok(status::sink_status(&self.status))
    343         })
    344     }
    345 
    346     fn deliver(
    347         &self,
    348         request: DeliveryRequest,
    349     ) -> BoxFuture<'_, Result<DeliveryReceipt, SinkFailure>> {
    350         Box::pin(async move {
    351             let prepared = self.prepare_delivery(request).map_err(|failure| *failure)?;
    352             self.execute_prepared_delivery(prepared).await
    353         })
    354     }
    355 
    356     fn deliver_selected(
    357         &self,
    358         request: DeliveryRequest,
    359         selected: TargetSet,
    360     ) -> BoxFuture<'_, Result<DeliveryReceipt, SinkFailure>> {
    361         Box::pin(async move {
    362             let prepared = self
    363                 .prepare_delivery_selected(request, &selected)
    364                 .map_err(|failure| *failure)?;
    365             self.execute_prepared_delivery(prepared).await
    366         })
    367     }
    368 }
    369 
    370 #[cfg(test)]
    371 mod tests {
    372     use super::*;
    373     use crate::{Config, RelayUrlPolicy};
    374     use radroots_transport::{
    375         Target, TargetSet,
    376         outcome::DeliveryOutcomeKind,
    377         policy::{SatisfactionClass, SatisfactionPolicy, TargetPolicy},
    378         sink::DeliveryPayload,
    379     };
    380     use std::sync::{
    381         Arc,
    382         atomic::{AtomicUsize, Ordering},
    383     };
    384 
    385     #[derive(Debug)]
    386     struct MockRelayClient {
    387         outcomes: BTreeMap<RelayUrl, DeliveryOutcome>,
    388     }
    389 
    390     impl RelayClient for MockRelayClient {
    391         fn publish<'a>(
    392             &'a self,
    393             relays: Vec<RelayUrl>,
    394             _event: ExactEvent,
    395             _max_connections: usize,
    396             _connect_timeout: Duration,
    397             _operation_timeout: Duration,
    398         ) -> BoxFuture<'a, Vec<RelayPublishResult>> {
    399             Box::pin(async move {
    400                 relays
    401                     .into_iter()
    402                     .map(|relay| RelayPublishResult {
    403                         attempted: true,
    404                         outcome: self
    405                             .outcomes
    406                             .get(&relay)
    407                             .cloned()
    408                             .unwrap_or_else(DeliveryOutcome::accepted),
    409                         relay,
    410                     })
    411                     .collect()
    412             })
    413         }
    414     }
    415 
    416     #[derive(Debug)]
    417     struct CountingRelayClient(Arc<AtomicUsize>);
    418 
    419     impl RelayClient for CountingRelayClient {
    420         fn publish<'a>(
    421             &'a self,
    422             _relays: Vec<RelayUrl>,
    423             _event: ExactEvent,
    424             _max_connections: usize,
    425             _connect_timeout: Duration,
    426             _operation_timeout: Duration,
    427         ) -> BoxFuture<'a, Vec<RelayPublishResult>> {
    428             self.0.fetch_add(1, Ordering::SeqCst);
    429             Box::pin(async { Vec::new() })
    430         }
    431     }
    432 
    433     fn payload() -> DeliveryPayload {
    434         let raw = r#"{"id":"56bfc78223bb2221bad82b539efdec1ade0f56d0eb0e1f592fd387df4b2ceee0","pubkey":"585591529da0bab31b3b1b1f986611cf5f435dca84f978c89ee8a40cca7103df","created_at":1700000001,"kind":0,"tags":[],"content":"{}","sig":"dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"}"#;
    435         DeliveryPayload::new(radroots_event_codec::decode::signed_event(raw).expect("signed event"))
    436     }
    437 
    438     fn request() -> DeliveryRequest {
    439         request_with_deadline(1_800_000_000_000)
    440     }
    441 
    442     fn request_with_deadline(deadline_unix_ms: u64) -> DeliveryRequest {
    443         DeliveryRequest::new(
    444             "nostr-delivery",
    445             payload(),
    446             TargetSet::new(vec![
    447                 Target::nostr_relay("wss://one.example").expect("one"),
    448                 Target::nostr_relay("wss://two.example").expect("two"),
    449             ])
    450             .expect("targets"),
    451             SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()),
    452             deadline_unix_ms,
    453         )
    454         .expect("request")
    455     }
    456 
    457     #[test]
    458     fn sink_returns_normalized_per_relay_partial_success() {
    459         let config = Config::from_profile(
    460             crate::profile::test_profile(
    461                 crate::RelayProfileKind::Public,
    462                 RelayUrlPolicy::Public,
    463                 ["wss://one.example", "wss://two.example"],
    464             )
    465             .expect("profile"),
    466         );
    467         let two = RelayUrl::parse("wss://two.example", RelayUrlPolicy::Public).expect("two");
    468         let client = MockRelayClient {
    469             outcomes: BTreeMap::from([(two, status::delivery_failure("rate limited"))]),
    470         };
    471         let transport = NostrTransport::with_client(config, Arc::new(client));
    472         let request = request();
    473         let receipt = futures::executor::block_on(transport.deliver(request.clone()))
    474             .expect("delivery receipt");
    475 
    476         assert_eq!(receipt.target_receipts().len(), 2);
    477         assert_eq!(
    478             receipt.target_receipts()[0].outcome().kind(),
    479             DeliveryOutcomeKind::Accepted
    480         );
    481         assert_eq!(
    482             receipt.target_receipts()[1].outcome().kind(),
    483             DeliveryOutcomeKind::Unavailable
    484         );
    485         assert!(!receipt.is_satisfied(&request).expect("satisfaction"));
    486     }
    487 
    488     #[test]
    489     fn selected_preparation_retains_binding_and_only_authorizes_selected_relays() {
    490         let config = Config::from_profile(
    491             crate::profile::test_profile(
    492                 crate::RelayProfileKind::Public,
    493                 RelayUrlPolicy::Public,
    494                 ["wss://one.example", "wss://two.example"],
    495             )
    496             .unwrap(),
    497         );
    498         let transport = NostrTransport::with_client(
    499             config,
    500             Arc::new(MockRelayClient {
    501                 outcomes: BTreeMap::new(),
    502             }),
    503         );
    504         let request = request();
    505         let selected = TargetSet::new(vec![request.target_set().targets()[0].clone()]).unwrap();
    506         let prepared = transport
    507             .prepare_delivery_selected(request.clone(), &selected)
    508             .unwrap();
    509         assert_eq!(prepared.request(), &request);
    510         assert_eq!(prepared.authorized.len(), 1);
    511         assert_eq!(&prepared.authorized[0].1, &selected.targets()[0]);
    512         let receipt =
    513             futures::executor::block_on(transport.execute_prepared_delivery(prepared)).unwrap();
    514         receipt.validate_for_request(&request).unwrap();
    515         assert!(receipt.target_receipts()[0].was_attempted());
    516         assert_eq!(
    517             receipt.target_receipts()[0].outcome().kind(),
    518             DeliveryOutcomeKind::Accepted
    519         );
    520         assert!(!receipt.target_receipts()[1].was_attempted());
    521         assert_eq!(
    522             receipt.target_receipts()[1].outcome().code(),
    523             Some("target_not_selected")
    524         );
    525         assert!(receipt.target_receipts()[1].outcome().is_retryable());
    526         assert!(!receipt.is_satisfied(&request).unwrap());
    527         let foreign =
    528             TargetSet::new(vec![Target::nostr_relay("wss://foreign.example").unwrap()]).unwrap();
    529         let failure = transport
    530             .prepare_delivery_selected(request.clone(), &foreign)
    531             .unwrap_err();
    532         failure.validate_for_request(&request).unwrap();
    533         assert_eq!(failure.code(), "invalid_transport_contract");
    534         let all = futures::executor::block_on(
    535             transport.deliver_selected(request.clone(), request.target_set().clone()),
    536         )
    537         .unwrap();
    538         assert!(all.is_satisfied(&request).unwrap());
    539     }
    540 
    541     #[test]
    542     fn upstream_messages_map_to_stable_outcomes() {
    543         let cases = [
    544             ("duplicate: already have", DeliveryOutcomeKind::Unavailable),
    545             ("blocked by policy", DeliveryOutcomeKind::Rejected),
    546             ("rate limited", DeliveryOutcomeKind::Unavailable),
    547             ("auth required", DeliveryOutcomeKind::Failed),
    548             ("connection timeout", DeliveryOutcomeKind::Unavailable),
    549             ("connection failed", DeliveryOutcomeKind::Unavailable),
    550         ];
    551         for (message, expected) in cases {
    552             assert_eq!(status::delivery_failure(message).kind(), expected);
    553         }
    554     }
    555 
    556     #[test]
    557     fn dropping_an_unpolled_delivery_performs_no_relay_work() {
    558         let calls = Arc::new(AtomicUsize::new(0));
    559         let config = Config::from_profile(
    560             crate::profile::test_profile(
    561                 crate::RelayProfileKind::Public,
    562                 RelayUrlPolicy::Public,
    563                 ["wss://one.example", "wss://two.example"],
    564             )
    565             .expect("profile"),
    566         );
    567         let transport =
    568             NostrTransport::with_client(config, Arc::new(CountingRelayClient(Arc::clone(&calls))));
    569         let delivery = transport.deliver(request());
    570         drop(delivery);
    571         assert_eq!(calls.load(Ordering::SeqCst), 0);
    572     }
    573 
    574     #[test]
    575     fn preparation_is_no_io_redacted_consuming_and_bound_to_exact_config() {
    576         let calls = Arc::new(AtomicUsize::new(0));
    577         let profile = crate::profile::test_profile(
    578             crate::RelayProfileKind::Public,
    579             RelayUrlPolicy::Public,
    580             ["wss://one.example", "wss://two.example"],
    581         )
    582         .expect("profile");
    583         let config = Config::from_profile(profile.clone());
    584         let transport =
    585             NostrTransport::with_client(config, Arc::new(CountingRelayClient(Arc::clone(&calls))));
    586         let request = request();
    587 
    588         let prepared = transport
    589             .prepare_delivery(request.clone())
    590             .expect("prepared delivery");
    591         assert_eq!(prepared.request(), &request);
    592         assert_eq!(format!("{prepared:?}"), "PreparedDelivery([redacted])");
    593         assert_eq!(calls.load(Ordering::SeqCst), 0);
    594 
    595         let receipt = futures::executor::block_on(transport.execute_prepared_delivery(prepared))
    596             .expect("executed delivery");
    597         assert_eq!(receipt.request_id(), request.request_id());
    598         assert_eq!(calls.load(Ordering::SeqCst), 1);
    599 
    600         let mismatch_calls = Arc::new(AtomicUsize::new(0));
    601         let mismatched = NostrTransport::with_client(
    602             Config::from_profile(profile)
    603                 .with_timeouts(5_000, 20_000, 2_000)
    604                 .expect("different bounded config"),
    605             Arc::new(CountingRelayClient(Arc::clone(&mismatch_calls))),
    606         );
    607         let prepared = transport
    608             .prepare_delivery(request)
    609             .expect("second prepared delivery");
    610         assert_eq!(
    611             futures::executor::block_on(mismatched.execute_prepared_delivery(prepared))
    612                 .expect_err("prepared authority is config-bound")
    613                 .code(),
    614             "invalid_transport_contract"
    615         );
    616         assert_eq!(mismatch_calls.load(Ordering::SeqCst), 0);
    617     }
    618 
    619     #[test]
    620     fn expired_delivery_deadline_performs_no_relay_work() {
    621         let calls = Arc::new(AtomicUsize::new(0));
    622         let config = Config::from_profile(
    623             crate::profile::test_profile(
    624                 crate::RelayProfileKind::Public,
    625                 RelayUrlPolicy::Public,
    626                 ["wss://one.example", "wss://two.example"],
    627             )
    628             .expect("profile"),
    629         );
    630         let transport =
    631             NostrTransport::with_client(config, Arc::new(CountingRelayClient(Arc::clone(&calls))));
    632         let receipt = futures::executor::block_on(transport.deliver(request_with_deadline(1)))
    633             .expect("bounded timeout receipt");
    634         assert_eq!(calls.load(Ordering::SeqCst), 0);
    635         assert!(
    636             receipt
    637                 .target_receipts()
    638                 .iter()
    639                 .all(|target| !target.was_attempted())
    640         );
    641     }
    642 
    643     #[derive(Debug)]
    644     struct ScriptedRelayClient(Vec<RelayPublishResult>);
    645 
    646     impl RelayClient for ScriptedRelayClient {
    647         fn publish<'a>(
    648             &'a self,
    649             _relays: Vec<RelayUrl>,
    650             _event: ExactEvent,
    651             _max_connections: usize,
    652             _connect_timeout: Duration,
    653             _operation_timeout: Duration,
    654         ) -> BoxFuture<'a, Vec<RelayPublishResult>> {
    655             Box::pin(async move { self.0.clone() })
    656         }
    657     }
    658 
    659     fn scripted(results: Vec<RelayPublishResult>) -> NostrTransport {
    660         let config = Config::from_profile(
    661             crate::profile::test_profile(
    662                 crate::RelayProfileKind::Public,
    663                 RelayUrlPolicy::Public,
    664                 ["wss://one.example", "wss://two.example"],
    665             )
    666             .expect("profile"),
    667         );
    668         NostrTransport::with_client(config, Arc::new(ScriptedRelayClient(results)))
    669     }
    670 
    671     #[test]
    672     fn sink_handles_missing_duplicate_unexpected_and_denied_targets() {
    673         let one = RelayUrl::parse("wss://one.example", RelayUrlPolicy::Public).expect("one");
    674         let missing = futures::executor::block_on(
    675             scripted(vec![RelayPublishResult {
    676                 relay: one.clone(),
    677                 attempted: true,
    678                 outcome: DeliveryOutcome::accepted(),
    679             }])
    680             .deliver(request()),
    681         )
    682         .expect("missing result receipt");
    683         assert_eq!(missing.target_receipts().len(), 2);
    684 
    685         let duplicate = scripted(vec![
    686             RelayPublishResult {
    687                 relay: one.clone(),
    688                 attempted: true,
    689                 outcome: DeliveryOutcome::accepted(),
    690             },
    691             RelayPublishResult {
    692                 relay: one,
    693                 attempted: true,
    694                 outcome: DeliveryOutcome::accepted(),
    695             },
    696         ]);
    697         assert_eq!(
    698             futures::executor::block_on(duplicate.deliver(request()))
    699                 .expect_err("duplicate relay evidence")
    700                 .code(),
    701             "invalid_transport_contract"
    702         );
    703 
    704         let other = RelayUrl::parse("wss://other.example", RelayUrlPolicy::Public).expect("other");
    705         let unexpected = scripted(vec![RelayPublishResult {
    706             relay: other,
    707             attempted: true,
    708             outcome: DeliveryOutcome::accepted(),
    709         }]);
    710         assert_eq!(
    711             futures::executor::block_on(unexpected.deliver(request()))
    712                 .expect_err("unexpected relay evidence")
    713                 .code(),
    714             "invalid_transport_contract"
    715         );
    716 
    717         let denied_request = DeliveryRequest::new(
    718             "denied",
    719             payload(),
    720             TargetSet::new(vec![
    721                 Target::nostr_relay("wss://other.example").expect("other"),
    722             ])
    723             .expect("targets"),
    724             SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()),
    725             1_800_000_000_000,
    726         )
    727         .expect("request");
    728         let denied = futures::executor::block_on(scripted(vec![]).deliver(denied_request))
    729             .expect("denied receipt");
    730         assert!(!denied.target_receipts()[0].was_attempted());
    731         assert!(futures::executor::block_on(scripted(vec![]).status()).is_ok());
    732     }
    733 
    734     #[test]
    735     fn skipped_results_remain_skipped_and_cannot_claim_acceptance() {
    736         let one = RelayUrl::parse("wss://one.example", RelayUrlPolicy::Public).unwrap();
    737         let two = RelayUrl::parse("wss://two.example", RelayUrlPolicy::Public).unwrap();
    738         let receipt = futures::executor::block_on(
    739             scripted(vec![
    740                 RelayPublishResult {
    741                     relay: one.clone(),
    742                     attempted: false,
    743                     outcome: status::delivery_failure("timeout"),
    744                 },
    745                 RelayPublishResult {
    746                     relay: two,
    747                     attempted: true,
    748                     outcome: DeliveryOutcome::accepted(),
    749                 },
    750             ])
    751             .deliver(request()),
    752         )
    753         .unwrap();
    754         assert!(!receipt.target_receipts()[0].was_attempted());
    755         assert_eq!(
    756             receipt.target_receipts()[0].outcome().code(),
    757             Some("timeout")
    758         );
    759         assert!(receipt.target_receipts()[1].was_attempted());
    760         assert_eq!(
    761             receipt.target_receipts()[1].outcome(),
    762             &DeliveryOutcome::accepted()
    763         );
    764         for outcome in [DeliveryOutcome::accepted(), DeliveryOutcome::delivered()] {
    765             let transport = scripted(vec![RelayPublishResult {
    766                 relay: one.clone(),
    767                 attempted: false,
    768                 outcome,
    769             }]);
    770             let failure = futures::executor::block_on(transport.deliver(request())).unwrap_err();
    771             assert_eq!(failure.code(), "invalid_transport_contract");
    772             assert!(
    773                 transport
    774                     .relay_status()
    775                     .relays()
    776                     .iter()
    777                     .all(|relay| relay.write().last_success_unix_ms().is_none())
    778             );
    779         }
    780     }
    781 
    782     #[test]
    783     fn live_relay_client_accepts_an_empty_batch_without_io() {
    784         let client = LiveRelayClient::isolated();
    785         let results = futures::executor::block_on(client.publish(
    786             vec![],
    787             ExactEvent::from_request(&request()).expect("exact event"),
    788             1,
    789             Duration::from_millis(1),
    790             Duration::from_millis(1),
    791         ));
    792         assert!(results.is_empty());
    793     }
    794 }