Add support for new dehydrated device format

src/lib.rs

@@ -232,7 +232,6 @@ pub enum PickleError {
 
 /// Error type describing the various ways libolm pickles can fail to be
 /// decoded.
-#[cfg(feature = "libolm-compat")]
 #[derive(Debug, thiserror::Error)]
 pub enum LibolmPickleError {
     /// The pickle is missing a valid version.
@@ -262,6 +261,55 @@ pub enum LibolmPickleError {
     Encode(#[from] matrix_pickle::EncodeError),
 }
 
+/// Error type describing the various ways dehydrated devices can fail to be
+/// decoded.
+#[derive(Debug, thiserror::Error)]
+pub enum DehydratedDeviceError {
+    /// The pickle is missing a valid version.
+    #[error("The pickle doesn't contain a version")]
+    MissingVersion,
+    /// The pickle has a unsupported version.
+    #[error("The pickle uses an unsupported version, expected {0}, got {1}")]
+    Version(u32, u32),
+    /// Invalid nonce.
+    #[error("The nonce was invalid")]
+    InvalidNonce,
+    /// The pickle wasn't valid base64.
+    #[error("The pickle wasn't valid base64: {0}")]
+    Base64(#[from] Base64DecodeError),
+    /// The pickle could not have been decrypted.
+    #[error("The pickle couldn't be decrypted: {0}")]
+    Decryption(chacha20poly1305::aead::Error),
+    /// The pickle contains an invalid public key.
+    #[error("The pickle contained an invalid ed25519 public key {0}")]
+    PublicKey(#[from] KeyError),
+    /// The payload of the pickle could not be decoded.
+    #[error(transparent)]
+    Decode(#[from] matrix_pickle::DecodeError),
+    /// The object could not be encoded as a pickle.
+    #[error(transparent)]
+    Encode(#[from] matrix_pickle::EncodeError),
+}
+
+impl From<LibolmPickleError> for DehydratedDeviceError {
+    fn from(err: LibolmPickleError) -> Self {
+        match err {
+            LibolmPickleError::PublicKey(e) => Self::PublicKey(e),
+            LibolmPickleError::Decode(e) => Self::Decode(e),
+            LibolmPickleError::Encode(e) => Self::Encode(e),
+            // Any other errors should not happen when we're dealing with
+            // dehydrated devices.
+            _ => panic!("Unexpected libolm pickle error {}", err),
+        }
+    }
+}
+
+impl From<chacha20poly1305::aead::Error> for DehydratedDeviceError {
+    fn from(error: chacha20poly1305::aead::Error) -> Self {
+        Self::Decryption(error)
+    }
+}
+
 /// Error type describing the different ways message decoding can fail.
 #[derive(Debug, thiserror::Error)]
 pub enum DecodeError {