cesr-rs 0.1.1

CESR + KERI primitives for Rust as a single feature-gated, no_std-capable crate
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use crate::keri::error::KeriError;
#[cfg(feature = "alloc")]
#[allow(
    unused_imports,
    reason = "alloc prelude items; subset used per cfg/feature combination"
)]
use alloc::borrow::ToOwned;

/// KERI infrastructure roles.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Role {
    /// Identifier controller.
    Controller,
    /// Witness providing receipts.
    Witness,
    /// Watcher monitoring key event logs.
    Watcher,
    /// Registrar managing credential registries.
    Registrar,
    /// Judge evaluating duplicity.
    Judge,
    /// Generic peer participant.
    Peer,
    /// Gateway for protocol bridging.
    Gateway,
    /// Juror for adjudicating duplicity.
    Juror,
    /// Mailbox for asynchronous message delivery.
    Mailbox,
    /// Agent acting on behalf of a controller.
    Agent,
    /// Indexer for event log indexing.
    Indexer,
}

impl Role {
    /// Returns the KERI code for this role.
    #[must_use]
    pub const fn code(&self) -> &'static str {
        match self {
            Self::Controller => "controller",
            Self::Witness => "witness",
            Self::Watcher => "watcher",
            Self::Registrar => "registrar",
            Self::Judge => "judge",
            Self::Peer => "peer",
            Self::Gateway => "gateway",
            Self::Juror => "juror",
            Self::Mailbox => "mailbox",
            Self::Agent => "agent",
            Self::Indexer => "indexer",
        }
    }

    /// Parses a `Role` from its KERI code.
    ///
    /// # Errors
    ///
    /// Returns [`KeriError::UnknownRole`] if the code is not recognized.
    pub fn from_code(code: &str) -> Result<Self, KeriError> {
        match code {
            "controller" => Ok(Self::Controller),
            "witness" => Ok(Self::Witness),
            "watcher" => Ok(Self::Watcher),
            "registrar" => Ok(Self::Registrar),
            "judge" => Ok(Self::Judge),
            "peer" => Ok(Self::Peer),
            "gateway" => Ok(Self::Gateway),
            "juror" => Ok(Self::Juror),
            "mailbox" => Ok(Self::Mailbox),
            "agent" => Ok(Self::Agent),
            "indexer" => Ok(Self::Indexer),
            _ => Err(KeriError::UnknownRole(code.to_owned())),
        }
    }
}

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

    const ALL_VARIANTS: &[(Role, &str)] = &[
        (Role::Controller, "controller"),
        (Role::Witness, "witness"),
        (Role::Watcher, "watcher"),
        (Role::Registrar, "registrar"),
        (Role::Judge, "judge"),
        (Role::Peer, "peer"),
        (Role::Gateway, "gateway"),
        (Role::Juror, "juror"),
        (Role::Mailbox, "mailbox"),
        (Role::Agent, "agent"),
        (Role::Indexer, "indexer"),
    ];

    #[test]
    fn role_code_roundtrip() {
        for (variant, expected_code) in ALL_VARIANTS {
            assert_eq!(variant.code(), *expected_code);
            let parsed = Role::from_code(expected_code).unwrap();
            assert_eq!(parsed, *variant);
        }
    }

    #[test]
    fn role_from_code_valid() {
        assert_eq!(Role::from_code("controller").unwrap(), Role::Controller);
        assert_eq!(Role::from_code("peer").unwrap(), Role::Peer);
    }

    #[test]
    fn role_from_code_invalid() {
        let err = Role::from_code("unknown").unwrap_err();
        assert!(matches!(err, KeriError::UnknownRole(ref s) if s == "unknown"));
    }
}