lib

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

shared.rs (6059B)


      1 use crate::{check, pause};
      2 use futures::FutureExt;
      3 use radroots_transport::{
      4     DeliveryRequest, EventSink, EventSource, FetchRequest, TargetSet,
      5     outcome::FetchTargetState,
      6     policy::{SatisfactionClass, SatisfactionPolicy, TargetPolicy},
      7     sink::DeliveryPayload,
      8     source::FetchBounds,
      9 };
     10 use radroots_transport_nostr::{
     11     Config, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind, RelayUrlPolicy,
     12 };
     13 use wasm_bindgen::prelude::*;
     14 
     15 fn now() -> u64 {
     16     js_sys::Date::now() as u64
     17 }
     18 fn profile_config(base: &str, route: &str) -> Config {
     19     Config::from_profile(
     20         RelayProfile::explicit(
     21             RelayProfileKind::Simulator,
     22             [RelayEndpoint::new(
     23                 format!("{base}/{route}"),
     24                 RelayUrlPolicy::Local,
     25                 RelayAccess::ReadWrite,
     26             )
     27             .unwrap()],
     28         )
     29         .unwrap(),
     30     )
     31     .with_timeouts(1000, 500, 100)
     32     .unwrap()
     33 }
     34 fn targets(config: &Config) -> TargetSet {
     35     TargetSet::new(
     36         config
     37             .relays()
     38             .iter()
     39             .map(|relay| relay.to_target().unwrap())
     40             .collect(),
     41     )
     42     .unwrap()
     43 }
     44 
     45 #[wasm_bindgen]
     46 pub fn fixture_event() -> String {
     47     // Consume the source-owned conformance vector, retaining an independently
     48     // verified signature while deliberately changing only its outer whitespace.
     49     let vectors: serde_json::Value = serde_json::from_str(include_str!(
     50         "../../../../../contracts/conformance/vectors/event/verified_admission.v1.json"
     51     ))
     52     .unwrap();
     53     format!(
     54         " \n{} \t",
     55         serde_json::to_string_pretty(&vectors["vectors"][1]["input"]["event"]).unwrap()
     56     )
     57 }
     58 
     59 #[wasm_bindgen]
     60 pub async fn verify_shared_session(base: String) -> Result<js_sys::Array, JsValue> {
     61     let passed = js_sys::Array::new();
     62     let raw = fixture_event();
     63     let config = profile_config(&base, "shared-accept");
     64     let transport = radroots_transport_nostr_browser::create_transport(config.clone());
     65     let page = transport
     66         .fetch(
     67             FetchRequest::new(
     68                 "browser-source",
     69                 targets(&config),
     70                 FetchBounds::new(10, now() + 5000).unwrap(),
     71             )
     72             .unwrap(),
     73         )
     74         .await
     75         .map_err(|_| JsValue::from_str("shared fetch error"))?;
     76     check(
     77         page.events().len() == 1 && page.target_outcomes()[0].state() == FetchTargetState::Complete,
     78         &format!(
     79             "shared verified source and EOSE: events={} targets={:?}",
     80             page.events().len(),
     81             page.target_outcomes()
     82         ),
     83     )?;
     84     passed.push(&"shared independently verified event and EOSE".into());
     85     let request = DeliveryRequest::new(
     86         "browser-exact",
     87         DeliveryPayload::new(radroots_event_codec::decode::signed_event(&raw).unwrap()),
     88         targets(&config),
     89         SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()),
     90         now() + 5000,
     91     )
     92     .unwrap();
     93     let receipt = transport
     94         .deliver(request)
     95         .await
     96         .map_err(|_| JsValue::from_str("shared deliver error"))?;
     97     check(
     98         receipt.target_receipts()[0]
     99             .outcome()
    100             .satisfies(SatisfactionClass::Accepted),
    101         "shared exact acceptance",
    102     )?;
    103     transport.shutdown().await;
    104     check(transport.admission_is_closed(), "shared shutdown admission")?;
    105     passed.push(&"shared original publication and matching ACK".into());
    106 
    107     for route in ["shared-negative", "shared-noack", "shared-badack"] {
    108         let config = profile_config(&base, route);
    109         let transport = radroots_transport_nostr_browser::create_transport(config.clone());
    110         let request = DeliveryRequest::new(
    111             route,
    112             DeliveryPayload::new(radroots_event_codec::decode::signed_event(&raw).unwrap()),
    113             targets(&config),
    114             SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()),
    115             now() + 5000,
    116         )
    117         .unwrap();
    118         let receipt = transport
    119             .deliver(request)
    120             .await
    121             .map_err(|_| JsValue::from_str("shared negative deliver error"))?;
    122         check(
    123             !receipt.target_receipts()[0]
    124                 .outcome()
    125                 .satisfies(SatisfactionClass::Accepted),
    126             route,
    127         )?;
    128         transport.shutdown().await;
    129         passed.push(&JsValue::from_str(route));
    130     }
    131 
    132     let config = profile_config(&base, "shared-disconnect");
    133     let transport = radroots_transport_nostr_browser::create_transport(config.clone());
    134     let page = transport
    135         .fetch(
    136             FetchRequest::new(
    137                 "browser-gap",
    138                 targets(&config),
    139                 FetchBounds::new(10, now() + 5000).unwrap(),
    140             )
    141             .unwrap(),
    142         )
    143         .await
    144         .map_err(|_| JsValue::from_str("shared disconnect fetch error"))?;
    145     check(
    146         page.target_outcomes()[0].state() != FetchTargetState::Complete,
    147         "disconnect cannot prove complete history",
    148     )?;
    149     transport.shutdown().await;
    150     passed.push(&"shared disconnect never proves complete history".into());
    151 
    152     let config = profile_config(&base, "shared-observer");
    153     let transport = radroots_transport_nostr_browser::create_transport(config.clone());
    154     let mut fetch = transport.fetch(
    155         FetchRequest::new(
    156             "browser-observer",
    157             targets(&config),
    158             FetchBounds::new(10, now() + 5000).unwrap(),
    159         )
    160         .unwrap(),
    161     );
    162     check(
    163         fetch.as_mut().now_or_never().is_none(),
    164         "shared fetch starts pending",
    165     )?;
    166     pause().await;
    167     check(
    168         fetch.as_mut().now_or_never().is_none(),
    169         "shared original observer remains pending",
    170     )?;
    171     drop(fetch);
    172     transport.shutdown().await;
    173     pause().await;
    174     check(
    175         !transport.has_in_flight_operations(),
    176         "shared observer loss frees original call",
    177     )?;
    178     passed.push(&"shared fetch observer loss and shutdown".into());
    179     Ok(passed)
    180 }