lib

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

wire_admission.rs (9609B)


      1 use super::*;
      2 use radroots_event::admission::RawEvent;
      3 use radroots_event_codec::verify::{self, Nip01SignatureVerifier};
      4 use radroots_storage::event::{AdmissionStage, EventAdmission};
      5 use radroots_transport::source::{EventProvenance, ObservedEvent};
      6 
      7 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
      8 enum Variant {
      9     Reordered,
     10     Limit,
     11     Extra,
     12     Signature,
     13     Duplicate,
     14     Oversize,
     15 }
     16 
     17 impl Variant {
     18     fn permits_admission(self) -> bool {
     19         matches!(self, Self::Reordered | Self::Limit)
     20     }
     21 }
     22 
     23 fn verified_admission(event: SignedEvent) -> EventAdmission {
     24     let target = Target::new(TransportId::NOSTR, "wss://relay.example").expect("target");
     25     let verified = verify::signature(
     26         verify::id(RawEvent::new(event.envelope().clone())).expect("identifier"),
     27         &Nip01SignatureVerifier,
     28     )
     29     .expect("actual Schnorr signature");
     30     let observed = ObservedEvent::new(
     31         event,
     32         EventProvenance::new(
     33             TransportId::NOSTR,
     34             target.fingerprint().clone(),
     35             1_800_000_200_000,
     36         )
     37         .expect("provenance"),
     38     );
     39     EventAdmission::verified(observed, verified).expect("verified incoming event")
     40 }
     41 
     42 fn alternate(original: &SignedEvent, variant: Variant) -> SignedEvent {
     43     let mut value: serde_json::Value =
     44         serde_json::from_str(original.raw_json()).expect("wire JSON");
     45     match variant {
     46         Variant::Extra => value["future_attribute"] = serde_json::json!("retained extension"),
     47         Variant::Signature => {
     48             value["sig"] = serde_json::json!(
     49                 Secp256k1::new()
     50                     .sign_schnorr_with_aux_rand(
     51                         &Message::from_digest(*original.id().as_bytes()),
     52                         &signing_keypair(),
     53                         &[2; 32],
     54                     )
     55                     .to_string()
     56             );
     57         }
     58         _ => {}
     59     }
     60     let mut raw = serde_json::to_string_pretty(&value).expect("alternate serialization");
     61     if variant == Variant::Duplicate {
     62         assert_eq!(raw.pop(), Some('}'));
     63         raw.push_str(&format!(",\"id\":\"{}\"}}", original.id().to_hex()));
     64     }
     65     if matches!(variant, Variant::Limit | Variant::Oversize) {
     66         let limit = 64 * 1024 + usize::from(variant == Variant::Oversize);
     67         raw.insert_str(0, &" ".repeat(limit - raw.len()));
     68         assert_eq!(raw.len(), limit);
     69     }
     70     let wire = radroots_event::wire::Nip01EventWire::parse_json(&raw).expect("valid identifier");
     71     SignedEvent::from_wire_verified_id(wire, raw).expect("exact raw/wire binding")
     72 }
     73 
     74 async fn exercise(
     75     storage: Arc<dyn SyncStorage>,
     76     variant: Variant,
     77 ) -> (SignedEvent, SignedEvent, SyncId) {
     78     let sink = Arc::new(ScriptedSink::new([DeliveryBehavior::Outcomes(vec![
     79         DeliveryOutcome::accepted(),
     80     ])]));
     81     let signer = Arc::new(MockSigner::new(SignBehavior::Success {
     82         completed_at_unix_ms: 1_800_000_200_500,
     83     }));
     84     let engine = Engine::builder(
     85         storage.clone(),
     86         Arc::new(TestClock(AtomicU64::new(1_800_000_200_000))),
     87         Arc::new(TestIds(AtomicU64::new(10))),
     88         DeadlinePolicy::new(10_000, 10_000, 10_000).expect("deadlines"),
     89     )
     90     .sink(sink.clone())
     91     .signer(signer.clone())
     92     .build()
     93     .expect("engine");
     94     let push = request(119, "wss://relay.example");
     95     let signed = engine
     96         .sign_prepared(push.clone())
     97         .await
     98         .expect("actual signed artifact");
     99     let original = signed
    100         .artifact()
    101         .signed()
    102         .expect("signed bytes")
    103         .event()
    104         .clone();
    105     let remote = alternate(&original, variant);
    106     assert_ne!(remote.raw_json(), original.raw_json());
    107     assert_eq!(remote.id(), original.id());
    108     assert_eq!(
    109         remote.wire() == original.wire(),
    110         !matches!(variant, Variant::Extra | Variant::Signature)
    111     );
    112     EventStore::admit(storage.as_ref(), verified_admission(remote.clone()))
    113         .await
    114         .expect("initial canonical observation");
    115     // The store's strict byte-conflict invariant remains in force.
    116     assert_eq!(
    117         EventStore::admit(storage.as_ref(), verified_admission(original.clone())).await,
    118         Err(radroots_storage::Error::EventConflict)
    119     );
    120 
    121     let result = engine.admit_signed(push.operation_id()).await;
    122     if variant.permits_admission() {
    123         assert!(
    124             result
    125                 .expect("equivalent-wire admission")
    126                 .artifact()
    127                 .admission_state()
    128                 .is_admitted()
    129         );
    130         assert!(
    131             engine
    132                 .admit_signed(push.operation_id())
    133                 .await
    134                 .expect("exact admission replay")
    135                 .is_replay()
    136         );
    137         engine
    138             .deliver_push(push.operation_id())
    139             .await
    140             .expect("original delivery");
    141         let requests = sink.requests.lock().expect("delivery records");
    142         assert_eq!(requests.len(), 1);
    143         assert_eq!(
    144             requests[0].payload().event().raw_json(),
    145             original.raw_json()
    146         );
    147     } else {
    148         assert_eq!(result, Err(Error::AdmissionFailed));
    149     }
    150     let status = engine
    151         .push_status(push.operation_id())
    152         .await
    153         .expect("status")
    154         .expect("retained operation");
    155     assert_eq!(
    156         status
    157             .artifact()
    158             .signed()
    159             .expect("original artifact")
    160             .event()
    161             .raw_json(),
    162         original.raw_json()
    163     );
    164     assert_eq!(signer.calls.load(Ordering::Relaxed), 1);
    165     let canonical = EventStore::query_raw(
    166         storage.as_ref(),
    167         EventQuery::for_ids(
    168             EventQueryBounds::first(1).expect("bounds"),
    169             vec![*original.id()],
    170         )
    171         .expect("identifier query"),
    172     )
    173     .await
    174     .expect("canonical event");
    175     assert_eq!(canonical.items().len(), 1);
    176     assert_eq!(canonical.items()[0].event().raw_json(), remote.raw_json());
    177     assert_eq!(
    178         canonical.items()[0].stage(),
    179         if variant.permits_admission() {
    180             AdmissionStage::Visible
    181         } else {
    182             AdmissionStage::Verified
    183         }
    184     );
    185     (original, remote, push.operation_id())
    186 }
    187 
    188 #[test]
    189 fn memory_wire_variants_preserve_both_originals_and_refuse_profile_or_signature_changes() {
    190     for (generation, variant) in [
    191         (81, Variant::Reordered),
    192         (82, Variant::Limit),
    193         (83, Variant::Extra),
    194         (84, Variant::Signature),
    195         (85, Variant::Duplicate),
    196         (86, Variant::Oversize),
    197     ] {
    198         block_on(exercise(
    199             Arc::new(MemoryStorage::new(
    200                 SourceGeneration::new([generation; 32]).expect("generation"),
    201             )),
    202             variant,
    203         ));
    204     }
    205 }
    206 
    207 #[tokio::test]
    208 async fn sqlite_wire_variants_preserve_both_originals_across_explicit_close_and_reopen() {
    209     for (generation, variant) in [
    210         (91, Variant::Reordered),
    211         (92, Variant::Limit),
    212         (93, Variant::Extra),
    213         (94, Variant::Signature),
    214         (95, Variant::Duplicate),
    215         (96, Variant::Oversize),
    216     ] {
    217         let directory = tempfile::tempdir().expect("database directory");
    218         let paths = Paths::from_directory(directory.path()).expect("paths");
    219         let storage = Arc::new(
    220             SqliteStorage::open(
    221                 OpenOptions::new(paths.clone(), OpenMode::Create)
    222                     .with_source_generation(
    223                         SourceGeneration::new([generation; 32]).expect("generation"),
    224                         1,
    225                     )
    226                     .expect("source generation"),
    227             )
    228             .await
    229             .expect("SQLite"),
    230         );
    231         let (original, remote, operation_id) = exercise(storage.clone(), variant).await;
    232         storage.close().await.expect("explicit close");
    233         let reopened = Arc::new(
    234             SqliteStorage::open(OpenOptions::new(paths, OpenMode::ReadOnly))
    235                 .await
    236                 .expect("read-only reopen"),
    237         );
    238         let events = reopened
    239             .query_raw(EventQuery::all(EventQueryBounds::first(1).expect("bounds")))
    240             .await
    241             .expect("retained canonical row");
    242         assert_eq!(events.items().len(), 1);
    243         assert_eq!(events.items()[0].event().raw_json(), remote.raw_json());
    244         assert_eq!(
    245             events.items()[0].stage(),
    246             if variant.permits_admission() {
    247                 AdmissionStage::Visible
    248             } else {
    249                 AdmissionStage::Verified
    250             }
    251         );
    252         let inspection: Arc<dyn SyncStorage> = reopened.clone();
    253         let reader = Engine::builder(
    254             inspection,
    255             Arc::new(TestClock(AtomicU64::new(1_800_000_201_000))),
    256             Arc::new(TestIds(AtomicU64::new(100))),
    257             DeadlinePolicy::new(10_000, 10_000, 10_000).expect("deadlines"),
    258         )
    259         .sink(Arc::new(MockSink))
    260         .build()
    261         .expect("read-only inspection without signer");
    262         let status = reader
    263             .push_status(operation_id)
    264             .await
    265             .expect("read-only status")
    266             .expect("original operation");
    267         assert_eq!(
    268             status
    269                 .artifact()
    270                 .signed()
    271                 .expect("original retained evidence")
    272                 .event()
    273                 .raw_json(),
    274             original.raw_json()
    275         );
    276         assert_eq!(
    277             status.artifact().admission_state().is_admitted(),
    278             variant.permits_admission()
    279         );
    280         reopened.close().await.expect("close inspection");
    281     }
    282 }