lib

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

visibility.rs (24416B)


      1 //! Deterministic current-visibility reduction over immutable event truth.
      2 
      3 use std::collections::{BTreeMap, BTreeSet};
      4 
      5 use radroots_event::{
      6     EventId, SignedEvent,
      7     envelope::event_head::{
      8         CurrentEventHead, EventHeadCandidateResult, EventHeadCoordinate, EventHeadDecision,
      9         event_head_candidate_for_nip01_event, select_event_head,
     10     },
     11     envelope::kind::KIND_DELETION_REQUEST,
     12     id::Nip01Coordinate,
     13 };
     14 use sha2::{Digest, Sha256};
     15 
     16 use super::{
     17     AdmissionStage, EventPosition, SourceGeneration, VisibilityDigest, VisibilitySnapshot,
     18 };
     19 use crate::Error;
     20 
     21 #[doc(hidden)]
     22 pub struct VisibilityInput<'a> {
     23     position: EventPosition,
     24     event: &'a SignedEvent,
     25     stage: AdmissionStage,
     26 }
     27 
     28 impl<'a> VisibilityInput<'a> {
     29     #[doc(hidden)]
     30     pub const fn new(
     31         position: EventPosition,
     32         event: &'a SignedEvent,
     33         stage: AdmissionStage,
     34     ) -> Self {
     35         Self {
     36             position,
     37             event,
     38             stage,
     39         }
     40     }
     41 }
     42 
     43 #[doc(hidden)]
     44 pub struct VisibilityEvaluation {
     45     snapshot: VisibilitySnapshot,
     46     visible: BTreeSet<EventId>,
     47 }
     48 
     49 impl VisibilityEvaluation {
     50     #[doc(hidden)]
     51     pub fn is_visible(&self, event_id: &EventId) -> bool {
     52         self.visible.contains(event_id)
     53     }
     54 
     55     #[doc(hidden)]
     56     pub const fn snapshot(&self) -> &VisibilitySnapshot {
     57         &self.snapshot
     58     }
     59 
     60     #[doc(hidden)]
     61     pub fn into_snapshot(self) -> VisibilitySnapshot {
     62         self.snapshot
     63     }
     64 }
     65 
     66 #[derive(Clone)]
     67 struct Candidate<'a> {
     68     position: EventPosition,
     69     event: &'a SignedEvent,
     70     coordinate: Option<EventHeadCoordinate>,
     71     ephemeral: bool,
     72 }
     73 
     74 struct DeletionRequest {
     75     request_id: EventId,
     76     author: [u8; 32],
     77     created_at: u64,
     78     event_targets: BTreeSet<EventId>,
     79     address_targets: BTreeSet<Nip01Coordinate>,
     80 }
     81 
     82 /// Canonical provider metadata extracted with the reference reducer's parsing.
     83 #[doc(hidden)]
     84 #[derive(Clone, Debug, Eq, PartialEq)]
     85 pub struct VisibilityEventMetadata {
     86     pub event_id: EventId,
     87     pub author: [u8; 32],
     88     pub created_at: u64,
     89     pub stage: AdmissionStage,
     90     pub head_coordinate: Option<Vec<u8>>,
     91     pub deletion_coordinate: Option<String>,
     92     pub ephemeral: bool,
     93     pub deletion_request: bool,
     94     pub event_targets: BTreeSet<EventId>,
     95     pub address_targets: BTreeSet<String>,
     96 }
     97 
     98 impl VisibilityEventMetadata {
     99     #[doc(hidden)]
    100     pub fn from_event(event: &SignedEvent, stage: AdmissionStage) -> Result<Self, Error> {
    101         let envelope = event.envelope();
    102         let (head_coordinate, ephemeral) = if stage == AdmissionStage::Raw {
    103             (None, false)
    104         } else {
    105             match event_head_candidate_for_nip01_event(envelope) {
    106                 EventHeadCandidateResult::Candidate(candidate) => {
    107                     let mut key = Vec::new();
    108                     match candidate.coordinate {
    109                         EventHeadCoordinate::Replaceable { kind, pubkey } => {
    110                             key.push(0);
    111                             key.extend_from_slice(&kind.to_be_bytes());
    112                             key.extend_from_slice(pubkey.as_bytes());
    113                         }
    114                         EventHeadCoordinate::Addressable {
    115                             kind,
    116                             pubkey,
    117                             d_tag,
    118                         } => {
    119                             key.push(1);
    120                             key.extend_from_slice(&kind.to_be_bytes());
    121                             key.extend_from_slice(pubkey.as_bytes());
    122                             key.extend_from_slice(d_tag.as_bytes());
    123                         }
    124                     }
    125                     (Some(key), false)
    126                 }
    127                 EventHeadCandidateResult::NotHeadSelected => (None, false),
    128                 EventHeadCandidateResult::NotPersisted => (None, true),
    129                 EventHeadCandidateResult::Malformed(_) => return Err(Error::CorruptStoredEvent),
    130             }
    131         };
    132         let deletion_request =
    133             stage == AdmissionStage::Visible && envelope.kind_u32() == KIND_DELETION_REQUEST;
    134         let (event_targets, address_targets) = if deletion_request {
    135             let request = parse_deletion_request(event)?;
    136             (
    137                 request.event_targets,
    138                 request
    139                     .address_targets
    140                     .into_iter()
    141                     .map(|coordinate| coordinate.as_str().to_owned())
    142                     .collect(),
    143             )
    144         } else {
    145             (BTreeSet::new(), BTreeSet::new())
    146         };
    147         Ok(Self {
    148             event_id: *event.id(),
    149             author: *envelope.author().as_bytes(),
    150             created_at: envelope.created_at_u64(),
    151             stage,
    152             head_coordinate,
    153             deletion_coordinate: event_coordinate(envelope).map(|value| value.as_str().to_owned()),
    154             ephemeral,
    155             deletion_request,
    156             event_targets,
    157             address_targets,
    158         })
    159     }
    160 }
    161 
    162 #[doc(hidden)]
    163 pub fn evaluate_visibility<'a>(
    164     generation: SourceGeneration,
    165     inputs: impl IntoIterator<Item = VisibilityInput<'a>>,
    166 ) -> Result<VisibilityEvaluation, Error> {
    167     let mut candidates = Vec::new();
    168     let mut deletion_requests = Vec::new();
    169     let mut heads = BTreeMap::<EventHeadCoordinate, CurrentEventHead>::new();
    170 
    171     for input in inputs {
    172         if input.position.generation() != generation {
    173             return Err(Error::CorruptStoredEvent);
    174         }
    175         if input.stage == AdmissionStage::Raw {
    176             continue;
    177         }
    178         let envelope = input.event.envelope();
    179         if input.stage == AdmissionStage::Visible && envelope.kind_u32() == KIND_DELETION_REQUEST {
    180             deletion_requests.push(parse_deletion_request(input.event)?);
    181         }
    182         let (coordinate, ephemeral) = match event_head_candidate_for_nip01_event(envelope) {
    183             EventHeadCandidateResult::Candidate(candidate) => {
    184                 let coordinate = candidate.coordinate.clone();
    185                 match select_event_head(candidate, heads.get(&coordinate)) {
    186                     EventHeadDecision::Applied(head) => {
    187                         heads.insert(coordinate.clone(), head);
    188                     }
    189                     EventHeadDecision::SkippedDuplicate
    190                     | EventHeadDecision::SkippedOlder
    191                     | EventHeadDecision::SkippedSameTimestampHigherEventId => {}
    192                     EventHeadDecision::CoordinateMismatch => {
    193                         return Err(Error::CorruptStoredEvent);
    194                     }
    195                 }
    196                 (Some(coordinate), false)
    197             }
    198             EventHeadCandidateResult::NotHeadSelected => (None, false),
    199             EventHeadCandidateResult::NotPersisted => (None, true),
    200             EventHeadCandidateResult::Malformed(_) => return Err(Error::CorruptStoredEvent),
    201         };
    202         if input.stage != AdmissionStage::Visible {
    203             continue;
    204         }
    205         candidates.push(Candidate {
    206             position: input.position,
    207             event: input.event,
    208             coordinate,
    209             ephemeral,
    210         });
    211     }
    212 
    213     candidates.sort_by_key(|candidate| candidate.position.sequence());
    214     deletion_requests.sort_by_key(|request| request.request_id);
    215 
    216     let mut visible = BTreeSet::new();
    217     let mut suppressed = BTreeSet::new();
    218     let mut superseded = BTreeSet::new();
    219     for candidate in candidates {
    220         let event_id = *candidate.event.id();
    221         if candidate.ephemeral {
    222             suppressed.insert(event_id);
    223             continue;
    224         }
    225         if candidate.coordinate.as_ref().is_some_and(|coordinate| {
    226             heads
    227                 .get(coordinate)
    228                 .is_none_or(|head| head.event_id != event_id)
    229         }) {
    230             superseded.insert(event_id);
    231             continue;
    232         }
    233         if is_suppressed(candidate.event, &deletion_requests) {
    234             suppressed.insert(event_id);
    235         } else {
    236             visible.insert(event_id);
    237         }
    238     }
    239 
    240     let current_heads = heads.into_values().collect::<Vec<_>>();
    241     let deletion_request_ids = deletion_requests
    242         .iter()
    243         .map(|request| request.request_id)
    244         .collect::<Vec<_>>();
    245     let visible_event_ids = visible.iter().copied().collect::<Vec<_>>();
    246     let suppressed_event_ids = suppressed.into_iter().collect::<Vec<_>>();
    247     let superseded_event_ids = superseded.into_iter().collect::<Vec<_>>();
    248     let digest = visibility_digest(
    249         generation,
    250         current_heads.as_slice(),
    251         deletion_request_ids.as_slice(),
    252         visible_event_ids.as_slice(),
    253         suppressed_event_ids.as_slice(),
    254         superseded_event_ids.as_slice(),
    255     )?;
    256     Ok(VisibilityEvaluation {
    257         snapshot: VisibilitySnapshot::new(
    258             generation,
    259             current_heads,
    260             deletion_request_ids,
    261             visible_event_ids,
    262             suppressed_event_ids,
    263             superseded_event_ids,
    264             digest,
    265         ),
    266         visible,
    267     })
    268 }
    269 
    270 fn parse_deletion_request(event: &SignedEvent) -> Result<DeletionRequest, Error> {
    271     let mut event_targets = BTreeSet::new();
    272     let mut address_targets = BTreeSet::new();
    273     for tag in event.envelope().tag_slices() {
    274         match tag.as_slice().first().map(String::as_str) {
    275             Some("e") => {
    276                 let value = tag.as_slice().get(1).ok_or(Error::CorruptStoredEvent)?;
    277                 event_targets.insert(EventId::parse(value).map_err(|_| Error::CorruptStoredEvent)?);
    278             }
    279             Some("a") => {
    280                 let value = tag.as_slice().get(1).ok_or(Error::CorruptStoredEvent)?;
    281                 address_targets
    282                     .insert(Nip01Coordinate::parse(value).map_err(|_| Error::CorruptStoredEvent)?);
    283             }
    284             _ => {}
    285         }
    286     }
    287     if event_targets.is_empty() && address_targets.is_empty() {
    288         return Err(Error::CorruptStoredEvent);
    289     }
    290     Ok(DeletionRequest {
    291         request_id: *event.id(),
    292         author: *event.envelope().author().as_bytes(),
    293         created_at: event.envelope().created_at_u64(),
    294         event_targets,
    295         address_targets,
    296     })
    297 }
    298 
    299 fn is_suppressed(target: &SignedEvent, requests: &[DeletionRequest]) -> bool {
    300     let target_event = target.envelope();
    301     if target_event.kind_u32() == KIND_DELETION_REQUEST {
    302         return false;
    303     }
    304     let coordinate = event_coordinate(target_event);
    305     requests.iter().any(|request| {
    306         let request_event_id_match = request.event_targets.contains(target_event.id());
    307         let request_coordinate_match = coordinate.as_ref().is_some_and(|coordinate| {
    308             request.address_targets.contains(coordinate)
    309                 && target_event.created_at_u64() <= request.created_at
    310         });
    311         (request_event_id_match || request_coordinate_match)
    312             && request.author == *target_event.author().as_bytes()
    313     })
    314 }
    315 
    316 fn event_coordinate(event: &radroots_event::Event) -> Option<Nip01Coordinate> {
    317     let kind = event.kind_u32();
    318     let identifier = match event.kind_class() {
    319         radroots_event::envelope::EventKindClass::Replaceable => "",
    320         radroots_event::envelope::EventKindClass::Addressable => event
    321             .tag_slices()
    322             .iter()
    323             .find(|tag| tag.as_slice().first().is_some_and(|name| name == "d"))?
    324             .as_slice()
    325             .get(1)?
    326             .as_str(),
    327         radroots_event::envelope::EventKindClass::Regular
    328         | radroots_event::envelope::EventKindClass::Ephemeral => return None,
    329     };
    330     Nip01Coordinate::parse(format!("{kind}:{}:{identifier}", event.author())).ok()
    331 }
    332 
    333 fn visibility_digest(
    334     generation: SourceGeneration,
    335     heads: &[CurrentEventHead],
    336     deletion_requests: &[EventId],
    337     visible: &[EventId],
    338     suppressed: &[EventId],
    339     superseded: &[EventId],
    340 ) -> Result<VisibilityDigest, Error> {
    341     let mut digest = Sha256::new();
    342     digest.update(b"radroots.storage.visibility.v1\0");
    343     digest.update(generation.as_bytes());
    344     for head in heads {
    345         digest.update(b"head\0");
    346         match &head.coordinate {
    347             EventHeadCoordinate::Replaceable { kind, pubkey } => {
    348                 digest.update(b"replaceable\0");
    349                 digest.update(kind.to_be_bytes());
    350                 digest.update(pubkey.as_bytes());
    351             }
    352             EventHeadCoordinate::Addressable {
    353                 kind,
    354                 pubkey,
    355                 d_tag,
    356             } => {
    357                 digest.update(b"addressable\0");
    358                 digest.update(kind.to_be_bytes());
    359                 digest.update(pubkey.as_bytes());
    360                 let d_tag_length =
    361                     u64::try_from(d_tag.len()).map_err(|_| Error::CorruptStoredEvent)?;
    362                 digest.update(d_tag_length.to_be_bytes());
    363                 digest.update(d_tag.as_bytes());
    364             }
    365         }
    366         digest.update(head.event_id.as_bytes());
    367         digest.update(head.created_at.to_be_bytes());
    368     }
    369     update_event_ids(&mut digest, b"deletion\0", deletion_requests);
    370     update_event_ids(&mut digest, b"visible\0", visible);
    371     update_event_ids(&mut digest, b"suppressed\0", suppressed);
    372     update_event_ids(&mut digest, b"superseded\0", superseded);
    373     Ok(VisibilityDigest::new(digest.finalize().into()))
    374 }
    375 
    376 fn update_event_ids(digest: &mut Sha256, prefix: &[u8], event_ids: &[EventId]) {
    377     for event_id in event_ids {
    378         digest.update(prefix);
    379         digest.update(event_id.as_bytes());
    380     }
    381 }
    382 
    383 #[cfg(test)]
    384 mod tests {
    385     use super::*;
    386     use radroots_event::wire::Nip01EventWire;
    387 
    388     const AUTHOR: &str = "585591529da0bab31b3b1b1f986611cf5f435dca84f978c89ee8a40cca7103df";
    389     const OTHER_AUTHOR: &str = "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798";
    390 
    391     fn signed_event(
    392         author: &str,
    393         created_at: u64,
    394         kind: u32,
    395         tags: Vec<Vec<&str>>,
    396         content: &str,
    397     ) -> SignedEvent {
    398         let tags = tags
    399             .into_iter()
    400             .map(|tag| tag.into_iter().map(str::to_owned).collect::<Vec<_>>())
    401             .collect::<Vec<_>>();
    402         let mut wire = Nip01EventWire {
    403             id: "0".repeat(64),
    404             pubkey: author.to_owned(),
    405             created_at,
    406             kind,
    407             tags,
    408             content: content.to_owned(),
    409             sig: "42".repeat(64),
    410             extra: Default::default(),
    411         };
    412         wire.id = wire.computed_event_id().expect("event id").to_hex();
    413         let raw_json = serde_json::json!({
    414             "id": &wire.id,
    415             "pubkey": &wire.pubkey,
    416             "created_at": wire.created_at,
    417             "kind": wire.kind,
    418             "tags": &wire.tags,
    419             "content": &wire.content,
    420             "sig": &wire.sig,
    421         })
    422         .to_string();
    423         SignedEvent::from_wire_verified_id(wire, raw_json).expect("signed event")
    424     }
    425 
    426     fn evaluate<'a>(
    427         events: impl IntoIterator<Item = (&'a SignedEvent, AdmissionStage)>,
    428     ) -> VisibilityEvaluation {
    429         let generation = SourceGeneration::new([7; 32]).expect("generation");
    430         evaluate_visibility(
    431             generation,
    432             events
    433                 .into_iter()
    434                 .enumerate()
    435                 .map(|(index, (event, stage))| {
    436                     let sequence = u64::try_from(index)
    437                         .expect("index")
    438                         .checked_add(1)
    439                         .and_then(|value| super::super::EventSequence::new(value).ok())
    440                         .expect("sequence");
    441                     VisibilityInput::new(EventPosition::new(generation, sequence), event, stage)
    442                 }),
    443         )
    444         .expect("visibility")
    445     }
    446 
    447     #[test]
    448     fn verified_head_supersedes_visible_payload_without_becoming_visible() {
    449         for (kind, tags) in [(0, vec![]), (30_023, vec![vec!["d", "same"]])] {
    450             let old = signed_event(AUTHOR, 10, kind, tags.clone(), r#"{"name":"old"}"#);
    451             let invalid = signed_event(AUTHOR, 20, kind, tags, "malformed payload");
    452             let before = evaluate([
    453                 (&old, AdmissionStage::Visible),
    454                 (&invalid, AdmissionStage::Raw),
    455             ]);
    456             assert!(before.is_visible(old.id()));
    457             let after = evaluate([
    458                 (&old, AdmissionStage::Visible),
    459                 (&invalid, AdmissionStage::Verified),
    460             ]);
    461             assert!(!after.is_visible(old.id()));
    462             assert!(!after.is_visible(invalid.id()));
    463             assert_eq!(after.snapshot().current_heads()[0].event_id, *invalid.id());
    464             assert_eq!(after.snapshot().superseded_event_ids(), &[*old.id()]);
    465             assert_ne!(before.snapshot().digest(), after.snapshot().digest());
    466             let reverse = evaluate([
    467                 (&invalid, AdmissionStage::Verified),
    468                 (&old, AdmissionStage::Visible),
    469             ]);
    470             assert_eq!(after.snapshot(), reverse.snapshot());
    471         }
    472     }
    473 
    474     #[test]
    475     fn verified_heads_keep_canonical_ties_and_empty_address_coordinates() {
    476         let a = signed_event(AUTHOR, 10, 30_023, vec![], "a");
    477         let b = signed_event(AUTHOR, 10, 30_023, vec![vec!["d", ""]], "b");
    478         let (winner, loser) = if a.id() < b.id() { (&a, &b) } else { (&b, &a) };
    479         let result = evaluate([
    480             (loser, AdmissionStage::Visible),
    481             (winner, AdmissionStage::Verified),
    482         ]);
    483         assert_eq!(result.snapshot().current_heads().len(), 1);
    484         assert_eq!(result.snapshot().current_heads()[0].event_id, *winner.id());
    485         assert!(result.snapshot().visible_event_ids().is_empty());
    486         let reverse = evaluate([
    487             (winner, AdmissionStage::Verified),
    488             (loser, AdmissionStage::Visible),
    489         ]);
    490         assert_eq!(result.snapshot(), reverse.snapshot());
    491         let visible_winner = evaluate([
    492             (winner, AdmissionStage::Visible),
    493             (loser, AdmissionStage::Verified),
    494         ]);
    495         assert!(visible_winner.is_visible(winner.id()));
    496         assert!(!visible_winner.is_visible(loser.id()));
    497     }
    498 
    499     #[test]
    500     fn verified_deletion_has_no_authority_and_valid_deletion_precedes_target() {
    501         let target = signed_event(AUTHOR, 10, 0, vec![], "profile");
    502         let deletion = signed_event(
    503             AUTHOR,
    504             20,
    505             5,
    506             vec![vec!["e", target.id().to_hex().as_str()]],
    507             "",
    508         );
    509         let forged = signed_event(
    510             OTHER_AUTHOR,
    511             20,
    512             5,
    513             vec![vec!["e", target.id().to_hex().as_str()]],
    514             "",
    515         );
    516         let malformed = signed_event(AUTHOR, 30, 5, vec![], "");
    517         for stage in [AdmissionStage::Raw, AdmissionStage::Verified] {
    518             let result = evaluate([
    519                 (&deletion, stage),
    520                 (&malformed, stage),
    521                 (&forged, AdmissionStage::Visible),
    522                 (&target, AdmissionStage::Visible),
    523             ]);
    524             assert!(result.is_visible(target.id()));
    525             assert_eq!(result.snapshot().deletion_request_ids(), &[*forged.id()]);
    526         }
    527         let result = evaluate([
    528             (&deletion, AdmissionStage::Visible),
    529             (&target, AdmissionStage::Visible),
    530         ]);
    531         assert!(!result.is_visible(target.id()));
    532         assert_eq!(result.snapshot().suppressed_event_ids(), &[*target.id()]);
    533     }
    534 
    535     #[test]
    536     fn selected_head_is_stable_and_a_deleted_head_does_not_resurrect() {
    537         let old = signed_event(AUTHOR, 10, 0, vec![], r#"{"name":"old"}"#);
    538         let current = signed_event(AUTHOR, 20, 0, vec![], r#"{"name":"current"}"#);
    539         let deletion = signed_event(
    540             AUTHOR,
    541             30,
    542             KIND_DELETION_REQUEST,
    543             vec![vec!["e", current.id().to_hex().as_str()]],
    544             "",
    545         );
    546         let evaluation = evaluate([
    547             (&old, AdmissionStage::Visible),
    548             (&current, AdmissionStage::Visible),
    549             (&deletion, AdmissionStage::Visible),
    550         ]);
    551 
    552         assert!(!evaluation.is_visible(old.id()));
    553         assert!(!evaluation.is_visible(current.id()));
    554         assert!(evaluation.is_visible(deletion.id()));
    555         assert_eq!(evaluation.snapshot().superseded_event_ids(), &[*old.id()]);
    556         assert_eq!(
    557             evaluation.snapshot().suppressed_event_ids(),
    558             &[*current.id()]
    559         );
    560         assert_eq!(
    561             evaluation.snapshot().current_heads()[0].event_id,
    562             *current.id()
    563         );
    564     }
    565 
    566     #[test]
    567     fn address_cutoff_allows_a_later_replacement_and_wrong_author_is_ineffective() {
    568         let old = signed_event(AUTHOR, 10, 30_023, vec![vec!["d", "farm-update"]], "old");
    569         let wrong_author_deletion = signed_event(
    570             OTHER_AUTHOR,
    571             15,
    572             KIND_DELETION_REQUEST,
    573             vec![vec!["a", format!("30023:{AUTHOR}:farm-update").as_str()]],
    574             "",
    575         );
    576         let cutoff = signed_event(
    577             AUTHOR,
    578             20,
    579             KIND_DELETION_REQUEST,
    580             vec![vec!["a", format!("30023:{AUTHOR}:farm-update").as_str()]],
    581             "",
    582         );
    583         let later = signed_event(AUTHOR, 30, 30_023, vec![vec!["d", "farm-update"]], "later");
    584         let evaluation = evaluate([
    585             (&old, AdmissionStage::Visible),
    586             (&wrong_author_deletion, AdmissionStage::Visible),
    587             (&cutoff, AdmissionStage::Visible),
    588             (&later, AdmissionStage::Visible),
    589         ]);
    590 
    591         assert!(evaluation.is_visible(later.id()));
    592         assert!(evaluation.is_visible(wrong_author_deletion.id()));
    593         assert!(evaluation.is_visible(cutoff.id()));
    594         assert!(!evaluation.is_visible(old.id()));
    595         assert_eq!(
    596             evaluation.snapshot().current_heads()[0].event_id,
    597             *later.id()
    598         );
    599     }
    600 
    601     #[test]
    602     fn rebuild_is_order_independent_and_ignores_nonvisible_admissions() {
    603         let visible = signed_event(AUTHOR, 10, 1, vec![], "visible");
    604         let excluded = signed_event(AUTHOR, 20, 1, vec![], "excluded");
    605         let ephemeral = signed_event(AUTHOR, 30, 20_000, vec![], "ephemeral");
    606         let first = evaluate([
    607             (&visible, AdmissionStage::Visible),
    608             (&excluded, AdmissionStage::Verified),
    609             (&ephemeral, AdmissionStage::Visible),
    610         ]);
    611         let second = evaluate([
    612             (&ephemeral, AdmissionStage::Visible),
    613             (&excluded, AdmissionStage::Verified),
    614             (&visible, AdmissionStage::Visible),
    615         ]);
    616 
    617         assert!(first.is_visible(visible.id()));
    618         assert!(!first.is_visible(excluded.id()));
    619         assert!(!first.is_visible(ephemeral.id()));
    620         assert_eq!(first.snapshot().digest(), second.snapshot().digest());
    621         assert_eq!(first.snapshot(), second.snapshot());
    622     }
    623 
    624     #[test]
    625     fn deletion_requests_without_targets_fail_closed() {
    626         let deletion = signed_event(AUTHOR, 10, KIND_DELETION_REQUEST, vec![], "");
    627         let generation = SourceGeneration::new([7; 32]).expect("generation");
    628         let position = EventPosition::new(
    629             generation,
    630             super::super::EventSequence::new(1).expect("sequence"),
    631         );
    632 
    633         let error = evaluate_visibility(
    634             generation,
    635             [VisibilityInput::new(
    636                 position,
    637                 &deletion,
    638                 AdmissionStage::Visible,
    639             )],
    640         )
    641         .err()
    642         .expect("targetless deletion must fail");
    643 
    644         assert_eq!(error, Error::CorruptStoredEvent);
    645     }
    646 
    647     #[test]
    648     fn events_from_another_generation_fail_closed() {
    649         let event = signed_event(AUTHOR, 10, 1, vec![], "event");
    650         let requested_generation = SourceGeneration::new([7; 32]).expect("generation");
    651         let stored_generation = SourceGeneration::new([8; 32]).expect("generation");
    652         let position = EventPosition::new(
    653             stored_generation,
    654             super::super::EventSequence::new(1).expect("sequence"),
    655         );
    656 
    657         let error = evaluate_visibility(
    658             requested_generation,
    659             [VisibilityInput::new(
    660                 position,
    661                 &event,
    662                 AdmissionStage::Visible,
    663             )],
    664         )
    665         .err()
    666         .expect("cross-generation visibility input must fail");
    667 
    668         assert_eq!(error, Error::CorruptStoredEvent);
    669     }
    670 }