cesr-rs 0.2.0

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
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use super::cesr_code::CesrCode;
use super::matter_code::MatterCode;
use super::sealed::Sealed;
use super::verkey::VerKeyCode;
use crate::core::matter::error::ValidationError;
#[cfg(feature = "alloc")]
#[allow(
    unused_imports,
    reason = "alloc prelude items; subset used per cfg/feature combination"
)]
use alloc::string::ToString;

/// CESR codes for supported private key (seed) types.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
pub enum SeedCode {
    /// Ed25519 32-byte private key seed.
    Ed25519Seed,
    /// secp256k1 (ECDSA) 32-byte private key seed.
    ECDSA256k1Seed,
    /// Ed448 56-byte private key seed.
    Ed448Seed,
    /// secp256r1 / P-256 (ECDSA) 32-byte private key seed.
    ECDSA256r1Seed,
}

impl SeedCode {
    /// Returns the corresponding [`VerKeyCode`] for the public key derived from this seed.
    #[must_use]
    pub const fn verkey_code(&self) -> VerKeyCode {
        match self {
            Self::Ed25519Seed => VerKeyCode::Ed25519,
            Self::ECDSA256k1Seed => VerKeyCode::ECDSA256k1,
            Self::Ed448Seed => VerKeyCode::Ed448,
            Self::ECDSA256r1Seed => VerKeyCode::ECDSA256r1,
        }
    }
}

impl Sealed for SeedCode {}

impl CesrCode for SeedCode {
    fn to_matter_code(&self) -> MatterCode {
        match self {
            Self::Ed25519Seed => MatterCode::Ed25519Seed,
            Self::ECDSA256k1Seed => MatterCode::ECDSA256k1Seed,
            Self::Ed448Seed => MatterCode::Ed448Seed,
            Self::ECDSA256r1Seed => MatterCode::ECDSA256r1Seed,
        }
    }

    fn as_str(&self) -> &'static str {
        match self {
            Self::Ed25519Seed => "A",
            Self::ECDSA256k1Seed => "J",
            Self::Ed448Seed => "K",
            Self::ECDSA256r1Seed => "Q",
        }
    }
}

impl TryFrom<MatterCode> for SeedCode {
    type Error = ValidationError;

    fn try_from(code: MatterCode) -> Result<Self, Self::Error> {
        match code {
            MatterCode::Ed25519Seed => Ok(Self::Ed25519Seed),
            MatterCode::ECDSA256k1Seed => Ok(Self::ECDSA256k1Seed),
            MatterCode::Ed448Seed => Ok(Self::Ed448Seed),
            MatterCode::ECDSA256r1Seed => Ok(Self::ECDSA256r1Seed),
            _ => Err(ValidationError::UnknownMatterCode(code.to_string())),
        }
    }
}

impl From<SeedCode> for MatterCode {
    fn from(code: SeedCode) -> Self {
        code.to_matter_code()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::core::matter::code::MatterCode;
    use crate::core::matter::code::VerKeyCode;

    #[test]
    fn seed_code_to_matter_code_roundtrip() {
        let codes = [
            (SeedCode::Ed25519Seed, MatterCode::Ed25519Seed),
            (SeedCode::ECDSA256k1Seed, MatterCode::ECDSA256k1Seed),
            (SeedCode::Ed448Seed, MatterCode::Ed448Seed),
            (SeedCode::ECDSA256r1Seed, MatterCode::ECDSA256r1Seed),
        ];
        for (sc, mc) in codes {
            assert_eq!(sc.to_matter_code(), mc);
            assert_eq!(SeedCode::try_from(mc).unwrap(), sc);
            assert_eq!(MatterCode::from(sc), mc);
        }
    }

    #[test]
    fn seed_code_rejects_non_seed() {
        assert!(SeedCode::try_from(MatterCode::Ed25519).is_err());
        assert!(SeedCode::try_from(MatterCode::Blake3_256).is_err());
        assert!(SeedCode::try_from(MatterCode::Short).is_err());
    }

    #[test]
    fn seed_code_as_str() {
        assert_eq!(SeedCode::Ed25519Seed.as_str(), "A");
        assert_eq!(SeedCode::ECDSA256k1Seed.as_str(), "J");
        assert_eq!(SeedCode::Ed448Seed.as_str(), "K");
        assert_eq!(SeedCode::ECDSA256r1Seed.as_str(), "Q");
    }

    #[test]
    fn seed_code_verkey_relationship() {
        assert_eq!(SeedCode::Ed25519Seed.verkey_code(), VerKeyCode::Ed25519);
        assert_eq!(
            SeedCode::ECDSA256k1Seed.verkey_code(),
            VerKeyCode::ECDSA256k1
        );
        assert_eq!(SeedCode::Ed448Seed.verkey_code(), VerKeyCode::Ed448);
        assert_eq!(
            SeedCode::ECDSA256r1Seed.verkey_code(),
            VerKeyCode::ECDSA256r1
        );
    }
}