lib

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

event_store.rs (27716B)


      1 use futures_executor::block_on;
      2 use radroots_event::{
      3     EventId, SignedEvent, VerifiedEvent,
      4     admission::{AdmissionPolicy, RawEvent, VisibilityPolicy, VisibleEvent},
      5     wire::Nip01EventWire,
      6 };
      7 use radroots_storage::{
      8     Error, EventStore,
      9     event::{
     10         AdmissionDisposition, AdmissionReceipt, AdmissionStage, EventAdmission, EventPage,
     11         EventPosition, EventQuery, EventQueryBounds, EventSequence, SourceGeneration,
     12         StoredEventProvenance, StoredRawEvent, StoredVerifiedEvent, StoredVisibleEvent,
     13         VisibilityInput, VisibilitySnapshot, evaluate_visibility,
     14     },
     15     status::{EventStoreHealth, EventStoreMode, EventStoreStatus},
     16 };
     17 use radroots_transport::{
     18     BoxFuture, Target, TransportId,
     19     source::{EventProvenance, ObservedEvent},
     20 };
     21 use std::sync::Mutex;
     22 
     23 #[derive(Clone)]
     24 struct Entry {
     25     position: EventPosition,
     26     admission: EventAdmission,
     27     provenance: Vec<EventProvenance>,
     28 }
     29 
     30 struct MemoryEventStore {
     31     generation: SourceGeneration,
     32     entries: Mutex<Vec<Entry>>,
     33 }
     34 
     35 impl MemoryEventStore {
     36     fn new() -> Self {
     37         Self {
     38             generation: SourceGeneration::new([7; 32]).expect("non-zero generation"),
     39             entries: Mutex::new(Vec::new()),
     40         }
     41     }
     42 
     43     fn selected(&self, query: &EventQuery) -> Result<Vec<Entry>, Error> {
     44         if let Some(cursor) = query.bounds().cursor()
     45             && cursor.generation() != self.generation
     46         {
     47             return Err(Error::SourceGenerationChanged);
     48         }
     49         let after = query
     50             .bounds()
     51             .cursor()
     52             .map_or(0, |cursor| cursor.sequence().get());
     53         Ok(self
     54             .entries
     55             .lock()
     56             .expect("test store lock")
     57             .iter()
     58             .filter(|entry| {
     59                 entry.position.sequence().get() > after && query.selects(entry.admission.event_id())
     60             })
     61             .take(usize::from(query.bounds().limit()))
     62             .cloned()
     63             .collect())
     64     }
     65 }
     66 
     67 #[test]
     68 fn unsupported_adapter_cannot_invent_a_source_fence() {
     69     assert_eq!(
     70         block_on(MemoryEventStore::new().source_token()),
     71         Err(Error::BackendUnavailable)
     72     );
     73     assert_eq!(
     74         block_on(MemoryEventStore::new().query_visible_at(
     75             EventQuery::all(EventQueryBounds::first(5).unwrap()),
     76             radroots_storage::event::EventSourceToken::new(
     77                 SourceGeneration::new([1; 32]).unwrap(),
     78                 0
     79             ),
     80         )),
     81         Err(Error::BackendUnavailable)
     82     );
     83     assert_eq!(
     84         block_on(MemoryEventStore::new().maintain_visibility(
     85             radroots_storage::event::VisibilityIndexBounds::new(64, 16 * 1024 * 1024).unwrap()
     86         )),
     87         Err(Error::BackendUnavailable)
     88     );
     89 }
     90 
     91 impl EventStore for MemoryEventStore {
     92     fn status(&self) -> BoxFuture<'_, Result<EventStoreStatus, Error>> {
     93         Box::pin(async move {
     94             let entries = self.entries.lock().expect("test store lock");
     95             let raw = entries.len() as u64;
     96             let verified = entries
     97                 .iter()
     98                 .filter(|entry| entry.admission.stage() >= AdmissionStage::Verified)
     99                 .count() as u64;
    100             let visible = entries
    101                 .iter()
    102                 .filter(|entry| entry.admission.stage() == AdmissionStage::Visible)
    103                 .count() as u64;
    104             EventStoreStatus::new(
    105                 self.generation,
    106                 EventStoreMode::ReadWrite,
    107                 EventStoreHealth::Available,
    108                 raw,
    109                 verified,
    110                 visible,
    111             )
    112         })
    113     }
    114 
    115     fn admit(&self, admission: EventAdmission) -> BoxFuture<'_, Result<AdmissionReceipt, Error>> {
    116         Box::pin(async move {
    117             let mut entries = self.entries.lock().expect("test store lock");
    118             if let Some(entry) = entries
    119                 .iter_mut()
    120                 .find(|entry| entry.admission.event_id() == admission.event_id())
    121             {
    122                 if entry.admission.event() != admission.event() {
    123                     return Err(Error::EventConflict);
    124                 }
    125                 if admission.stage() < entry.admission.stage() {
    126                     return Err(Error::AdmissionRegression);
    127                 }
    128                 let disposition = if admission.stage() == entry.admission.stage() {
    129                     AdmissionDisposition::Duplicate
    130                 } else {
    131                     AdmissionDisposition::Advanced
    132                 };
    133                 if !entry.provenance.contains(admission.provenance()) {
    134                     entry.provenance.push(admission.provenance().clone());
    135                 }
    136                 entry.admission = admission;
    137                 return Ok(AdmissionReceipt::new(
    138                     *entry.admission.event_id(),
    139                     entry.position,
    140                     entry.admission.stage(),
    141                     disposition,
    142                 ));
    143             }
    144 
    145             let sequence = EventSequence::new(entries.len() as u64 + 1)?;
    146             let position = EventPosition::new(self.generation, sequence);
    147             let receipt = AdmissionReceipt::new(
    148                 *admission.event_id(),
    149                 position,
    150                 admission.stage(),
    151                 AdmissionDisposition::Inserted,
    152             );
    153             let provenance = vec![admission.provenance().clone()];
    154             entries.push(Entry {
    155                 position,
    156                 admission,
    157                 provenance,
    158             });
    159             Ok(receipt)
    160         })
    161     }
    162 
    163     fn query_raw(
    164         &self,
    165         query: EventQuery,
    166     ) -> BoxFuture<'_, Result<EventPage<StoredRawEvent>, Error>> {
    167         Box::pin(async move {
    168             let items = self
    169                 .selected(&query)?
    170                 .into_iter()
    171                 .map(|entry| {
    172                     StoredRawEvent::new(
    173                         entry.position,
    174                         entry.admission.event().clone(),
    175                         entry.admission.stage(),
    176                     )
    177                 })
    178                 .collect();
    179             EventPage::new(self.generation, items, None, query.bounds())
    180         })
    181     }
    182 
    183     fn query_verified(
    184         &self,
    185         query: EventQuery,
    186     ) -> BoxFuture<'_, Result<EventPage<StoredVerifiedEvent>, Error>> {
    187         Box::pin(async move {
    188             let items = self
    189                 .selected(&query)?
    190                 .into_iter()
    191                 .filter_map(|entry| {
    192                     (entry.admission.stage() >= AdmissionStage::Verified).then(|| {
    193                         StoredVerifiedEvent::new(entry.position, entry.admission.event().clone())
    194                     })
    195                 })
    196                 .collect();
    197             EventPage::new(self.generation, items, None, query.bounds())
    198         })
    199     }
    200 
    201     fn query_visible(
    202         &self,
    203         query: EventQuery,
    204     ) -> BoxFuture<'_, Result<EventPage<StoredVisibleEvent>, Error>> {
    205         Box::pin(async move {
    206             let items = self
    207                 .selected(&query)?
    208                 .into_iter()
    209                 .filter_map(|entry| {
    210                     (entry.admission.stage() == AdmissionStage::Visible).then(|| {
    211                         StoredVisibleEvent::new(entry.position, entry.admission.event().clone())
    212                     })
    213                 })
    214                 .collect();
    215             EventPage::new(self.generation, items, None, query.bounds())
    216         })
    217     }
    218 
    219     fn rebuild_visibility(&self) -> BoxFuture<'_, Result<VisibilitySnapshot, Error>> {
    220         Box::pin(async move {
    221             let entries = self.entries.lock().expect("test store lock");
    222             evaluate_visibility(
    223                 self.generation,
    224                 entries.iter().map(|entry| {
    225                     VisibilityInput::new(
    226                         entry.position,
    227                         entry.admission.event(),
    228                         entry.admission.stage(),
    229                     )
    230                 }),
    231             )
    232             .map(|evaluation| evaluation.into_snapshot())
    233         })
    234     }
    235 
    236     fn query_provenance(
    237         &self,
    238         event_id: EventId,
    239         bounds: EventQueryBounds,
    240     ) -> BoxFuture<'_, Result<EventPage<StoredEventProvenance>, Error>> {
    241         Box::pin(async move {
    242             let entries = self.entries.lock().expect("test store lock");
    243             let entry = entries
    244                 .iter()
    245                 .find(|entry| entry.admission.event_id() == &event_id)
    246                 .ok_or(Error::EventNotFound)?;
    247             let items = entry
    248                 .provenance
    249                 .iter()
    250                 .take(usize::from(bounds.limit()))
    251                 .cloned()
    252                 .map(|provenance| StoredEventProvenance::new(entry.position, provenance))
    253                 .collect();
    254             EventPage::new(self.generation, items, None, bounds)
    255         })
    256     }
    257 }
    258 
    259 struct Allow;
    260 
    261 impl radroots_event::admission::SignatureVerifier for Allow {
    262     fn verify_signature(
    263         &self,
    264         _event: &radroots_event::Event,
    265     ) -> Result<(), radroots_event::Error> {
    266         Ok(())
    267     }
    268 }
    269 
    270 impl AdmissionPolicy for Allow {
    271     type Error = core::convert::Infallible;
    272 
    273     fn policy_id(&self) -> &'static str {
    274         "test.storage.admission.v1"
    275     }
    276 
    277     fn admit(
    278         &self,
    279         _event: &radroots_event::admission::ContractValidatedEvent,
    280     ) -> Result<(), Self::Error> {
    281         Ok(())
    282     }
    283 }
    284 
    285 impl VisibilityPolicy for Allow {
    286     type Error = core::convert::Infallible;
    287 
    288     fn policy_id(&self) -> &'static str {
    289         "test.storage.visibility.v1"
    290     }
    291 
    292     fn make_visible(
    293         &self,
    294         _event: &radroots_event::admission::AdmittedEvent,
    295     ) -> Result<(), Self::Error> {
    296         Ok(())
    297     }
    298 }
    299 
    300 fn signed_event_with_signature(signature_byte: &str) -> SignedEvent {
    301     let mut wire = Nip01EventWire {
    302         id: "0".repeat(64),
    303         pubkey: "585591529da0bab31b3b1b1f986611cf5f435dca84f978c89ee8a40cca7103df".to_owned(),
    304         created_at: 1_800_000_100,
    305         kind: 0,
    306         tags: vec![],
    307         content: "{\"display_name\":\"Moss Street Farm\",\"bot\":false}".to_owned(),
    308         sig: signature_byte.repeat(64),
    309         extra: Default::default(),
    310     };
    311     wire.id = wire
    312         .computed_event_id()
    313         .expect("canonical event id")
    314         .to_hex();
    315     let raw_json = serde_json::json!({
    316         "id": &wire.id,
    317         "pubkey": &wire.pubkey,
    318         "created_at": wire.created_at,
    319         "kind": wire.kind,
    320         "tags": &wire.tags,
    321         "content": &wire.content,
    322         "sig": &wire.sig,
    323     })
    324     .to_string();
    325     SignedEvent::from_wire_verified_id(wire, raw_json).expect("signed event")
    326 }
    327 
    328 fn signed_event() -> SignedEvent {
    329     signed_event_with_signature("42")
    330 }
    331 
    332 fn observed(event: SignedEvent, observed_at: u64) -> ObservedEvent {
    333     let target = Target::new(TransportId::NOSTR, "wss://relay.example").expect("relay target");
    334     let provenance = EventProvenance::new(
    335         TransportId::NOSTR,
    336         target.fingerprint().clone(),
    337         observed_at,
    338     )
    339     .expect("provenance");
    340     ObservedEvent::new(event, provenance)
    341 }
    342 
    343 fn verified(event: &SignedEvent) -> VerifiedEvent {
    344     RawEvent::new(event.envelope().clone())
    345         .verify_id()
    346         .expect("event id")
    347         .verify_signature(&Allow)
    348         .expect("signature")
    349 }
    350 
    351 fn visible(event: &SignedEvent) -> VisibleEvent {
    352     let verified = verified(event);
    353     let validated = if event.envelope().kind_u32() == 5 {
    354         verified
    355             .validate_contract_for_admission("radroots.social.deletion_request.v1")
    356             .expect("deletion contract")
    357     } else {
    358         verified.validate_contract().expect("contract")
    359     };
    360     validated
    361         .admit_with(&Allow)
    362         .expect("admission")
    363         .make_visible_with(&Allow)
    364         .expect("visibility")
    365 }
    366 
    367 fn indexed_event(
    368     author: &str,
    369     time: u64,
    370     kind: u32,
    371     tags: Vec<Vec<String>>,
    372     content: &str,
    373 ) -> SignedEvent {
    374     let mut wire = Nip01EventWire {
    375         id: "0".repeat(64),
    376         pubkey: author.to_owned(),
    377         created_at: time,
    378         kind,
    379         tags,
    380         content: content.to_owned(),
    381         sig: "42".repeat(64),
    382         extra: Default::default(),
    383     };
    384     wire.id = wire.computed_event_id().unwrap().to_hex();
    385     let raw = serde_json::to_string(&wire).unwrap();
    386     SignedEvent::from_wire_verified_id(wire, raw).unwrap()
    387 }
    388 
    389 #[test]
    390 fn memory_indexed_address_deletion_head_ties_and_unsupported_authority_match_reference() {
    391     use radroots_storage::memory::MemoryStorage;
    392     const AUTHOR: &str = "585591529da0bab31b3b1b1f986611cf5f435dca84f978c89ee8a40cca7103df";
    393     const OTHER: &str = "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798";
    394     let storage = MemoryStorage::new(SourceGeneration::new([101; 32]).unwrap());
    395     let address = format!("0:{AUTHOR}:");
    396     let addressable = format!("30023:{AUTHOR}:");
    397     let cases = [
    398         (
    399             indexed_event(AUTHOR, 10, 0, vec![], r#"{"name":"old"}"#),
    400             true,
    401         ),
    402         (
    403             indexed_event(AUTHOR, 20, 0, vec![], r#"{"name":"first tie"}"#),
    404             true,
    405         ),
    406         (
    407             indexed_event(AUTHOR, 20, 0, vec![], r#"{"name":"second tie"}"#),
    408             true,
    409         ),
    410         (
    411             indexed_event(
    412                 OTHER,
    413                 25,
    414                 5,
    415                 vec![vec!["a".into(), address.clone()]],
    416                 "wrong author",
    417             ),
    418             true,
    419         ),
    420         (
    421             indexed_event(AUTHOR, 25, 5, vec![vec!["a".into(), address]], "cutoff"),
    422             true,
    423         ),
    424         (
    425             indexed_event(AUTHOR, 30, 0, vec![], r#"{"name":"later"}"#),
    426             true,
    427         ),
    428         (
    429             indexed_event(AUTHOR, 5, 0, vec![], r#"{"name":"older arrives late"}"#),
    430             true,
    431         ),
    432         (
    433             indexed_event(AUTHOR, 40, 0, vec![], "unsupported profile content"),
    434             false,
    435         ),
    436         (
    437             indexed_event(AUTHOR, 50, 30023, vec![], "missing identifier"),
    438             false,
    439         ),
    440         (
    441             indexed_event(
    442                 AUTHOR,
    443                 51,
    444                 30023,
    445                 vec![vec!["d".into(), "".into()]],
    446                 "explicit empty",
    447             ),
    448             false,
    449         ),
    450         (
    451             indexed_event(AUTHOR, 52, 30023, vec![], "missing again"),
    452             false,
    453         ),
    454         (
    455             indexed_event(
    456                 AUTHOR,
    457                 60,
    458                 5,
    459                 vec![vec!["a".into(), addressable]],
    460                 "address cutoff",
    461             ),
    462             true,
    463         ),
    464     ];
    465     for (event, make_visible) in cases {
    466         let admission = if make_visible {
    467             EventAdmission::visible(observed(event.clone(), 100), visible(&event)).unwrap()
    468         } else {
    469             EventAdmission::verified(observed(event.clone(), 100), verified(&event)).unwrap()
    470         };
    471         block_on(storage.admit(admission.clone())).unwrap();
    472         block_on(storage.admit(admission)).unwrap();
    473         let oracle = block_on(storage.rebuild_visibility()).unwrap();
    474         let mut actual =
    475             block_on(storage.query_visible(EventQuery::all(EventQueryBounds::first(100).unwrap())))
    476                 .unwrap()
    477                 .items()
    478                 .iter()
    479                 .map(|item| *item.event().id())
    480                 .collect::<Vec<_>>();
    481         actual.sort();
    482         assert_eq!(actual, oracle.visible_event_ids());
    483         assert_eq!(
    484             block_on(storage.status()).unwrap().visible_events(),
    485             actual.len() as u64
    486         );
    487     }
    488 }
    489 
    490 #[test]
    491 fn memory_indexed_scoped_byte_pages_and_fences_preserve_continuation() {
    492     use radroots_storage::{event::EventSourceToken, memory::MemoryStorage};
    493     let generation = SourceGeneration::new([102; 32]).unwrap();
    494     let storage = MemoryStorage::new(generation);
    495     let author = "585591529da0bab31b3b1b1f986611cf5f435dca84f978c89ee8a40cca7103df";
    496     let mut ids = Vec::new();
    497     for time in 0..12 {
    498         let event = indexed_event(author, time, 1, vec![], &"x".repeat(120_000));
    499         ids.push(*event.id());
    500         block_on(storage.admit(
    501             EventAdmission::visible(observed(event.clone(), 100), visible(&event)).unwrap(),
    502         ))
    503         .unwrap();
    504     }
    505     let token = block_on(storage.source_token()).unwrap();
    506     let first = block_on(
    507         storage.query_visible_at(EventQuery::all(EventQueryBounds::first(12).unwrap()), token),
    508     )
    509     .unwrap();
    510     assert!(first.items().len() < 12);
    511     let next = block_on(
    512         storage.query_visible_at(
    513             EventQuery::all(
    514                 EventQueryBounds::first(12)
    515                     .unwrap()
    516                     .after(first.next_cursor().unwrap()),
    517             ),
    518             token,
    519         ),
    520     )
    521     .unwrap();
    522     assert_eq!(first.items().len() + next.items().len(), 12);
    523     assert!(next.next_cursor().is_none());
    524     let selected = EventQuery::for_ids(
    525         EventQueryBounds::first(5).unwrap(),
    526         vec![ids[11], EventId::from_bytes([255; 32]), ids[0]],
    527     )
    528     .unwrap();
    529     let page = block_on(storage.query_visible_at(selected, token)).unwrap();
    530     assert_eq!(
    531         page.items()
    532             .iter()
    533             .map(|item| *item.event().id())
    534             .collect::<Vec<_>>(),
    535         vec![ids[0], ids[11]]
    536     );
    537     assert_eq!(
    538         block_on(storage.query_visible_at(
    539             EventQuery::all(EventQueryBounds::first(5).unwrap()),
    540             EventSourceToken::new(generation, token.epoch() - 1)
    541         )),
    542         Err(Error::SourceEpochChanged)
    543     );
    544     let cursor = EventPosition::new(
    545         SourceGeneration::new([103; 32]).unwrap(),
    546         EventSequence::new(1).unwrap(),
    547     );
    548     assert_eq!(
    549         block_on(storage.query_visible(EventQuery::all(
    550             EventQueryBounds::first(5).unwrap().after(cursor)
    551         ))),
    552         Err(Error::SourceGenerationChanged)
    553     );
    554 }
    555 
    556 #[test]
    557 fn event_store_is_dyn_compatible_and_enforces_monotonic_admission() {
    558     let store = MemoryEventStore::new();
    559     let dynamic: &dyn EventStore = &store;
    560     let event = signed_event();
    561 
    562     let inserted = block_on(dynamic.admit(EventAdmission::raw(observed(event.clone(), 1))))
    563         .expect("raw insertion");
    564     assert_eq!(inserted.disposition(), AdmissionDisposition::Inserted);
    565     assert_eq!(inserted.stage(), AdmissionStage::Raw);
    566 
    567     let advanced = block_on(
    568         dynamic.admit(
    569             EventAdmission::verified(observed(event.clone(), 2), verified(&event))
    570                 .expect("verified admission"),
    571         ),
    572     )
    573     .expect("verified advancement");
    574     assert_eq!(advanced.disposition(), AdmissionDisposition::Advanced);
    575     assert_eq!(advanced.position(), inserted.position());
    576 
    577     let visible_event = visible(&event);
    578     let advanced = block_on(
    579         dynamic.admit(
    580             EventAdmission::visible(observed(event.clone(), 3), visible_event)
    581                 .expect("visible admission"),
    582         ),
    583     )
    584     .expect("visible advancement");
    585     assert_eq!(advanced.stage(), AdmissionStage::Visible);
    586 
    587     let duplicate = block_on(
    588         dynamic.admit(
    589             EventAdmission::visible(observed(event.clone(), 3), visible(&event))
    590                 .expect("duplicate visible admission"),
    591         ),
    592     )
    593     .expect("idempotent duplicate");
    594     assert_eq!(duplicate.disposition(), AdmissionDisposition::Duplicate);
    595 
    596     assert_eq!(
    597         block_on(dynamic.admit(EventAdmission::raw(observed(event, 4)))),
    598         Err(Error::AdmissionRegression)
    599     );
    600 
    601     let conflicting = signed_event_with_signature("43");
    602     assert_eq!(
    603         EventAdmission::verified(observed(conflicting.clone(), 5), verified(&signed_event())),
    604         Err(Error::AdmissionEventMismatch)
    605     );
    606     assert_eq!(
    607         block_on(dynamic.admit(EventAdmission::raw(observed(conflicting, 6)))),
    608         Err(Error::EventConflict)
    609     );
    610 }
    611 
    612 #[test]
    613 fn event_queries_preserve_stage_generation_bounds_and_provenance() {
    614     let store = MemoryEventStore::new();
    615     let event = signed_event();
    616     let event_id = *event.id();
    617     block_on(
    618         store.admit(
    619             EventAdmission::visible(observed(event.clone(), 5), visible(&event))
    620                 .expect("visible admission"),
    621         ),
    622     )
    623     .expect("insert visible event");
    624 
    625     let bounds = EventQueryBounds::first(1).expect("query bounds");
    626     let query = EventQuery::for_ids(bounds, vec![event_id]).expect("id query");
    627     let raw = block_on(store.query_raw(query.clone())).expect("raw page");
    628     let verified = block_on(store.query_verified(query.clone())).expect("verified page");
    629     let visible = block_on(store.query_visible(query)).expect("visible page");
    630     let provenance = block_on(store.query_provenance(event_id, bounds)).expect("provenance page");
    631 
    632     assert_eq!(raw.items().len(), 1);
    633     assert_eq!(raw.items()[0].stage(), AdmissionStage::Visible);
    634     assert_eq!(verified.items().len(), 1);
    635     assert_eq!(visible.items().len(), 1);
    636     assert_eq!(provenance.items().len(), 1);
    637     assert_eq!(raw.generation(), store.generation);
    638 
    639     let status = block_on(store.status()).expect("status");
    640     assert_eq!(status.raw_events(), 1);
    641     assert_eq!(status.verified_events(), 1);
    642     assert_eq!(status.visible_events(), 1);
    643 }
    644 
    645 #[test]
    646 fn bounds_generations_and_status_reject_invalid_state() {
    647     assert_eq!(
    648         SourceGeneration::new([0; 32]),
    649         Err(Error::InvalidSourceGeneration)
    650     );
    651     assert_eq!(EventSequence::new(0), Err(Error::InvalidEventSequence));
    652     assert_eq!(
    653         EventQueryBounds::first(0),
    654         Err(Error::InvalidEventQueryLimit)
    655     );
    656     assert_eq!(
    657         EventStoreStatus::new(
    658             SourceGeneration::new([1; 32]).expect("generation"),
    659             EventStoreMode::ReadOnly,
    660             EventStoreHealth::Degraded,
    661             1,
    662             2,
    663             0,
    664         ),
    665         Err(Error::CorruptStoredEvent)
    666     );
    667 }
    668 
    669 #[test]
    670 fn event_value_models_cover_bounds_accessors_and_durable_reconstruction() {
    671     let generation = SourceGeneration::new([1; 32]).expect("generation");
    672     let other_generation = SourceGeneration::new([2; 32]).expect("other generation");
    673     let sequence = EventSequence::new(1).expect("sequence");
    674     let position = EventPosition::new(generation, sequence);
    675     assert_eq!(generation.as_bytes(), &[1; 32]);
    676     assert_eq!(sequence.get(), 1);
    677     assert_eq!(position.generation(), generation);
    678     assert_eq!(position.sequence(), sequence);
    679 
    680     assert_eq!(
    681         EventQueryBounds::first(radroots_storage::event::EVENT_QUERY_LIMIT_MAX + 1),
    682         Err(Error::InvalidEventQueryLimit)
    683     );
    684     let bounds = EventQueryBounds::first(1).expect("bounds").after(position);
    685     assert_eq!(bounds.limit(), 1);
    686     assert_eq!(bounds.cursor(), Some(position));
    687     let event = signed_event();
    688     let event_id = *event.id();
    689     assert_eq!(
    690         EventQuery::for_ids(bounds, Vec::new()),
    691         Err(Error::EmptyEventQueryIds)
    692     );
    693     assert_eq!(
    694         EventQuery::for_ids(bounds, vec![event_id, event_id]),
    695         Err(Error::DuplicateEventQueryId)
    696     );
    697     assert_eq!(
    698         EventQuery::for_ids(
    699             bounds,
    700             vec![event_id; radroots_storage::event::EVENT_QUERY_ID_MAX + 1]
    701         ),
    702         Err(Error::TooManyEventQueryIds)
    703     );
    704     let all = EventQuery::all(bounds);
    705     assert!(all.event_ids().is_empty());
    706     assert!(all.selects(&event_id));
    707     let selected = EventQuery::for_ids(bounds, vec![event_id]).expect("selected query");
    708     assert_eq!(selected.bounds(), bounds);
    709     assert_eq!(selected.event_ids(), &[event_id]);
    710     assert!(selected.selects(&event_id));
    711     let other_event_id = EventId::parse("f".repeat(64)).expect("other event id");
    712     assert!(!selected.selects(&other_event_id));
    713 
    714     let raw_admission = EventAdmission::raw(observed(event.clone(), 1));
    715     assert_eq!(raw_admission.stage(), AdmissionStage::Raw);
    716     assert_eq!(raw_admission.event(), &event);
    717     assert_eq!(raw_admission.event_id(), &event_id);
    718     assert_eq!(raw_admission.provenance().observed_at_unix_ms(), 1);
    719     assert!(raw_admission.verified_event().is_none());
    720     assert!(raw_admission.visible_event().is_none());
    721     let verified_admission =
    722         EventAdmission::verified(observed(event.clone(), 2), verified(&event)).expect("verified");
    723     assert!(verified_admission.verified_event().is_some());
    724     assert!(verified_admission.visible_event().is_none());
    725     let visible_admission =
    726         EventAdmission::visible(observed(event.clone(), 3), visible(&event)).expect("visible");
    727     assert!(visible_admission.verified_event().is_some());
    728     assert!(visible_admission.visible_event().is_some());
    729     assert_eq!(
    730         EventAdmission::visible(
    731             observed(signed_event_with_signature("43"), 4),
    732             visible(&event)
    733         ),
    734         Err(Error::AdmissionEventMismatch)
    735     );
    736 
    737     let receipt = AdmissionReceipt::new(
    738         event_id,
    739         position,
    740         AdmissionStage::Raw,
    741         AdmissionDisposition::Inserted,
    742     );
    743     assert_eq!(receipt.event_id(), &event_id);
    744     assert_eq!(receipt.position(), position);
    745     assert_eq!(receipt.stage(), AdmissionStage::Raw);
    746     assert_eq!(receipt.disposition(), AdmissionDisposition::Inserted);
    747     let stored_raw = StoredRawEvent::new(position, event.clone(), AdmissionStage::Raw);
    748     assert_eq!(stored_raw.position(), position);
    749     assert_eq!(stored_raw.event(), &event);
    750     assert_eq!(stored_raw.stage(), AdmissionStage::Raw);
    751     let stored_verified = StoredVerifiedEvent::new(position, event.clone());
    752     assert_eq!(stored_verified.position(), position);
    753     assert_eq!(stored_verified.event(), &event);
    754     let stored_visible = StoredVisibleEvent::new(position, event);
    755     assert_eq!(stored_visible.position(), position);
    756     assert_eq!(stored_visible.event().id(), &event_id);
    757 
    758     assert_eq!(
    759         EventPage::new(
    760             generation,
    761             vec![1, 2],
    762             None,
    763             EventQueryBounds::first(1).unwrap()
    764         ),
    765         Err(Error::EventPageLimitExceeded)
    766     );
    767     assert_eq!(
    768         EventPage::<u8>::new(
    769             generation,
    770             vec![],
    771             Some(EventPosition::new(other_generation, sequence)),
    772             EventQueryBounds::first(1).unwrap(),
    773         ),
    774         Err(Error::CursorGenerationMismatch)
    775     );
    776     let page = EventPage::new(generation, vec![1], Some(position), bounds).expect("page");
    777     assert_eq!(page.generation(), generation);
    778     assert_eq!(page.items(), &[1]);
    779     assert_eq!(page.next_cursor(), Some(position));
    780 
    781     let provenance = observed(signed_event(), 5).provenance().clone();
    782     let stored = StoredEventProvenance::new(position, provenance.clone());
    783     assert_eq!(stored.position(), position);
    784     assert_eq!(stored.provenance(), &provenance);
    785     let reconstructed = StoredEventProvenance::from_stored_parts(
    786         position,
    787         "nostr",
    788         provenance.target().as_str(),
    789         5,
    790         Some("cursor"),
    791     )
    792     .expect("stored provenance");
    793     assert_eq!(
    794         reconstructed.provenance().cursor().unwrap().as_str(),
    795         "cursor"
    796     );
    797     for (transport, target, observed_at, cursor) in [
    798         ("BAD ID", provenance.target().as_str(), 5, None),
    799         ("nostr", "bad", 5, None),
    800         ("nostr", provenance.target().as_str(), 0, None),
    801         ("nostr", provenance.target().as_str(), 5, Some(" bad")),
    802     ] {
    803         assert_eq!(
    804             StoredEventProvenance::from_stored_parts(
    805                 position,
    806                 transport,
    807                 target,
    808                 observed_at,
    809                 cursor,
    810             ),
    811             Err(Error::CorruptStoredEvent)
    812         );
    813     }
    814 }