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 (¤t, 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 }