1use serde::{Deserialize, Serialize};
11use std::collections::{BTreeSet, HashMap};
12
13#[derive(Debug, Clone, Hash, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize)]
14pub struct Place {
15 pub id: String,
16}
17
18impl Place {
19 pub fn new(id: impl Into<String>) -> Self {
20 Self { id: id.into() }
21 }
22}
23
24#[derive(Debug, Clone, Default, Eq, PartialEq, Serialize, Deserialize)]
25#[serde(transparent)]
29pub struct Marking {
30 pub tokens: HashMap<String, Vec<String>>,
32}
33
34impl Marking {
35 pub fn new() -> Self {
36 Self::default()
37 }
38
39 pub fn with_token(mut self, color: &str, hash: &str) -> Self {
40 self.tokens
41 .entry(color.to_string())
42 .or_default()
43 .push(hash.to_string());
44 self
45 }
46
47 pub fn restrict(&self, colors: &BTreeSet<String>) -> Self {
49 let mut tokens = HashMap::new();
50 for color in colors {
51 if let Some(vals) = self.tokens.get(color) {
52 tokens.insert(color.clone(), vals.clone());
53 }
54 }
55 Self { tokens }
56 }
57}
58
59#[derive(Debug, Clone, Default, Eq, PartialEq, Hash, Serialize, Deserialize)]
60pub struct OpenSet {
61 pub places: BTreeSet<Place>,
62}
63
64impl OpenSet {
65 pub fn new() -> Self {
66 Self::default()
67 }
68
69 pub fn from_places<I: IntoIterator<Item = Place>>(places: I) -> Self {
70 Self {
71 places: places.into_iter().collect(),
72 }
73 }
74
75 pub fn intersection(&self, other: &OpenSet) -> OpenSet {
76 OpenSet {
77 places: self
78 .places
79 .intersection(&other.places)
80 .cloned()
81 .collect(),
82 }
83 }
84
85 pub fn is_disjoint(&self, other: &OpenSet) -> bool {
86 self.places.is_disjoint(&other.places)
87 }
88
89 pub fn is_subset(&self, other: &OpenSet) -> bool {
90 self.places.is_subset(&other.places)
91 }
92
93 pub fn is_empty(&self) -> bool {
94 self.places.is_empty()
95 }
96
97 pub fn colors(&self) -> BTreeSet<String> {
98 self.places.iter().map(|p| p.id.clone()).collect()
100 }
101}
102
103#[derive(Debug, Clone, Serialize, Deserialize)]
104pub struct Section {
105 pub open_set: OpenSet,
106 pub marking: Marking,
107}
108
109impl Section {
110 pub fn new(open_set: OpenSet, marking: Marking) -> Self {
111 Self { open_set, marking }
112 }
113
114 pub fn restrict(&self, subset: &OpenSet) -> Result<Section, CohomologyError> {
116 if !subset.is_subset(&self.open_set) {
117 return Err(CohomologyError::InvalidRestriction {
118 subset: subset.clone(),
119 superset: self.open_set.clone(),
120 });
121 }
122 let colors = subset.colors();
123 let marking = self.marking.restrict(&colors);
124 Ok(Section {
125 open_set: subset.clone(),
126 marking,
127 })
128 }
129}
130
131#[derive(Debug, Clone, Serialize, Deserialize)]
132pub struct Sheaf {
133 pub sections: HashMap<OpenSet, Section>,
134}
135
136impl Default for Sheaf {
137 fn default() -> Self {
138 Self::new()
139 }
140}
141
142impl Sheaf {
143 pub fn new() -> Self {
144 Self {
145 sections: HashMap::new(),
146 }
147 }
148
149 pub fn restriction(&self, section: &Section, subset: &OpenSet) -> Result<Section, CohomologyError> {
151 section.restrict(subset)
152 }
153
154 pub fn gluing_check(
161 &self,
162 local_sections: &[Section],
163 open_cover: &[OpenSet],
164 ) -> Result<Section, CohomologyError> {
165 if local_sections.len() != open_cover.len() {
166 return Err(CohomologyError::InputMismatch);
167 }
168 if local_sections.is_empty() {
169 return Ok(Section::new(OpenSet::new(), Marking::new()));
170 }
171
172 let merkle_trees: Vec<MerkleNode> =
174 local_sections.iter().map(section_to_merkle).collect();
175
176 let n = local_sections.len();
177 for i in 0..n {
178 for j in (i + 1)..n {
179 let intersection = open_cover[i].intersection(&open_cover[j]);
180 if intersection.is_empty() {
181 continue;
182 }
183 let root_i = merkle_sub_root(&merkle_trees[i], &intersection.places);
185 let root_j = merkle_sub_root(&merkle_trees[j], &intersection.places);
186 if root_i != root_j {
187 let left = self.restriction(&local_sections[i], &intersection)?;
191 let right = self.restriction(&local_sections[j], &intersection)?;
192 return Err(CohomologyError::GluingFailure {
193 place_i: local_sections[i].open_set.places.iter().next().cloned().unwrap_or(Place::new("?")),
194 place_j: local_sections[j].open_set.places.iter().next().cloned().unwrap_or(Place::new("?")),
195 intersection: intersection.clone(),
196 expected_marking: left.marking,
197 actual_marking: right.marking,
198 cohomology_class: "[delta_s]".to_string(),
199 });
200 }
201 }
202 }
203
204 let mut union = OpenSet::new();
205 let mut marking = Marking::new();
206 for (section, cover) in local_sections.iter().zip(open_cover.iter()) {
207 union.places.extend(cover.places.iter().cloned());
208 for (color, vals) in §ion.marking.tokens {
210 marking.tokens.insert(color.clone(), vals.clone());
211 }
212 }
213 Ok(Section::new(union, marking))
214 }
215}
216
217#[derive(Debug, Clone, Serialize, Deserialize)]
218pub enum CohomologyError {
219 InputMismatch,
220 InvalidRestriction { subset: OpenSet, superset: OpenSet },
221 GluingFailure {
222 place_i: Place,
223 place_j: Place,
224 intersection: OpenSet,
225 expected_marking: Marking,
226 actual_marking: Marking,
227 cohomology_class: String,
228 },
229}
230
231impl std::fmt::Display for CohomologyError {
232 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
233 match self {
234 CohomologyError::InputMismatch => write!(f, "open cover and local sections have different lengths"),
235 CohomologyError::InvalidRestriction { subset, superset } => {
236 write!(f, "cannot restrict {:?} to subset {:?}", superset, subset)
237 }
238 CohomologyError::GluingFailure { place_i, place_j, intersection, .. } => {
239 write!(
240 f,
241 "COHOMOLOGICAL OBSTRUCTION: Sections disagree on intersection of {:?} and {:?}: {:?}",
242 place_i.id, place_j.id, intersection
243 )
244 }
245 }
246 }
247}
248
249impl std::error::Error for CohomologyError {}
250
251#[derive(Debug, Clone, Serialize, Deserialize)]
257pub struct MerkleNode {
258 pub hash: [u8; 32],
259 pub children: Vec<MerkleNode>,
260 pub place_id: Option<String>,
261 pub payload: Option<Vec<u8>>,
262}
263
264pub fn compute_merkle_root(payload: &[u8]) -> [u8; 32] {
266 crate::hash::raw_hash_bytes_32(payload)
267}
268
269pub fn compute_merkle_node(children: &[MerkleNode]) -> [u8; 32] {
272 let mut combined = Vec::new();
273 for child in children {
274 combined.extend_from_slice(&child.hash);
275 }
276 crate::hash::raw_hash_bytes_32(&combined)
277}
278
279pub fn section_to_merkle(section: &Section) -> MerkleNode {
283 let mut leaves: Vec<MerkleNode> = section
284 .open_set
285 .places
286 .iter()
287 .map(|place| {
288 let tokens = section.marking.tokens.get(&place.id);
289 let payload = match tokens {
290 Some(vals) => format!("{}:{}", place.id, vals.join(",")),
291 None => place.id.clone(),
292 };
293 let hash = compute_merkle_root(payload.as_bytes());
294 MerkleNode {
295 hash,
296 children: vec![],
297 place_id: Some(place.id.clone()),
298 payload: Some(payload.into_bytes()),
299 }
300 })
301 .collect();
302 leaves.sort_by(|a, b| a.place_id.cmp(&b.place_id));
303 let root_hash = compute_merkle_node(&leaves);
304 MerkleNode {
305 hash: root_hash,
306 children: leaves,
307 place_id: None,
308 payload: None,
309 }
310}
311
312pub fn merkle_sub_root(node: &MerkleNode, places: &BTreeSet<Place>) -> [u8; 32] {
316 let place_ids: BTreeSet<String> = places.iter().map(|p| p.id.clone()).collect();
317 let matching: Vec<&MerkleNode> = node
318 .children
319 .iter()
320 .filter(|c| {
321 c.place_id
322 .as_ref()
323 .map(|id| place_ids.contains(id))
324 .unwrap_or(false)
325 })
326 .collect();
327 if matching.is_empty() {
328 return [0u8; 32];
329 }
330 let mut combined = Vec::new();
331 for child in &matching {
332 combined.extend_from_slice(&child.hash);
333 }
334 crate::hash::raw_hash_bytes_32(&combined)
335}
336
337#[cfg(feature = "native")]
339pub fn store_section_merkle(
340 section: &Section,
341 conn: &rusqlite::Connection,
342) -> Result<[u8; 32], String> {
343 let node = section_to_merkle(section);
344 let yaml = serde_yaml::to_string(section).map_err(|e| e.to_string())?;
345 let hash_hex = hex::encode(node.hash);
346 let now = chrono::Local::now()
347 .format("%Y-%m-%dT%H:%M:%S%z")
348 .to_string();
349 conn.execute(
350 "INSERT OR IGNORE INTO card (hash, content, g_time) VALUES (?, ?, ?)",
351 rusqlite::params![hash_hex, yaml, now],
352 )
353 .map_err(|e| e.to_string())?;
354 Ok(node.hash)
355}
356
357#[cfg(feature = "native")]
359pub fn load_section_merkle(
360 hash: &[u8; 32],
361 conn: &rusqlite::Connection,
362) -> Result<Section, String> {
363 let hash_hex = hex::encode(hash);
364 let content: String = conn
365 .query_row(
366 "SELECT content FROM card WHERE hash = ?",
367 [&hash_hex],
368 |row| row.get(0),
369 )
370 .map_err(|e| format!("Failed to load section: {}", e))?;
371 serde_yaml::from_str(&content).map_err(|e| format!("Failed to deserialize section: {}", e))
372}
373
374#[derive(Debug, Clone, Serialize, Deserialize)]
381pub struct CohomologyConflictReport {
382 pub conflicting_places: (Place, Place),
383 pub intersection: OpenSet,
384 pub expected_marking: Marking,
385 pub actual_marking: Marking,
386 pub cohomology_class: String,
387 pub timestamp: String,
388 pub agent_dids: Vec<String>,
389}
390
391impl CohomologyConflictReport {
392 pub fn to_yaml(&self) -> String {
394 serde_yaml::to_string(self).unwrap_or_else(|_| "cohomology_conflict: <error>".to_string())
395 }
396
397 pub fn content_hash(&self) -> String {
399 crate::hash::raw_hash_string(&self.to_yaml())
400 }
401
402 pub fn from_error(
404 err: &CohomologyError,
405 agent_dids: Vec<String>,
406 ) -> Option<Self> {
407 match err {
408 CohomologyError::GluingFailure {
409 place_i,
410 place_j,
411 intersection,
412 expected_marking,
413 actual_marking,
414 cohomology_class,
415 } => Some(CohomologyConflictReport {
416 conflicting_places: (place_i.clone(), place_j.clone()),
417 intersection: intersection.clone(),
418 expected_marking: expected_marking.clone(),
419 actual_marking: actual_marking.clone(),
420 cohomology_class: cohomology_class.clone(),
421 timestamp: chrono::Utc::now().to_rfc3339(),
422 agent_dids,
423 }),
424 _ => None,
425 }
426 }
427}
428
429#[cfg(feature = "native")]
431pub fn store_conflict_report(
432 report: &CohomologyConflictReport,
433 conn: &rusqlite::Connection,
434) -> Result<String, String> {
435 let yaml = report.to_yaml();
436 let hash = report.content_hash();
437 let now = chrono::Local::now()
438 .format("%Y-%m-%dT%H:%M:%S%z")
439 .to_string();
440 conn.execute(
441 "INSERT OR IGNORE INTO card (hash, content, g_time) VALUES (?, ?, ?)",
442 rusqlite::params![hash, yaml, now],
443 )
444 .map_err(|e| e.to_string())?;
445 Ok(hash)
446}
447
448#[cfg(test)]
449mod tests {
450 use super::*;
451
452 #[cfg_attr(not(target_arch = "wasm32"), test)]
453 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
454 fn test_disjoint_places_glue() {
455 let sheaf = Sheaf::new();
456 let s1 = Section::new(
457 OpenSet::from_places([Place::new("a")]),
458 Marking::new().with_token("a", "hash-a"),
459 );
460 let s2 = Section::new(
461 OpenSet::from_places([Place::new("b")]),
462 Marking::new().with_token("b", "hash-b"),
463 );
464 let global = sheaf.gluing_check(&[s1, s2], &[OpenSet::from_places([Place::new("a")]), OpenSet::from_places([Place::new("b")])]).unwrap();
465 assert_eq!(global.open_set.places.len(), 2);
466 }
467
468 #[cfg_attr(not(target_arch = "wasm32"), test)]
469 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
470 fn test_overlapping_matching_restrictions_glue() {
471 let sheaf = Sheaf::new();
472 let _shared = OpenSet::from_places([Place::new("shared")]);
473 let s1 = Section::new(
474 OpenSet::from_places([Place::new("shared"), Place::new("a")]),
475 Marking::new().with_token("shared", "hash-s").with_token("a", "hash-a"),
476 );
477 let s2 = Section::new(
478 OpenSet::from_places([Place::new("shared"), Place::new("b")]),
479 Marking::new().with_token("shared", "hash-s").with_token("b", "hash-b"),
480 );
481 let global = sheaf.gluing_check(&[s1, s2], &[OpenSet::from_places([Place::new("shared"), Place::new("a")]), OpenSet::from_places([Place::new("shared"), Place::new("b")])]).unwrap();
482 assert!(global.open_set.places.contains(&Place::new("shared")));
483 }
484
485 #[cfg_attr(not(target_arch = "wasm32"), test)]
486 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
487 fn test_overlapping_mismatched_restrictions_fail() {
488 let sheaf = Sheaf::new();
489 let s1 = Section::new(
490 OpenSet::from_places([Place::new("shared"), Place::new("a")]),
491 Marking::new().with_token("shared", "hash-s1"),
492 );
493 let s2 = Section::new(
494 OpenSet::from_places([Place::new("shared"), Place::new("b")]),
495 Marking::new().with_token("shared", "hash-s2"),
496 );
497 let result = sheaf.gluing_check(&[s1, s2], &[OpenSet::from_places([Place::new("shared"), Place::new("a")]), OpenSet::from_places([Place::new("shared"), Place::new("b")])]);
498 assert!(result.is_err());
499 let err = result.unwrap_err();
500 assert!(err.to_string().contains("COHOMOLOGICAL OBSTRUCTION"));
501 }
502
503 #[cfg_attr(not(target_arch = "wasm32"), test)]
504 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
505 fn test_three_section_cover_glue() {
506 let sheaf = Sheaf::new();
507 let cover = [
508 OpenSet::from_places([Place::new("a"), Place::new("b")]),
509 OpenSet::from_places([Place::new("b"), Place::new("c")]),
510 OpenSet::from_places([Place::new("c"), Place::new("d")]),
511 ];
512 let s1 = Section::new(cover[0].clone(), Marking::new().with_token("a", "h").with_token("b", "h"));
513 let s2 = Section::new(cover[1].clone(), Marking::new().with_token("b", "h").with_token("c", "h"));
514 let s3 = Section::new(cover[2].clone(), Marking::new().with_token("c", "h").with_token("d", "h"));
515 let global = sheaf.gluing_check(&[s1, s2, s3], &cover).unwrap();
516 assert_eq!(global.open_set.places.len(), 4);
517 }
518
519 #[cfg_attr(not(target_arch = "wasm32"), test)]
520 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
521 fn test_three_sections_one_conflict() {
522 let sheaf = Sheaf::new();
523 let cover = [
524 OpenSet::from_places([Place::new("a"), Place::new("b")]),
525 OpenSet::from_places([Place::new("b"), Place::new("c")]),
526 OpenSet::from_places([Place::new("c"), Place::new("d")]),
527 ];
528 let s1 = Section::new(cover[0].clone(), Marking::new().with_token("a", "h").with_token("b", "h1"));
529 let s2 = Section::new(cover[1].clone(), Marking::new().with_token("b", "h2").with_token("c", "h"));
530 let s3 = Section::new(cover[2].clone(), Marking::new().with_token("c", "h").with_token("d", "h"));
531 let result = sheaf.gluing_check(&[s1, s2, s3], &cover);
532 assert!(result.is_err());
533 }
534
535 #[cfg_attr(not(target_arch = "wasm32"), test)]
536 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
537 fn test_open_set_operations() {
538 let a = OpenSet::from_places([Place::new("x"), Place::new("y")]);
539 let b = OpenSet::from_places([Place::new("y"), Place::new("z")]);
540 assert!(!a.is_disjoint(&b));
541 let inter = a.intersection(&b);
542 assert_eq!(inter.places, [Place::new("y")].iter().cloned().collect());
543 assert!(OpenSet::from_places([Place::new("y")]).is_subset(&a));
544 }
545
546 #[cfg_attr(not(target_arch = "wasm32"), test)]
549 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
550 fn test_identical_sections_produce_identical_merkle_roots() {
551 let s1 = Section::new(
552 OpenSet::from_places([Place::new("a"), Place::new("b")]),
553 Marking::new().with_token("a", "h1").with_token("b", "h2"),
554 );
555 let s2 = Section::new(
556 OpenSet::from_places([Place::new("a"), Place::new("b")]),
557 Marking::new().with_token("a", "h1").with_token("b", "h2"),
558 );
559 let m1 = section_to_merkle(&s1);
560 let m2 = section_to_merkle(&s2);
561 assert_eq!(m1.hash, m2.hash);
562 }
563
564 #[cfg_attr(not(target_arch = "wasm32"), test)]
565 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
566 fn test_different_sections_produce_different_merkle_roots() {
567 let s1 = Section::new(
568 OpenSet::from_places([Place::new("a"), Place::new("b")]),
569 Marking::new().with_token("a", "h1").with_token("b", "h2"),
570 );
571 let s2 = Section::new(
572 OpenSet::from_places([Place::new("a"), Place::new("b")]),
573 Marking::new().with_token("a", "h1").with_token("b", "h3"),
574 );
575 let m1 = section_to_merkle(&s1);
576 let m2 = section_to_merkle(&s2);
577 assert_ne!(m1.hash, m2.hash);
578 }
579
580 #[cfg_attr(not(target_arch = "wasm32"), test)]
581 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
582 fn test_merkle_sub_root_detects_same_conflicts() {
583 let sheaf = Sheaf::new();
584 let s1 = Section::new(
585 OpenSet::from_places([Place::new("shared"), Place::new("a")]),
586 Marking::new().with_token("shared", "hash-s1"),
587 );
588 let s2 = Section::new(
589 OpenSet::from_places([Place::new("shared"), Place::new("b")]),
590 Marking::new().with_token("shared", "hash-s2"),
591 );
592 let cover = [
593 OpenSet::from_places([Place::new("shared"), Place::new("a")]),
594 OpenSet::from_places([Place::new("shared"), Place::new("b")]),
595 ];
596 let result = sheaf.gluing_check(&[s1, s2], &cover);
597 assert!(result.is_err());
598 let err = result.unwrap_err();
599 assert!(err.to_string().contains("COHOMOLOGICAL OBSTRUCTION"));
600 }
601
602 #[cfg_attr(not(target_arch = "wasm32"), test)]
603 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
604 fn test_merkle_sub_root_matching_sections_pass() {
605 let sheaf = Sheaf::new();
606 let s1 = Section::new(
607 OpenSet::from_places([Place::new("shared"), Place::new("a")]),
608 Marking::new().with_token("shared", "hash-s").with_token("a", "hash-a"),
609 );
610 let s2 = Section::new(
611 OpenSet::from_places([Place::new("shared"), Place::new("b")]),
612 Marking::new().with_token("shared", "hash-s").with_token("b", "hash-b"),
613 );
614 let cover = [
615 OpenSet::from_places([Place::new("shared"), Place::new("a")]),
616 OpenSet::from_places([Place::new("shared"), Place::new("b")]),
617 ];
618 let result = sheaf.gluing_check(&[s1, s2], &cover);
619 assert!(result.is_ok());
620 }
621
622 #[cfg_attr(not(target_arch = "wasm32"), test)]
625 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
626 fn test_conflict_report_from_gluing_failure() {
627 let sheaf = Sheaf::new();
628 let s1 = Section::new(
629 OpenSet::from_places([Place::new("shared"), Place::new("a")]),
630 Marking::new().with_token("shared", "hash-s1"),
631 );
632 let s2 = Section::new(
633 OpenSet::from_places([Place::new("shared"), Place::new("b")]),
634 Marking::new().with_token("shared", "hash-s2"),
635 );
636 let cover = [
637 OpenSet::from_places([Place::new("shared"), Place::new("a")]),
638 OpenSet::from_places([Place::new("shared"), Place::new("b")]),
639 ];
640 let err = sheaf.gluing_check(&[s1, s2], &cover).unwrap_err();
641 let report = CohomologyConflictReport::from_error(
642 &err,
643 vec!["did:key:agent1".to_string(), "did:key:agent2".to_string()],
644 );
645 assert!(report.is_some());
646 let r = report.unwrap();
647 assert_eq!(r.expected_marking.tokens.get("shared"), Some(&vec!["hash-s1".to_string()]));
648 assert_eq!(r.actual_marking.tokens.get("shared"), Some(&vec!["hash-s2".to_string()]));
649 assert_eq!(r.cohomology_class, "[delta_s]");
650 assert_eq!(r.agent_dids.len(), 2);
651 }
652
653 #[cfg_attr(not(target_arch = "wasm32"), test)]
654 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
655 fn test_conflict_report_yaml_serialization() {
656 let report = CohomologyConflictReport {
657 conflicting_places: (Place::new("a"), Place::new("b")),
658 intersection: OpenSet::from_places([Place::new("shared")]),
659 expected_marking: Marking::new().with_token("shared", "h1"),
660 actual_marking: Marking::new().with_token("shared", "h2"),
661 cohomology_class: "[delta_s]".to_string(),
662 timestamp: "2026-01-01T00:00:00Z".to_string(),
663 agent_dids: vec!["did:key:a1".to_string()],
664 };
665 let yaml = report.to_yaml();
666 assert!(yaml.contains("cohomology_class"));
667 assert!(yaml.contains("[delta_s]"));
668 assert!(yaml.contains("conflicting_places"));
669 let hash1 = report.content_hash();
671 let hash2 = report.content_hash();
672 assert_eq!(hash1, hash2);
673 }
674
675 #[cfg_attr(not(target_arch = "wasm32"), test)]
676 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
677 fn test_conflict_report_deterministic_hash() {
678 let make_report = || CohomologyConflictReport {
679 conflicting_places: (Place::new("x"), Place::new("y")),
680 intersection: OpenSet::from_places([Place::new("z")]),
681 expected_marking: Marking::new().with_token("z", "h1"),
682 actual_marking: Marking::new().with_token("z", "h2"),
683 cohomology_class: "[delta_s]".to_string(),
684 timestamp: "2026-01-01T00:00:00Z".to_string(),
685 agent_dids: vec!["did:key:a".to_string()],
686 };
687 let r1 = make_report();
688 let r2 = make_report();
689 assert_eq!(r1.content_hash(), r2.content_hash());
690 }
691
692 #[cfg_attr(not(target_arch = "wasm32"), test)]
695 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
696 fn test_benchmark_gluing_check_100_places_200_overlaps() {
697 let sheaf = Sheaf::new();
698 let mut sections = Vec::new();
699 let mut cover = Vec::new();
700 for i in 0..100 {
702 let p1 = format!("p{}", i);
703 let p2 = format!("p{}", (i + 1) % 100);
704 let os = OpenSet::from_places([Place::new(&p1), Place::new(&p2)]);
705 let marking = Marking::new()
706 .with_token(&p1, &format!("h{}", i))
707 .with_token(&p2, &format!("h{}", i));
708 sections.push(Section::new(os.clone(), marking));
709 cover.push(os);
710 }
711 let start = std::time::Instant::now();
712 let result = sheaf.gluing_check(§ions, &cover);
713 let elapsed = start.elapsed();
714 let _ = result;
719 assert!(
720 elapsed.as_millis() < 100,
721 "gluing_check took {}ms, expected < 100ms",
722 elapsed.as_millis()
723 );
724 }
725
726 #[cfg(feature = "native")]
727 #[test]
728 fn test_store_and_load_section_merkle() {
729 let conn = rusqlite::Connection::open_in_memory().unwrap();
730 conn.execute(
731 "CREATE TABLE card (hash TEXT PRIMARY KEY, content TEXT, g_time TEXT)",
732 [],
733 )
734 .unwrap();
735
736 let section = Section::new(
737 OpenSet::from_places([Place::new("a"), Place::new("b")]),
738 Marking::new().with_token("a", "h1").with_token("b", "h2"),
739 );
740 let hash = store_section_merkle(§ion, &conn).unwrap();
741 let loaded = load_section_merkle(&hash, &conn).unwrap();
742 assert_eq!(loaded.open_set, section.open_set);
743 assert_eq!(loaded.marking, section.marking);
744 }
745
746 #[cfg(feature = "native")]
747 #[test]
748 fn test_store_conflict_report_in_db() {
749 let conn = rusqlite::Connection::open_in_memory().unwrap();
750 conn.execute(
751 "CREATE TABLE card (hash TEXT PRIMARY KEY, content TEXT, g_time TEXT)",
752 [],
753 )
754 .unwrap();
755
756 let report = CohomologyConflictReport {
757 conflicting_places: (Place::new("a"), Place::new("b")),
758 intersection: OpenSet::from_places([Place::new("shared")]),
759 expected_marking: Marking::new().with_token("shared", "h1"),
760 actual_marking: Marking::new().with_token("shared", "h2"),
761 cohomology_class: "[delta_s]".to_string(),
762 timestamp: "2026-01-01T00:00:00Z".to_string(),
763 agent_dids: vec!["did:key:a1".to_string(), "did:key:a2".to_string()],
764 };
765 let hash = store_conflict_report(&report, &conn).unwrap();
766 let content: String = conn
767 .query_row(
768 "SELECT content FROM card WHERE hash = ?",
769 [&hash],
770 |row| row.get(0),
771 )
772 .unwrap();
773 assert!(content.contains("cohomology_class"));
774 assert!(content.contains("[delta_s]"));
775 assert!(content.contains("did:key:a1"));
776 }
777}