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