ed25519/
serde.rs

1//! `serde` support.
2
3use crate::{Signature, SignatureBytes};
4use ::serde::{de, ser, Deserialize, Serialize};
5use core::fmt;
6
7impl Serialize for Signature {
8    fn serialize<S: ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
9        use ser::SerializeTuple;
10
11        let mut seq = serializer.serialize_tuple(Signature::BYTE_SIZE)?;
12
13        for byte in self.to_bytes() {
14            seq.serialize_element(&byte)?;
15        }
16
17        seq.end()
18    }
19}
20
21// serde lacks support for deserializing arrays larger than 32-bytes
22// see: <https://github.com/serde-rs/serde/issues/631>
23impl<'de> Deserialize<'de> for Signature {
24    fn deserialize<D: de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
25        struct ByteArrayVisitor;
26
27        impl<'de> de::Visitor<'de> for ByteArrayVisitor {
28            type Value = [u8; Signature::BYTE_SIZE];
29
30            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
31                formatter.write_str("bytestring of length 64")
32            }
33
34            fn visit_seq<A>(self, mut seq: A) -> Result<[u8; Signature::BYTE_SIZE], A::Error>
35            where
36                A: de::SeqAccess<'de>,
37            {
38                use de::Error;
39                let mut arr = [0u8; Signature::BYTE_SIZE];
40
41                for (i, byte) in arr.iter_mut().enumerate() {
42                    *byte = seq
43                        .next_element()?
44                        .ok_or_else(|| Error::invalid_length(i, &self))?;
45                }
46
47                Ok(arr)
48            }
49        }
50
51        deserializer
52            .deserialize_tuple(Signature::BYTE_SIZE, ByteArrayVisitor)
53            .map(Into::into)
54    }
55}
56
57#[cfg(feature = "serde_bytes")]
58impl serde_bytes::Serialize for Signature {
59    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
60    where
61        S: serde::Serializer,
62    {
63        serializer.serialize_bytes(&self.to_bytes())
64    }
65}
66
67#[cfg(feature = "serde_bytes")]
68impl<'de> serde_bytes::Deserialize<'de> for Signature {
69    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
70    where
71        D: de::Deserializer<'de>,
72    {
73        struct ByteArrayVisitor;
74
75        impl<'de> de::Visitor<'de> for ByteArrayVisitor {
76            type Value = SignatureBytes;
77
78            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
79                formatter.write_str("bytestring of length 64")
80            }
81
82            fn visit_bytes<E>(self, bytes: &[u8]) -> Result<Self::Value, E>
83            where
84                E: de::Error,
85            {
86                use de::Error;
87
88                bytes
89                    .try_into()
90                    .map_err(|_| Error::invalid_length(bytes.len(), &self))
91            }
92        }
93
94        deserializer
95            .deserialize_bytes(ByteArrayVisitor)
96            .map(Into::into)
97    }
98}
99
100#[cfg(test)]
101mod tests {
102    use crate::{Signature, SignatureBytes};
103    use hex_literal::hex;
104
105    const SIGNATURE_BYTES: SignatureBytes = hex!(
106        "
107        e5564300c360ac729086e2cc806e828a
108        84877f1eb8e5d974d873e06522490155
109        5fb8821590a33bacc61e39701cf9b46b
110        d25bf5f0595bbe24655141438e7a100b
111        "
112    );
113
114    #[test]
115    fn round_trip() {
116        let signature = Signature::from_bytes(&SIGNATURE_BYTES);
117        let serialized = bincode::serialize(&signature).unwrap();
118        let deserialized = bincode::deserialize(&serialized).unwrap();
119        assert_eq!(signature, deserialized);
120    }
121}
ed25519/serde.rs

ed25519/
serde.rs
