auths-core 0.1.1

Core cryptography and keychain integration for Auths
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

//! No-op witness implementation.
//!
//! This is the default witness that disables all witness checks.
//! Use this when:
//! - You don't need split-view protection
//! - You're in a private/trusted environment
//! - The system has other consistency mechanisms (e.g., external consistency logic)

use auths_keri::Prefix;

use super::hash::EventHash;
use super::provider::WitnessProvider;

/// A no-op witness that returns `None` for all queries.
///
/// This effectively disables witness checking, which is the default
/// behavior for Auths. Split-view protection is opt-in.
///
/// # Example
///
/// ```rust
/// use auths_core::witness::{WitnessProvider, NoOpWitness};
/// use auths_keri::Prefix;
///
/// let witness = NoOpWitness;
/// let prefix = Prefix::new_unchecked("E123abc".into());
///
/// // Always returns None (no opinion)
/// assert!(witness.observe_identity_head(&prefix).is_none());
///
/// // Disabled by default
/// assert!(!witness.is_enabled());
/// ```
#[derive(Debug, Clone, Copy, Default)]
pub struct NoOpWitness;

impl NoOpWitness {
    /// Create a new no-op witness.
    pub fn new() -> Self {
        Self
    }
}

impl WitnessProvider for NoOpWitness {
    fn observe_identity_head(&self, _prefix: &Prefix) -> Option<EventHash> {
        None
    }

    fn quorum(&self) -> usize {
        0 // No quorum needed when disabled
    }

    fn is_enabled(&self) -> bool {
        false
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_noop_returns_none() {
        let witness = NoOpWitness;
        let prefix = Prefix::new_unchecked("ETestPrefix".into());
        assert!(witness.observe_identity_head(&prefix).is_none());
    }

    #[test]
    fn test_noop_is_disabled() {
        let witness = NoOpWitness;
        assert!(!witness.is_enabled());
    }

    #[test]
    fn test_noop_quorum_is_zero() {
        let witness = NoOpWitness;
        assert_eq!(witness.quorum(), 0);
    }

    #[test]
    fn test_noop_is_send_sync() {
        fn assert_send_sync<T: Send + Sync>() {}
        assert_send_sync::<NoOpWitness>();
    }
}