scsys-crypto 0.3.2

cryptographic primitives and utilities for the scsys ecosystem
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

/*
    Appellation: h160 <module>
    Contrib: @FL03
*/
#[cfg(feature = "blake3")]
mod impl_blake3;
mod impl_convert;
mod impl_ops;

/// The H160Hash type is a 20-byte hash.
pub type H160Hash = [u8; 20];

/// A SHA160 hash type.
#[derive(Clone, Copy, Default, Eq, Hash, PartialEq)]
#[cfg_attr(
    feature = "serde",
    derive(serde::Deserialize, serde::Serialize),
    serde(default, transparent)
)]
#[repr(transparent)]
pub struct H160(pub H160Hash);

impl H160 {
    pub fn from_digest(digest: impl AsRef<[u8]>) -> Self {
        let hash = crate::digest_to_hash::<20>(digest);
        Self(hash)
    }
    #[cfg(feature = "blake3")]
    pub fn b3(data: impl AsRef<[u8]>) -> Self {
        let hash = blake3::hash(data.as_ref());
        Self::from_digest(hash.as_bytes())
    }
    #[cfg(feature = "rand")]
    pub fn random() -> Self {
        let data = rand::random::<H160Hash>();
        let mut raw_bytes = [0; 20];
        raw_bytes.copy_from_slice(&data);
        (&raw_bytes).into()
    }
    /// returns the hash as a slice
    pub const fn as_slice(&self) -> &[u8] {
        &self.0
    }
    /// returns a mutable reference to the hash as a slice
    pub fn as_slice_mut(&mut self) -> &mut [u8] {
        &mut self.0
    }
    /// copies the hash into the provided buffer
    pub fn copy_from_slice(&mut self, value: &[u8]) -> &mut Self {
        self.0.copy_from_slice(value);
        self
    }
    /// returns the hash as a byte array
    pub const fn get(&self) -> &H160Hash {
        &self.0
    }
    /// returns a mutable reference to the hash as a byte array
    pub const fn get_mut(&mut self) -> &mut H160Hash {
        &mut self.0
    }
    /// updates the hash with the provided value
    pub fn set(&mut self, value: H160Hash) -> &mut Self {
        *self.get_mut() = value;
        self
    }
    /// [`replace`](core::mem::replace) and return the current value with another
    pub fn replace(&mut self, value: &H160Hash) -> H160Hash {
        core::mem::replace(&mut self.0, *value)
    }
    /// [`swap`](core::mem::swap) the current value with another
    pub fn swap(&mut self, other: &mut Self) {
        core::mem::swap(&mut self.0, &mut other.0)
    }
    #[cfg(feature = "alloc")]
    /// returns a [`Vec<u8>`](alloc::vec::Vec) representation of the hash
    pub fn to_vec(&self) -> alloc::vec::Vec<u8> {
        self.get().to_vec()
    }
}

impl core::fmt::Debug for H160 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        write!(
            f,
            "{:>02x}{:>02x}..{:>02x}{:>02x}",
            &self[0], &self[1], &self[18], &self[19]
        )
    }
}

impl core::fmt::Display for H160 {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        let start = if let Some(precision) = f.precision() {
            if precision >= 64 {
                0
            } else {
                20 - precision / 2
            }
        } else {
            0
        };
        for byte_idx in start..20 {
            write!(f, "{:>02x}", &self.0[byte_idx])?;
        }
        Ok(())
    }
}

impl AsRef<[u8]> for H160 {
    #[inline]
    fn as_ref(&self) -> &[u8] {
        &self.0
    }
}

impl AsMut<[u8]> for H160 {
    #[inline]
    fn as_mut(&mut self) -> &mut [u8] {
        &mut self.0
    }
}

impl core::borrow::Borrow<[u8]> for H160 {
    #[inline]
    fn borrow(&self) -> &[u8] {
        &self.0
    }
}

impl core::borrow::BorrowMut<[u8]> for H160 {
    #[inline]
    fn borrow_mut(&mut self) -> &mut [u8] {
        &mut self.0
    }
}

impl core::ops::Deref for H160 {
    type Target = [u8; 20];

    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl core::ops::DerefMut for H160 {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}