nois 2.0.0

The Nois standard library
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

use std::fmt;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RandomnessFromStrErr {
    InvalidInputLength {
        /// Input length in bytes
        n: usize,
    },
    InvalidHexCharacter {
        c: char,
        index: usize,
    },
}

impl fmt::Display for RandomnessFromStrErr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            RandomnessFromStrErr::InvalidInputLength { n } => {
                write!(
                    f,
                    "Expected 64 hex characters but got an input of {n} bytes"
                )
            }
            RandomnessFromStrErr::InvalidHexCharacter { c, index } => {
                write!(f, "Invalid character {:?} at position {}", c, index)
            }
        }
    }
}

/// Takes a hex string and decodes it. Input must be 64 hex characters long (32 bytes).
pub fn randomness_from_str(input: impl AsRef<str>) -> Result<[u8; 32], RandomnessFromStrErr> {
    let input = input.as_ref();
    if input.len() != 64 {
        return Err(RandomnessFromStrErr::InvalidInputLength { n: input.len() });
    }

    let mut out: [u8; 32] = Default::default();
    hex::decode_to_slice(input, &mut out).map_err(|err| match err {
        hex::FromHexError::InvalidHexCharacter { c, index } => {
            RandomnessFromStrErr::InvalidHexCharacter { c, index }
        }
        // Those two cases cannot happen as long as we check the input length independently
        hex::FromHexError::OddLength => unreachable!(),
        hex::FromHexError::InvalidStringLength => unreachable!(),
    })?;
    Ok(out)
}

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

    #[test]
    fn randomness_from_str_works() {
        let r =
            randomness_from_str("0000000000000000000000000000000000000000000000000000000000000000")
                .unwrap();
        assert_eq!(r, [0u8; 32]);
        let r =
            randomness_from_str("0101010101010101010101010101010101010101010101010101010101010101")
                .unwrap();
        assert_eq!(r, [1u8; 32]);

        // node
        // Uint8Array.from(Buffer.from("9e8e26615f51552aa3b18b6f0bcf0dae5afbe30321e8d7ea7fa51ebeb1d8fe62", "hex"))
        let r =
            randomness_from_str("9e8e26615f51552aa3b18b6f0bcf0dae5afbe30321e8d7ea7fa51ebeb1d8fe62")
                .unwrap();
        assert_eq!(
            r,
            [
                158, 142, 38, 97, 95, 81, 85, 42, 163, 177, 139, 111, 11, 207, 13, 174, 90, 251,
                227, 3, 33, 232, 215, 234, 127, 165, 30, 190, 177, 216, 254, 98
            ]
        );

        // wrong input length (30 bytes)
        let err =
            randomness_from_str("26615f51552aa3b18b6f0bcf0dae5afbe30321e8d7ea7fa51ebeb1d8fe62")
                .unwrap_err();
        assert_eq!(
            err.to_string(),
            "Expected 64 hex characters but got an input of 60 bytes"
        );

        // wrong input length and characters
        let err = randomness_from_str("whatever 🤷‍♂️").unwrap_err();
        assert_eq!(
            err.to_string(),
            "Expected 64 hex characters but got an input of 22 bytes"
        );
    }
}