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 = crate::fs_utils::compute_g_time();
348 conn.execute(
349 "INSERT OR IGNORE INTO card (hash, content, g_time) VALUES (?, ?, ?)",
350 rusqlite::params![hash_hex, yaml, now],
351 )
352 .map_err(|e| e.to_string())?;
353 Ok(node.hash)
354}
355
356#[cfg(feature = "native")]
358pub fn load_section_merkle(
359 hash: &[u8; 32],
360 conn: &rusqlite::Connection,
361) -> Result<Section, String> {
362 let hash_hex = hex::encode(hash);
363 let content: String = conn
364 .query_row(
365 "SELECT content FROM card WHERE hash = ?",
366 [&hash_hex],
367 |row| row.get(0),
368 )
369 .map_err(|e| format!("Failed to load section: {}", e))?;
370 serde_yaml::from_str(&content).map_err(|e| format!("Failed to deserialize section: {}", e))
371}
372
373#[derive(Debug, Clone, Serialize, Deserialize)]
380pub struct CohomologyConflictReport {
381 pub conflicting_places: (Place, Place),
382 pub intersection: OpenSet,
383 pub expected_marking: Marking,
384 pub actual_marking: Marking,
385 pub cohomology_class: String,
386 pub timestamp: String,
387 pub agent_dids: Vec<String>,
388}
389
390impl CohomologyConflictReport {
391 pub fn to_yaml(&self) -> String {
393 serde_yaml::to_string(self).unwrap_or_else(|_| "cohomology_conflict: <error>".to_string())
394 }
395
396 pub fn content_hash(&self) -> String {
398 crate::hash::raw_hash_string(&self.to_yaml())
399 }
400
401 pub fn from_error(
403 err: &CohomologyError,
404 agent_dids: Vec<String>,
405 ) -> Option<Self> {
406 match err {
407 CohomologyError::GluingFailure {
408 place_i,
409 place_j,
410 intersection,
411 expected_marking,
412 actual_marking,
413 cohomology_class,
414 } => Some(CohomologyConflictReport {
415 conflicting_places: (place_i.clone(), place_j.clone()),
416 intersection: intersection.clone(),
417 expected_marking: expected_marking.clone(),
418 actual_marking: actual_marking.clone(),
419 cohomology_class: cohomology_class.clone(),
420 timestamp: chrono::Utc::now().to_rfc3339(),
421 agent_dids,
422 }),
423 _ => None,
424 }
425 }
426}
427
428#[cfg(feature = "native")]
430pub fn store_conflict_report(
431 report: &CohomologyConflictReport,
432 conn: &rusqlite::Connection,
433) -> Result<String, String> {
434 let yaml = report.to_yaml();
435 let hash = report.content_hash();
436 let now = crate::fs_utils::compute_g_time();
438 conn.execute(
439 "INSERT OR IGNORE INTO card (hash, content, g_time) VALUES (?, ?, ?)",
440 rusqlite::params![hash, yaml, now],
441 )
442 .map_err(|e| e.to_string())?;
443 Ok(hash)
444}
445
446#[cfg(test)]
447mod tests {
448 use super::*;
449
450 #[cfg_attr(not(target_arch = "wasm32"), test)]
451 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
452 fn test_disjoint_places_glue() {
453 let sheaf = Sheaf::new();
454 let s1 = Section::new(
455 OpenSet::from_places([Place::new("a")]),
456 Marking::new().with_token("a", "hash-a"),
457 );
458 let s2 = Section::new(
459 OpenSet::from_places([Place::new("b")]),
460 Marking::new().with_token("b", "hash-b"),
461 );
462 let global = sheaf.gluing_check(&[s1, s2], &[OpenSet::from_places([Place::new("a")]), OpenSet::from_places([Place::new("b")])]).unwrap();
463 assert_eq!(global.open_set.places.len(), 2);
464 }
465
466 #[cfg_attr(not(target_arch = "wasm32"), test)]
467 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
468 fn test_overlapping_matching_restrictions_glue() {
469 let sheaf = Sheaf::new();
470 let _shared = OpenSet::from_places([Place::new("shared")]);
471 let s1 = Section::new(
472 OpenSet::from_places([Place::new("shared"), Place::new("a")]),
473 Marking::new().with_token("shared", "hash-s").with_token("a", "hash-a"),
474 );
475 let s2 = Section::new(
476 OpenSet::from_places([Place::new("shared"), Place::new("b")]),
477 Marking::new().with_token("shared", "hash-s").with_token("b", "hash-b"),
478 );
479 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();
480 assert!(global.open_set.places.contains(&Place::new("shared")));
481 }
482
483 #[cfg_attr(not(target_arch = "wasm32"), test)]
484 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
485 fn test_overlapping_mismatched_restrictions_fail() {
486 let sheaf = Sheaf::new();
487 let s1 = Section::new(
488 OpenSet::from_places([Place::new("shared"), Place::new("a")]),
489 Marking::new().with_token("shared", "hash-s1"),
490 );
491 let s2 = Section::new(
492 OpenSet::from_places([Place::new("shared"), Place::new("b")]),
493 Marking::new().with_token("shared", "hash-s2"),
494 );
495 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")])]);
496 assert!(result.is_err());
497 let err = result.unwrap_err();
498 assert!(err.to_string().contains("COHOMOLOGICAL OBSTRUCTION"));
499 }
500
501 #[cfg_attr(not(target_arch = "wasm32"), test)]
502 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
503 fn test_three_section_cover_glue() {
504 let sheaf = Sheaf::new();
505 let cover = [
506 OpenSet::from_places([Place::new("a"), Place::new("b")]),
507 OpenSet::from_places([Place::new("b"), Place::new("c")]),
508 OpenSet::from_places([Place::new("c"), Place::new("d")]),
509 ];
510 let s1 = Section::new(cover[0].clone(), Marking::new().with_token("a", "h").with_token("b", "h"));
511 let s2 = Section::new(cover[1].clone(), Marking::new().with_token("b", "h").with_token("c", "h"));
512 let s3 = Section::new(cover[2].clone(), Marking::new().with_token("c", "h").with_token("d", "h"));
513 let global = sheaf.gluing_check(&[s1, s2, s3], &cover).unwrap();
514 assert_eq!(global.open_set.places.len(), 4);
515 }
516
517 #[cfg_attr(not(target_arch = "wasm32"), test)]
518 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
519 fn test_three_sections_one_conflict() {
520 let sheaf = Sheaf::new();
521 let cover = [
522 OpenSet::from_places([Place::new("a"), Place::new("b")]),
523 OpenSet::from_places([Place::new("b"), Place::new("c")]),
524 OpenSet::from_places([Place::new("c"), Place::new("d")]),
525 ];
526 let s1 = Section::new(cover[0].clone(), Marking::new().with_token("a", "h").with_token("b", "h1"));
527 let s2 = Section::new(cover[1].clone(), Marking::new().with_token("b", "h2").with_token("c", "h"));
528 let s3 = Section::new(cover[2].clone(), Marking::new().with_token("c", "h").with_token("d", "h"));
529 let result = sheaf.gluing_check(&[s1, s2, s3], &cover);
530 assert!(result.is_err());
531 }
532
533 #[cfg_attr(not(target_arch = "wasm32"), test)]
534 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
535 fn test_open_set_operations() {
536 let a = OpenSet::from_places([Place::new("x"), Place::new("y")]);
537 let b = OpenSet::from_places([Place::new("y"), Place::new("z")]);
538 assert!(!a.is_disjoint(&b));
539 let inter = a.intersection(&b);
540 assert_eq!(inter.places, [Place::new("y")].iter().cloned().collect());
541 assert!(OpenSet::from_places([Place::new("y")]).is_subset(&a));
542 }
543
544 #[cfg_attr(not(target_arch = "wasm32"), test)]
547 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
548 fn test_identical_sections_produce_identical_merkle_roots() {
549 let s1 = Section::new(
550 OpenSet::from_places([Place::new("a"), Place::new("b")]),
551 Marking::new().with_token("a", "h1").with_token("b", "h2"),
552 );
553 let s2 = Section::new(
554 OpenSet::from_places([Place::new("a"), Place::new("b")]),
555 Marking::new().with_token("a", "h1").with_token("b", "h2"),
556 );
557 let m1 = section_to_merkle(&s1);
558 let m2 = section_to_merkle(&s2);
559 assert_eq!(m1.hash, m2.hash);
560 }
561
562 #[cfg_attr(not(target_arch = "wasm32"), test)]
563 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
564 fn test_different_sections_produce_different_merkle_roots() {
565 let s1 = Section::new(
566 OpenSet::from_places([Place::new("a"), Place::new("b")]),
567 Marking::new().with_token("a", "h1").with_token("b", "h2"),
568 );
569 let s2 = Section::new(
570 OpenSet::from_places([Place::new("a"), Place::new("b")]),
571 Marking::new().with_token("a", "h1").with_token("b", "h3"),
572 );
573 let m1 = section_to_merkle(&s1);
574 let m2 = section_to_merkle(&s2);
575 assert_ne!(m1.hash, m2.hash);
576 }
577
578 #[cfg_attr(not(target_arch = "wasm32"), test)]
579 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
580 fn test_merkle_sub_root_detects_same_conflicts() {
581 let sheaf = Sheaf::new();
582 let s1 = Section::new(
583 OpenSet::from_places([Place::new("shared"), Place::new("a")]),
584 Marking::new().with_token("shared", "hash-s1"),
585 );
586 let s2 = Section::new(
587 OpenSet::from_places([Place::new("shared"), Place::new("b")]),
588 Marking::new().with_token("shared", "hash-s2"),
589 );
590 let cover = [
591 OpenSet::from_places([Place::new("shared"), Place::new("a")]),
592 OpenSet::from_places([Place::new("shared"), Place::new("b")]),
593 ];
594 let result = sheaf.gluing_check(&[s1, s2], &cover);
595 assert!(result.is_err());
596 let err = result.unwrap_err();
597 assert!(err.to_string().contains("COHOMOLOGICAL OBSTRUCTION"));
598 }
599
600 #[cfg_attr(not(target_arch = "wasm32"), test)]
601 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
602 fn test_merkle_sub_root_matching_sections_pass() {
603 let sheaf = Sheaf::new();
604 let s1 = Section::new(
605 OpenSet::from_places([Place::new("shared"), Place::new("a")]),
606 Marking::new().with_token("shared", "hash-s").with_token("a", "hash-a"),
607 );
608 let s2 = Section::new(
609 OpenSet::from_places([Place::new("shared"), Place::new("b")]),
610 Marking::new().with_token("shared", "hash-s").with_token("b", "hash-b"),
611 );
612 let cover = [
613 OpenSet::from_places([Place::new("shared"), Place::new("a")]),
614 OpenSet::from_places([Place::new("shared"), Place::new("b")]),
615 ];
616 let result = sheaf.gluing_check(&[s1, s2], &cover);
617 assert!(result.is_ok());
618 }
619
620 #[cfg_attr(not(target_arch = "wasm32"), test)]
623 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
624 fn test_conflict_report_from_gluing_failure() {
625 let sheaf = Sheaf::new();
626 let s1 = Section::new(
627 OpenSet::from_places([Place::new("shared"), Place::new("a")]),
628 Marking::new().with_token("shared", "hash-s1"),
629 );
630 let s2 = Section::new(
631 OpenSet::from_places([Place::new("shared"), Place::new("b")]),
632 Marking::new().with_token("shared", "hash-s2"),
633 );
634 let cover = [
635 OpenSet::from_places([Place::new("shared"), Place::new("a")]),
636 OpenSet::from_places([Place::new("shared"), Place::new("b")]),
637 ];
638 let err = sheaf.gluing_check(&[s1, s2], &cover).unwrap_err();
639 let report = CohomologyConflictReport::from_error(
640 &err,
641 vec!["did:key:agent1".to_string(), "did:key:agent2".to_string()],
642 );
643 assert!(report.is_some());
644 let r = report.unwrap();
645 assert_eq!(r.expected_marking.tokens.get("shared"), Some(&vec!["hash-s1".to_string()]));
646 assert_eq!(r.actual_marking.tokens.get("shared"), Some(&vec!["hash-s2".to_string()]));
647 assert_eq!(r.cohomology_class, "[delta_s]");
648 assert_eq!(r.agent_dids.len(), 2);
649 }
650
651 #[cfg_attr(not(target_arch = "wasm32"), test)]
652 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
653 fn test_conflict_report_yaml_serialization() {
654 let report = CohomologyConflictReport {
655 conflicting_places: (Place::new("a"), Place::new("b")),
656 intersection: OpenSet::from_places([Place::new("shared")]),
657 expected_marking: Marking::new().with_token("shared", "h1"),
658 actual_marking: Marking::new().with_token("shared", "h2"),
659 cohomology_class: "[delta_s]".to_string(),
660 timestamp: "2026-01-01T00:00:00Z".to_string(),
661 agent_dids: vec!["did:key:a1".to_string()],
662 };
663 let yaml = report.to_yaml();
664 assert!(yaml.contains("cohomology_class"));
665 assert!(yaml.contains("[delta_s]"));
666 assert!(yaml.contains("conflicting_places"));
667 let hash1 = report.content_hash();
669 let hash2 = report.content_hash();
670 assert_eq!(hash1, hash2);
671 }
672
673 #[cfg_attr(not(target_arch = "wasm32"), test)]
674 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
675 fn test_conflict_report_deterministic_hash() {
676 let make_report = || CohomologyConflictReport {
677 conflicting_places: (Place::new("x"), Place::new("y")),
678 intersection: OpenSet::from_places([Place::new("z")]),
679 expected_marking: Marking::new().with_token("z", "h1"),
680 actual_marking: Marking::new().with_token("z", "h2"),
681 cohomology_class: "[delta_s]".to_string(),
682 timestamp: "2026-01-01T00:00:00Z".to_string(),
683 agent_dids: vec!["did:key:a".to_string()],
684 };
685 let r1 = make_report();
686 let r2 = make_report();
687 assert_eq!(r1.content_hash(), r2.content_hash());
688 }
689
690 #[cfg_attr(not(target_arch = "wasm32"), test)]
693 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
694 fn test_benchmark_gluing_check_100_places_200_overlaps() {
695 let sheaf = Sheaf::new();
696 let mut sections = Vec::new();
697 let mut cover = Vec::new();
698 for i in 0..100 {
700 let p1 = format!("p{}", i);
701 let p2 = format!("p{}", (i + 1) % 100);
702 let os = OpenSet::from_places([Place::new(&p1), Place::new(&p2)]);
703 let marking = Marking::new()
704 .with_token(&p1, &format!("h{}", i))
705 .with_token(&p2, &format!("h{}", i));
706 sections.push(Section::new(os.clone(), marking));
707 cover.push(os);
708 }
709 let start = std::time::Instant::now();
710 let result = sheaf.gluing_check(§ions, &cover);
711 let elapsed = start.elapsed();
712 let _ = result;
717 assert!(
718 elapsed.as_millis() < 100,
719 "gluing_check took {}ms, expected < 100ms",
720 elapsed.as_millis()
721 );
722 }
723
724 #[cfg(feature = "native")]
725 #[test]
726 fn test_store_and_load_section_merkle() {
727 let conn = rusqlite::Connection::open_in_memory().unwrap();
728 conn.execute(
729 "CREATE TABLE card (hash TEXT PRIMARY KEY, content TEXT, g_time TEXT)",
730 [],
731 )
732 .unwrap();
733
734 let section = Section::new(
735 OpenSet::from_places([Place::new("a"), Place::new("b")]),
736 Marking::new().with_token("a", "h1").with_token("b", "h2"),
737 );
738 let hash = store_section_merkle(§ion, &conn).unwrap();
739 let loaded = load_section_merkle(&hash, &conn).unwrap();
740 assert_eq!(loaded.open_set, section.open_set);
741 assert_eq!(loaded.marking, section.marking);
742 }
743
744 #[cfg(feature = "native")]
745 #[test]
746 fn test_store_conflict_report_in_db() {
747 let conn = rusqlite::Connection::open_in_memory().unwrap();
748 conn.execute(
749 "CREATE TABLE card (hash TEXT PRIMARY KEY, content TEXT, g_time TEXT)",
750 [],
751 )
752 .unwrap();
753
754 let report = CohomologyConflictReport {
755 conflicting_places: (Place::new("a"), Place::new("b")),
756 intersection: OpenSet::from_places([Place::new("shared")]),
757 expected_marking: Marking::new().with_token("shared", "h1"),
758 actual_marking: Marking::new().with_token("shared", "h2"),
759 cohomology_class: "[delta_s]".to_string(),
760 timestamp: "2026-01-01T00:00:00Z".to_string(),
761 agent_dids: vec!["did:key:a1".to_string(), "did:key:a2".to_string()],
762 };
763 let hash = store_conflict_report(&report, &conn).unwrap();
764 let content: String = conn
765 .query_row(
766 "SELECT content FROM card WHERE hash = ?",
767 [&hash],
768 |row| row.get(0),
769 )
770 .unwrap();
771 assert!(content.contains("cohomology_class"));
772 assert!(content.contains("[delta_s]"));
773 assert!(content.contains("did:key:a1"));
774 }
775}