lib

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

exact_delivery.rs (20411B)


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