implement serializable for pairs

src/bytes_ser_de.rs

@@ -404,6 +404,39 @@ where
     }
 }
 
+impl<T1: Serializable, T2: Serializable> Serializable for (T1, T2)
+where
+    T1::Error: From<CryptoCoreError>,
+    T2::Error: From<CryptoCoreError>,
+{
+    type Error = CryptoCoreError;
+
+    fn length(&self) -> usize {
+        self.0.length() + self.1.length()
+    }
+
+    fn write(&self, ser: &mut Serializer) -> Result<usize, Self::Error> {
+        let mut n = self
+            .0
+            .write(ser)
+            .map_err(|e| Self::Error::GenericSerializationError(e.to_string()))?;
+        n += self
+            .1
+            .write(ser)
+            .map_err(|e| Self::Error::GenericSerializationError(e.to_string()))?;
+        Ok(n)
+    }
+
+    fn read(de: &mut Deserializer) -> Result<Self, Self::Error> {
+        Ok((
+            de.read()
+                .map_err(|e: T1::Error| Self::Error::GenericDeserializationError(e.to_string()))?,
+            de.read()
+                .map_err(|e: T2::Error| Self::Error::GenericDeserializationError(e.to_string()))?,
+        ))
+    }
+}
+
 impl<const LENGTH: usize, T: Default + Serializable> Serializable for [T; LENGTH]
 where
     T::Error: From<CryptoCoreError>,

src/error.rs

@@ -26,6 +26,7 @@ pub enum CryptoCoreError {
     EllipticCurveError(String),
     EncryptionError,
     GenericDeserializationError(String),
+    GenericSerializationError(String),
     InvalidBytesLength(String, usize, Option<usize>),
     PlaintextTooBigError {
         plaintext_len: usize,
@@ -91,6 +92,9 @@ impl Display for CryptoCoreError {
             CryptoCoreError::GenericDeserializationError(err) => {
                 write!(f, "deserialization error: {err}")
             }
+            CryptoCoreError::GenericSerializationError(err) => {
+                write!(f, "serialization error: {err}")
+            }
             CryptoCoreError::InvalidBytesLength(message, given, expected) => match expected {
                 Some(expected_length) => write!(
                     f,