serial: Use mutable references for non-async {en,de}code functions

src/blockchain/block_store.rs

@@ -190,25 +190,25 @@ impl BlockRanks {
 // Note: Doing all the imports here as this might get obselete if
 // we implemented Encodable/Decodable for num_bigint::BigUint.
 impl darkfi_serial::Encodable for BlockRanks {
-    fn encode<S: std::io::Write>(&self, mut s: S) -> std::io::Result<usize> {
+    fn encode<S: std::io::Write>(&self, s: &mut S) -> std::io::Result<usize> {
         let mut len = 0;
-        len += self.target_rank.to_bytes_be().encode(&mut s)?;
-        len += self.targets_rank.to_bytes_be().encode(&mut s)?;
-        len += self.hash_rank.to_bytes_be().encode(&mut s)?;
-        len += self.hashes_rank.to_bytes_be().encode(&mut s)?;
+        len += self.target_rank.to_bytes_be().encode(s)?;
+        len += self.targets_rank.to_bytes_be().encode(s)?;
+        len += self.hash_rank.to_bytes_be().encode(s)?;
+        len += self.hashes_rank.to_bytes_be().encode(s)?;
         Ok(len)
     }
 }
 
 impl darkfi_serial::Decodable for BlockRanks {
-    fn decode<D: std::io::Read>(mut d: D) -> std::io::Result<Self> {
-        let bytes: Vec<u8> = darkfi_serial::Decodable::decode(&mut d)?;
+    fn decode<D: std::io::Read>(d: &mut D) -> std::io::Result<Self> {
+        let bytes: Vec<u8> = darkfi_serial::Decodable::decode(d)?;
         let target_rank: BigUint = BigUint::from_bytes_be(&bytes);
-        let bytes: Vec<u8> = darkfi_serial::Decodable::decode(&mut d)?;
+        let bytes: Vec<u8> = darkfi_serial::Decodable::decode(d)?;
         let targets_rank: BigUint = BigUint::from_bytes_be(&bytes);
-        let bytes: Vec<u8> = darkfi_serial::Decodable::decode(&mut d)?;
+        let bytes: Vec<u8> = darkfi_serial::Decodable::decode(d)?;
         let hash_rank: BigUint = BigUint::from_bytes_be(&bytes);
-        let bytes: Vec<u8> = darkfi_serial::Decodable::decode(&mut d)?;
+        let bytes: Vec<u8> = darkfi_serial::Decodable::decode(d)?;
         let hashes_rank: BigUint = BigUint::from_bytes_be(&bytes);
         let ret = Self { target_rank, targets_rank, hash_rank, hashes_rank };
         Ok(ret)
@@ -259,26 +259,26 @@ impl BlockDifficulty {
 // Note: Doing all the imports here as this might get obselete if
 // we implemented Encodable/Decodable for num_bigint::BigUint.
 impl darkfi_serial::Encodable for BlockDifficulty {
-    fn encode<S: std::io::Write>(&self, mut s: S) -> std::io::Result<usize> {
+    fn encode<S: std::io::Write>(&self, s: &mut S) -> std::io::Result<usize> {
         let mut len = 0;
-        len += self.height.encode(&mut s)?;
-        len += self.timestamp.encode(&mut s)?;
-        len += self.difficulty.to_bytes_be().encode(&mut s)?;
-        len += self.cummulative_difficulty.to_bytes_be().encode(&mut s)?;
-        len += self.ranks.encode(&mut s)?;
+        len += self.height.encode(s)?;
+        len += self.timestamp.encode(s)?;
+        len += self.difficulty.to_bytes_be().encode(s)?;
+        len += self.cummulative_difficulty.to_bytes_be().encode(s)?;
+        len += self.ranks.encode(s)?;
         Ok(len)
     }
 }
 
 impl darkfi_serial::Decodable for BlockDifficulty {
-    fn decode<D: std::io::Read>(mut d: D) -> std::io::Result<Self> {
-        let height: u32 = darkfi_serial::Decodable::decode(&mut d)?;
-        let timestamp: Timestamp = darkfi_serial::Decodable::decode(&mut d)?;
-        let bytes: Vec<u8> = darkfi_serial::Decodable::decode(&mut d)?;
+    fn decode<D: std::io::Read>(d: &mut D) -> std::io::Result<Self> {
+        let height: u32 = darkfi_serial::Decodable::decode(d)?;
+        let timestamp: Timestamp = darkfi_serial::Decodable::decode(d)?;
+        let bytes: Vec<u8> = darkfi_serial::Decodable::decode(d)?;
         let difficulty: BigUint = BigUint::from_bytes_be(&bytes);
-        let bytes: Vec<u8> = darkfi_serial::Decodable::decode(&mut d)?;
+        let bytes: Vec<u8> = darkfi_serial::Decodable::decode(d)?;
         let cummulative_difficulty: BigUint = BigUint::from_bytes_be(&bytes);
-        let ranks: BlockRanks = darkfi_serial::Decodable::decode(&mut d)?;
+        let ranks: BlockRanks = darkfi_serial::Decodable::decode(d)?;
         let ret = Self { height, timestamp, difficulty, cummulative_difficulty, ranks };
         Ok(ret)
     }

src/sdk/src/crypto/note.rs

@@ -16,6 +16,8 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
+use std::io::Cursor;
+
 use chacha20poly1305::{AeadInPlace, ChaCha20Poly1305, KeyInit};
 use darkfi_serial::{Decodable, Encodable, SerialDecodable, SerialEncodable};
 use pasta_curves::{group::ff::Field, pallas};
@@ -75,7 +77,10 @@ impl AeadEncryptedNote {
             &[],
             &mut plaintext,
         ) {
-            Ok(()) => Ok(D::decode(&plaintext[..ct_len - AEAD_TAG_SIZE])?),
+            Ok(()) => {
+                let mut cursor = Cursor::new(&plaintext[..ct_len - AEAD_TAG_SIZE]);
+                Ok(D::decode(&mut cursor)?)
+            }
             Err(e) => Err(ContractError::IoError(format!("Note decrypt failed: {}", e))),
         }
     }

src/sdk/src/wasm/util.rs

@@ -178,7 +178,7 @@ pub fn get_tx_location(hash: &TransactionHash) -> GenericResult<(u32, u16)> {
     let ret = unsafe { get_tx_location_(buf.as_ptr()) };
     let loc_data = parse_ret(ret)?.ok_or(ContractError::DbGetFailed)?;
     let mut cursor = Cursor::new(loc_data);
-    Ok((Decodable::decode(&mut cursor)?, Decodable::decode(cursor)?))
+    Ok((Decodable::decode(&mut cursor)?, Decodable::decode(&mut cursor)?))
 }
 
 extern "C" {

src/serial/derive-internal/src/sync_derive.rs

@@ -51,7 +51,7 @@ fn named_fields(
             );
 
             variant_body.extend(quote! {
-                len += #field_ident.encode(&mut s)?;
+                len += #field_ident.encode(s)?;
             })
         }
     }
@@ -94,7 +94,7 @@ fn unnamed_fields(
             );
 
             variant_body.extend(quote! {
-                len += #field_ident.encode(&mut s)?;
+                len += #field_ident.encode(s)?;
             })
         }
     }
@@ -156,7 +156,7 @@ pub fn enum_ser(input: &ItemEnum, cratename: Ident) -> syn::Result<TokenStream>
 
     Ok(quote! {
         impl #impl_generics #cratename::Encodable for #enum_ident #ty_generics #where_clause {
-            fn encode<S: std::io::Write>(&self, mut s: S) -> ::core::result::Result<usize, std::io::Error> {
+            fn encode<S: std::io::Write>(&self, s: &mut S) -> ::core::result::Result<usize, std::io::Error> {
                 let variant_idx: u8 = match self {
                     #all_variants_idx_body
                 };
@@ -210,7 +210,7 @@ pub fn enum_de(input: &ItemEnum, cratename: Ident) -> syn::Result<TokenStream> {
                         );
 
                         variant_header.extend(quote! {
-                            #field_name: #cratename::Decodable::decode(&mut d)?,
+                            #field_name: #cratename::Decodable::decode(d)?,
                         });
                     }
                 }
@@ -230,7 +230,7 @@ pub fn enum_de(input: &ItemEnum, cratename: Ident) -> syn::Result<TokenStream> {
                         );
 
                         variant_header.extend(quote! {
-                            #cratename::Decodable::decode(&mut d)?,
+                            #cratename::Decodable::decode(d)?,
                         });
                     }
                 }
@@ -253,8 +253,8 @@ pub fn enum_de(input: &ItemEnum, cratename: Ident) -> syn::Result<TokenStream> {
 
     Ok(quote! {
     impl #impl_generics #cratename::Decodable for #name #ty_generics #where_clause {
-        fn decode<D: std::io::Read>(mut d: D) -> ::core::result::Result<Self, std::io::Error> {
-            let variant_tag: u8 = #cratename::Decodable::decode(&mut d)?;
+        fn decode<D: std::io::Read>(d: &mut D) -> ::core::result::Result<Self, std::io::Error> {
+            let variant_tag: u8 = #cratename::Decodable::decode(d)?;
 
             let mut return_value =
                 #variant_arms {
@@ -289,7 +289,7 @@ pub fn struct_ser(input: &ItemStruct, cratename: Ident) -> syn::Result<TokenStre
 
                 let field_name = field.ident.as_ref().unwrap();
                 let delta = quote! {
-                    len += self.#field_name.encode(&mut s)?;
+                    len += self.#field_name.encode(s)?;
                 };
                 body.extend(delta);
 
@@ -309,7 +309,7 @@ pub fn struct_ser(input: &ItemStruct, cratename: Ident) -> syn::Result<TokenStre
                     span: Span::call_site(),
                 };
                 let delta = quote! {
-                    len += self.#field_idx.encode(&mut s)?;
+                    len += self.#field_idx.encode(s)?;
                 };
                 body.extend(delta);
             }
@@ -319,7 +319,7 @@ pub fn struct_ser(input: &ItemStruct, cratename: Ident) -> syn::Result<TokenStre
 
     Ok(quote! {
         impl #impl_generics #cratename::Encodable for #name #ty_generics #where_clause {
-            fn encode<S: std::io::Write>(&self, mut s: S) -> ::core::result::Result<usize, std::io::Error> {
+            fn encode<S: std::io::Write>(&self, s: &mut S) -> ::core::result::Result<usize, std::io::Error> {
                 let mut len = 0;
                 #body
                 Ok(len)
@@ -357,7 +357,7 @@ pub fn struct_de(input: &ItemStruct, cratename: Ident) -> syn::Result<TokenStrea
                     );
 
                     quote! {
-                        #field_name: #cratename::Decodable::decode(&mut d)?,
+                        #field_name: #cratename::Decodable::decode(d)?,
                     }
                 };
                 body.extend(delta);
@@ -370,7 +370,7 @@ pub fn struct_de(input: &ItemStruct, cratename: Ident) -> syn::Result<TokenStrea
             let mut body = TokenStream::new();
             for _ in 0..fields.unnamed.len() {
                 let delta = quote! {
-                    #cratename::Decodable::decode(&mut d)?,
+                    #cratename::Decodable::decode(d)?,
                 };
                 body.extend(delta);
             }
@@ -388,7 +388,7 @@ pub fn struct_de(input: &ItemStruct, cratename: Ident) -> syn::Result<TokenStrea
     if let Some(method_ident) = init_method {
         Ok(quote! {
         impl #impl_generics #cratename::Decodable for #name #ty_generics #where_clause {
-            fn decode<D: std::io::Read>(mut d: D) -> ::core::result::Result<Self, std::io::Error> {
+            fn decode<D: std::io::Read>(d: &mut D) -> ::core::result::Result<Self, std::io::Error> {
                 let mut return_value = #return_value;
                 return_value.#method_ident();
                 Ok(return_value)
@@ -398,7 +398,7 @@ pub fn struct_de(input: &ItemStruct, cratename: Ident) -> syn::Result<TokenStrea
     } else {
         Ok(quote! {
             impl #impl_generics #cratename::Decodable for #name #ty_generics #where_clause {
-                fn decode<D: std::io::Read>(mut d: D) -> ::core::result::Result<Self, std::io::Error> {
+                fn decode<D: std::io::Read>(d: &mut D) -> ::core::result::Result<Self, std::io::Error> {
                     Ok(#return_value)
                 }
             }

src/serial/src/lib.rs

@@ -41,12 +41,12 @@ pub trait Encodable {
     /// Encode an object with a well-defined format.
     /// Should only ever error if the underlying `Write` errors.
     /// Returns the number of bytes written on success.
-    fn encode<W: Write>(&self, e: W) -> Result<usize, Error>;
+    fn encode<W: Write>(&self, e: &mut W) -> Result<usize, Error>;
 }
 
 /// Data which can be decoded in a consensus-consistent way.
 pub trait Decodable: Sized {
-    fn decode<D: Read>(d: D) -> Result<Self, Error>;
+    fn decode<D: Read>(d: &mut D) -> Result<Self, Error>;
 }
 
 /// Encode an object into a vector.
@@ -241,14 +241,14 @@ macro_rules! impl_int_encodable {
     ($ty:ident, $meth_dec:ident, $meth_enc:ident) => {
         impl Decodable for $ty {
             #[inline]
-            fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
-                ReadExt::$meth_dec(&mut d).map($ty::from_le)
+            fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
+                ReadExt::$meth_dec(d).map($ty::from_le)
             }
         }
 
         impl Encodable for $ty {
             #[inline]
-            fn encode<S: WriteExt>(&self, mut s: S) -> Result<usize, Error> {
+            fn encode<S: WriteExt>(&self, s: &mut S) -> Result<usize, Error> {
                 s.$meth_enc(self.to_le())?;
                 Ok(core::mem::size_of::<$ty>())
             }
@@ -304,7 +304,7 @@ impl VarInt {
 
 impl Encodable for VarInt {
     #[inline]
-    fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
+    fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
         match self.0 {
             0..=0xFC => {
                 (self.0 as u8).encode(s)?;
@@ -334,11 +334,11 @@ impl Encodable for VarInt {
 
 impl Decodable for VarInt {
     #[inline]
-    fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
-        let n = ReadExt::read_u8(&mut d)?;
+    fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
+        let n = ReadExt::read_u8(d)?;
         match n {
             0xFF => {
-                let x = ReadExt::read_u64(&mut d)?;
+                let x = ReadExt::read_u64(d)?;
                 if x < 0x100000000 {
                     return Err(Error::new(ErrorKind::Other, "Non-minimal VarInt"))
                 }
@@ -346,7 +346,7 @@ impl Decodable for VarInt {
             }
 
             0xFE => {
-                let x = ReadExt::read_u32(&mut d)?;
+                let x = ReadExt::read_u32(d)?;
                 if x < 0x10000 {
                     return Err(Error::new(ErrorKind::Other, "Non-minimal VarInt"))
                 }
@@ -354,7 +354,7 @@ impl Decodable for VarInt {
             }
 
             0xFD => {
-                let x = ReadExt::read_u16(&mut d)?;
+                let x = ReadExt::read_u16(d)?;
                 if x < 0xFD {
                     return Err(Error::new(ErrorKind::Other, "Non-minimal VarInt"))
                 }
@@ -371,10 +371,10 @@ macro_rules! tuple_encode {
         impl<$($x: Encodable),*> Encodable for ($($x),*) {
             #[inline]
             #[allow(non_snake_case)]
-            fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
+            fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
                 let &($(ref $x),*) = self;
                 let mut len = 0;
-                $(len += $x.encode(&mut s)?;)*
+                $(len += $x.encode(s)?;)*
                 Ok(len)
             }
         }
@@ -382,8 +382,8 @@ macro_rules! tuple_encode {
         impl<$($x: Decodable),*> Decodable for ($($x),*) {
             #[inline]
             #[allow(non_snake_case)]
-            fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
-                Ok(($({let $x = Decodable::decode(&mut d)?; $x }),*))
+            fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
+                Ok(($({let $x = Decodable::decode(d)?; $x }),*))
             }
         }
     )
@@ -406,7 +406,7 @@ macro_rules! encode_payload {
 // Implementations for some primitive types.
 impl Encodable for usize {
     #[inline]
-    fn encode<S: WriteExt>(&self, mut s: S) -> Result<usize, Error> {
+    fn encode<S: WriteExt>(&self, s: &mut S) -> Result<usize, Error> {
         s.write_u64(*self as u64)?;
         Ok(8)
     }
@@ -414,14 +414,14 @@ impl Encodable for usize {
 
 impl Decodable for usize {
     #[inline]
-    fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
-        Ok(ReadExt::read_u64(&mut d)? as usize)
+    fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
+        Ok(ReadExt::read_u64(d)? as usize)
     }
 }
 
 impl Encodable for f64 {
     #[inline]
-    fn encode<S: WriteExt>(&self, mut s: S) -> Result<usize, Error> {
+    fn encode<S: WriteExt>(&self, s: &mut S) -> Result<usize, Error> {
         s.write_f64(*self)?;
         Ok(core::mem::size_of::<f64>())
     }
@@ -429,14 +429,14 @@ impl Encodable for f64 {
 
 impl Decodable for f64 {
     #[inline]
-    fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
-        ReadExt::read_f64(&mut d)
+    fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
+        ReadExt::read_f64(d)
     }
 }
 
 impl Encodable for f32 {
     #[inline]
-    fn encode<S: WriteExt>(&self, mut s: S) -> Result<usize, Error> {
+    fn encode<S: WriteExt>(&self, s: &mut S) -> Result<usize, Error> {
         s.write_f32(*self)?;
         Ok(core::mem::size_of::<f32>())
     }
@@ -444,14 +444,14 @@ impl Encodable for f32 {
 
 impl Decodable for f32 {
     #[inline]
-    fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
-        ReadExt::read_f32(&mut d)
+    fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
+        ReadExt::read_f32(d)
     }
 }
 
 impl Encodable for bool {
     #[inline]
-    fn encode<S: WriteExt>(&self, mut s: S) -> Result<usize, Error> {
+    fn encode<S: WriteExt>(&self, s: &mut S) -> Result<usize, Error> {
         s.write_bool(*self)?;
         Ok(1)
     }
@@ -459,18 +459,18 @@ impl Encodable for bool {
 
 impl Decodable for bool {
     #[inline]
-    fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
-        ReadExt::read_bool(&mut d)
+    fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
+        ReadExt::read_bool(d)
     }
 }
 
 impl<T: Encodable> Encodable for Vec<T> {
     #[inline]
-    fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
+    fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
         let mut len = 0;
-        len += VarInt(self.len() as u64).encode(&mut s)?;
+        len += VarInt(self.len() as u64).encode(s)?;
         for val in self {
-            len += val.encode(&mut s)?;
+            len += val.encode(s)?;
         }
         Ok(len)
     }
@@ -478,12 +478,12 @@ impl<T: Encodable> Encodable for Vec<T> {
 
 impl<T: Decodable> Decodable for Vec<T> {
     #[inline]
-    fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
-        let len = VarInt::decode(&mut d)?.0;
+    fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
+        let len = VarInt::decode(d)?.0;
         let mut ret = Vec::new();
         ret.try_reserve(len as usize).map_err(|_| std::io::ErrorKind::InvalidData)?;
         for _ in 0..len {
-            ret.push(Decodable::decode(&mut d)?);
+            ret.push(Decodable::decode(d)?);
         }
         Ok(ret)
     }
@@ -491,11 +491,11 @@ impl<T: Decodable> Decodable for Vec<T> {
 
 impl<T: Encodable> Encodable for VecDeque<T> {
     #[inline]
-    fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
+    fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
         let mut len = 0;
-        len += VarInt(self.len() as u64).encode(&mut s)?;
+        len += VarInt(self.len() as u64).encode(s)?;
         for val in self {
-            len += val.encode(&mut s)?;
+            len += val.encode(s)?;
         }
         Ok(len)
     }
@@ -503,34 +503,34 @@ impl<T: Encodable> Encodable for VecDeque<T> {
 
 impl<T: Decodable> Decodable for VecDeque<T> {
     #[inline]
-    fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
-        let len = VarInt::decode(&mut d)?.0;
+    fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
+        let len = VarInt::decode(d)?.0;
         let mut ret = VecDeque::new();
         ret.try_reserve(len as usize).map_err(|_| std::io::ErrorKind::InvalidData)?;
         for _ in 0..len {
-            ret.push_back(Decodable::decode(&mut d)?);
+            ret.push_back(Decodable::decode(d)?);
         }
         Ok(ret)
     }
 }
 
 impl<T: Encodable> Encodable for Option<T> {
-    fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
+    fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
         let mut len = 0;
         if let Some(v) = self {
-            len += true.encode(&mut s)?;
-            len += v.encode(&mut s)?;
+            len += true.encode(s)?;
+            len += v.encode(s)?;
         } else {
-            len += false.encode(&mut s)?;
+            len += false.encode(s)?;
         }
         Ok(len)
     }
 }
 
 impl<T: Decodable> Decodable for Option<T> {
-    fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
-        let valid: bool = Decodable::decode(&mut d)?;
-        let val = if valid { Some(Decodable::decode(&mut d)?) } else { None };
+    fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
+        let valid: bool = Decodable::decode(d)?;
+        let val = if valid { Some(Decodable::decode(d)?) } else { None };
         Ok(val)
     }
 }
@@ -540,10 +540,10 @@ where
     T: Encodable,
 {
     #[inline]
-    fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
+    fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
         let mut len = 0;
         for elem in self.iter() {
-            len += elem.encode(&mut s)?;
+            len += elem.encode(s)?;
         }
         Ok(len)
     }
@@ -554,10 +554,10 @@ where
     T: Decodable + core::fmt::Debug,
 {
     #[inline]
-    fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
+    fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
         let mut ret = vec![];
         for _ in 0..N {
-            ret.push(Decodable::decode(&mut d)?);
+            ret.push(Decodable::decode(d)?);
         }
 
         Ok(ret.try_into().unwrap())
@@ -566,10 +566,10 @@ where
 
 impl Encodable for String {
     #[inline]
-    fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
+    fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
         let b = self.as_bytes();
         let b_len = b.len();
-        let vi_len = VarInt(b_len as u64).encode(&mut s)?;
+        let vi_len = VarInt(b_len as u64).encode(s)?;
         s.write_slice(b)?;
         Ok(vi_len + b_len)
     }
@@ -577,10 +577,10 @@ impl Encodable for String {
 
 impl Encodable for &str {
     #[inline]
-    fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
+    fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
         let b = self.as_bytes();
         let b_len = b.len();
-        let vi_len = VarInt(b_len as u64).encode(&mut s)?;
+        let vi_len = VarInt(b_len as u64).encode(s)?;
         s.write_slice(b)?;
         Ok(vi_len + b_len)
     }
@@ -588,7 +588,7 @@ impl Encodable for &str {
 
 impl Decodable for String {
     #[inline]
-    fn decode<D: Read>(d: D) -> Result<String, Error> {
+    fn decode<D: Read>(d: &mut D) -> Result<String, Error> {
         match String::from_utf8(Decodable::decode(d)?) {
             Ok(v) => Ok(v),
             Err(_) => Err(Error::new(ErrorKind::Other, "Invalid UTF-8 for string")),

src/serial/src/types/bridgetree.rs

@@ -29,8 +29,8 @@ use futures_lite::{AsyncRead, AsyncWrite};
 use crate::{Decodable, Encodable};
 
 impl Encodable for bridgetree::Position {
-    fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
-        u64::from(*self).encode(&mut s)
+    fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
+        u64::from(*self).encode(s)
     }
 }
 
@@ -43,8 +43,8 @@ impl AsyncEncodable for bridgetree::Position {
 }
 
 impl Decodable for bridgetree::Position {
-    fn decode<D: Read>(mut d: D) -> Result<Self> {
-        let dec: u64 = Decodable::decode(&mut d)?;
+    fn decode<D: Read>(d: &mut D) -> Result<Self> {
+        let dec: u64 = Decodable::decode(d)?;
         Ok(Self::from(dec))
     }
 }
@@ -59,10 +59,10 @@ impl AsyncDecodable for bridgetree::Position {
 }
 
 impl Encodable for bridgetree::Address {
-    fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
+    fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
         let mut len = 0;
-        len += u8::from(self.level()).encode(&mut s)?;
-        len += self.index().encode(&mut s)?;
+        len += u8::from(self.level()).encode(s)?;
+        len += self.index().encode(s)?;
         Ok(len)
     }
 }
@@ -79,9 +79,9 @@ impl AsyncEncodable for bridgetree::Address {
 }
 
 impl Decodable for bridgetree::Address {
-    fn decode<D: Read>(mut d: D) -> Result<Self> {
-        let level: u8 = Decodable::decode(&mut d)?;
-        let index = Decodable::decode(&mut d)?;
+    fn decode<D: Read>(d: &mut D) -> Result<Self> {
+        let level: u8 = Decodable::decode(d)?;
+        let index = Decodable::decode(d)?;
         Ok(Self::from_parts(level.into(), index))
     }
 }
@@ -97,11 +97,11 @@ impl AsyncDecodable for bridgetree::Address {
 }
 
 impl<H: Encodable + Ord + Clone> Encodable for bridgetree::NonEmptyFrontier<H> {
-    fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
+    fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
         let mut len = 0;
-        len += self.position().encode(&mut s)?;
-        len += self.leaf().encode(&mut s)?;
-        len += self.ommers().to_vec().encode(&mut s)?;
+        len += self.position().encode(s)?;
+        len += self.leaf().encode(s)?;
+        len += self.ommers().to_vec().encode(s)?;
         Ok(len)
     }
 }
@@ -121,10 +121,10 @@ impl<H: AsyncEncodable + Sync + Send + Ord + Clone> AsyncEncodable
 }
 
 impl<H: Decodable + Ord + Clone> Decodable for bridgetree::NonEmptyFrontier<H> {
-    fn decode<D: Read>(mut d: D) -> Result<Self> {
-        let position = Decodable::decode(&mut d)?;
-        let leaf = Decodable::decode(&mut d)?;
-        let ommers = Decodable::decode(&mut d)?;
+    fn decode<D: Read>(d: &mut D) -> Result<Self> {
+        let position = Decodable::decode(d)?;
+        let leaf = Decodable::decode(d)?;
+        let ommers = Decodable::decode(d)?;
 
         match Self::from_parts(position, leaf, ommers) {
             Ok(v) => Ok(v),
@@ -149,12 +149,12 @@ impl<H: AsyncDecodable + Send + Ord + Clone> AsyncDecodable for bridgetree::NonE
 }
 
 impl<H: Encodable + Ord + Clone> Encodable for bridgetree::MerkleBridge<H> {
-    fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
+    fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
         let mut len = 0;
-        len += self.prior_position().encode(&mut s)?;
-        len += self.tracking().encode(&mut s)?;
-        len += self.ommers().encode(&mut s)?;
-        len += self.frontier().encode(&mut s)?;
+        len += self.prior_position().encode(s)?;
+        len += self.tracking().encode(s)?;
+        len += self.ommers().encode(s)?;
+        len += self.frontier().encode(s)?;
         Ok(len)
     }
 }
@@ -173,11 +173,11 @@ impl<H: AsyncEncodable + Sync + Send + Ord + Clone> AsyncEncodable for bridgetre
 }
 
 impl<H: Decodable + Ord + Clone> Decodable for bridgetree::MerkleBridge<H> {
-    fn decode<D: Read>(mut d: D) -> Result<Self> {
-        let prior_position = Decodable::decode(&mut d)?;
-        let tracking = Decodable::decode(&mut d)?;
-        let ommers = Decodable::decode(&mut d)?;
-        let frontier = Decodable::decode(&mut d)?;
+    fn decode<D: Read>(d: &mut D) -> Result<Self> {
+        let prior_position = Decodable::decode(d)?;
+        let tracking = Decodable::decode(d)?;
+        let ommers = Decodable::decode(d)?;
+        let frontier = Decodable::decode(d)?;
         Ok(Self::from_parts(prior_position, tracking, ommers, frontier))
     }
 }
@@ -195,12 +195,12 @@ impl<H: AsyncDecodable + Send + Ord + Clone> AsyncDecodable for bridgetree::Merk
 }
 
 impl<C: Encodable> Encodable for bridgetree::Checkpoint<C> {
-    fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
+    fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
         let mut len = 0;
-        len += self.id().encode(&mut s)?;
-        len += self.bridges_len().encode(&mut s)?;
-        len += self.marked().encode(&mut s)?;
-        len += self.forgotten().encode(&mut s)?;
+        len += self.id().encode(s)?;
+        len += self.bridges_len().encode(s)?;
+        len += self.marked().encode(s)?;
+        len += self.forgotten().encode(s)?;
         Ok(len)
     }
 }
@@ -219,11 +219,11 @@ impl<C: AsyncEncodable + Sync> AsyncEncodable for bridgetree::Checkpoint<C> {
 }
 
 impl<C: Decodable> Decodable for bridgetree::Checkpoint<C> {
-    fn decode<D: Read>(mut d: D) -> Result<Self> {
-        let id = Decodable::decode(&mut d)?;
-        let bridges_len = Decodable::decode(&mut d)?;
-        let marked = Decodable::decode(&mut d)?;
-        let forgotten = Decodable::decode(&mut d)?;
+    fn decode<D: Read>(d: &mut D) -> Result<Self> {
+        let id = Decodable::decode(d)?;
+        let bridges_len = Decodable::decode(d)?;
+        let marked = Decodable::decode(d)?;
+        let forgotten = Decodable::decode(d)?;
         Ok(Self::from_parts(id, bridges_len, marked, forgotten))
     }
 }
@@ -243,13 +243,13 @@ impl<C: AsyncDecodable + Send> AsyncDecodable for bridgetree::Checkpoint<C> {
 impl<H: Encodable + Ord + Clone, C: Encodable + Debug, const DEPTH: u8> Encodable
     for bridgetree::BridgeTree<H, C, DEPTH>
 {
-    fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
+    fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
         let mut len = 0;
-        len += self.prior_bridges().to_vec().encode(&mut s)?;
-        len += self.current_bridge().encode(&mut s)?;
-        len += self.marked_indices().encode(&mut s)?;
-        len += self.checkpoints().encode(&mut s)?;
-        len += self.max_checkpoints().encode(&mut s)?;
+        len += self.prior_bridges().to_vec().encode(s)?;
+        len += self.current_bridge().encode(s)?;
+        len += self.marked_indices().encode(s)?;
+        len += self.checkpoints().encode(s)?;
+        len += self.max_checkpoints().encode(s)?;
         Ok(len)
     }
 }
@@ -279,12 +279,12 @@ impl<
         const DEPTH: u8,
     > Decodable for bridgetree::BridgeTree<H, C, DEPTH>
 {
-    fn decode<D: Read>(mut d: D) -> Result<Self> {
-        let prior_bridges = Decodable::decode(&mut d)?;
-        let current_bridge = Decodable::decode(&mut d)?;
-        let saved = Decodable::decode(&mut d)?;
-        let checkpoints = Decodable::decode(&mut d)?;
-        let max_checkpoints = Decodable::decode(&mut d)?;
+    fn decode<D: Read>(d: &mut D) -> Result<Self> {
+        let prior_bridges = Decodable::decode(d)?;
+        let current_bridge = Decodable::decode(d)?;
+        let saved = Decodable::decode(d)?;
+        let checkpoints = Decodable::decode(d)?;
+        let max_checkpoints = Decodable::decode(d)?;
         match Self::from_parts(prior_bridges, current_bridge, saved, checkpoints, max_checkpoints) {
             Ok(v) => Ok(v),
             Err(_) => Err(Error::new(ErrorKind::Other, "BridgeTreeError")),

src/serial/src/types/collections.rs

@@ -32,11 +32,11 @@ use futures_lite::{AsyncRead, AsyncWrite};
 use crate::{Decodable, Encodable, VarInt};
 
 impl<T: Encodable> Encodable for HashSet<T> {
-    fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
+    fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
         let mut len = 0;
-        len += VarInt(self.len() as u64).encode(&mut s)?;
+        len += VarInt(self.len() as u64).encode(s)?;
         for c in self.iter() {
-            len += c.encode(&mut s)?;
+            len += c.encode(s)?;
         }
         Ok(len)
     }
@@ -56,11 +56,11 @@ impl<T: AsyncEncodable + Sync> AsyncEncodable for HashSet<T> {
 }
 
 impl<T: Decodable + std::cmp::Eq + std::hash::Hash> Decodable for HashSet<T> {
-    fn decode<D: Read>(mut d: D) -> Result<Self> {
-        let len = VarInt::decode(&mut d)?.0;
+    fn decode<D: Read>(d: &mut D) -> Result<Self> {
+        let len = VarInt::decode(d)?.0;
         let mut ret = HashSet::new();
         for _ in 0..len {
-            let entry: T = Decodable::decode(&mut d)?;
+            let entry: T = Decodable::decode(d)?;
             ret.insert(entry);
         }
         Ok(ret)
@@ -82,12 +82,12 @@ impl<T: AsyncDecodable + Send + std::cmp::Eq + std::hash::Hash> AsyncDecodable f
 }
 
 impl<T: Encodable, U: Encodable> Encodable for BTreeMap<T, U> {
-    fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
+    fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
         let mut len = 0;
-        len += VarInt(self.len() as u64).encode(&mut s)?;
+        len += VarInt(self.len() as u64).encode(s)?;
         for c in self.iter() {
-            len += c.0.encode(&mut s)?;
-            len += c.1.encode(&mut s)?;
+            len += c.0.encode(s)?;
+            len += c.1.encode(s)?;
         }
         Ok(len)
     }
@@ -108,12 +108,12 @@ impl<T: AsyncEncodable + Sync, U: AsyncEncodable + Sync> AsyncEncodable for BTre
 }
 
 impl<T: Decodable + std::cmp::Ord, U: Decodable> Decodable for BTreeMap<T, U> {
-    fn decode<D: Read>(mut d: D) -> Result<Self> {
-        let len = VarInt::decode(&mut d)?.0;
+    fn decode<D: Read>(d: &mut D) -> Result<Self> {
+        let len = VarInt::decode(d)?.0;
         let mut ret = BTreeMap::new();
         for _ in 0..len {
-            let key: T = Decodable::decode(&mut d)?;
-            let entry: U = Decodable::decode(&mut d)?;
+            let key: T = Decodable::decode(d)?;
+            let entry: U = Decodable::decode(d)?;
             ret.insert(key, entry);
         }
         Ok(ret)
@@ -138,11 +138,11 @@ impl<T: AsyncDecodable + Send + std::cmp::Ord, U: AsyncDecodable + Send> AsyncDe
 }
 
 impl<T: Encodable> Encodable for BTreeSet<T> {
-    fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
+    fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
         let mut len = 0;
-        len += VarInt(self.len() as u64).encode(&mut s)?;
+        len += VarInt(self.len() as u64).encode(s)?;
         for c in self.iter() {
-            len += c.encode(&mut s)?;
+            len += c.encode(s)?;
         }
         Ok(len)
     }
@@ -162,11 +162,11 @@ impl<T: AsyncEncodable + Sync> AsyncEncodable for BTreeSet<T> {
 }
 
 impl<T: Decodable + std::cmp::Ord> Decodable for BTreeSet<T> {
-    fn decode<D: Read>(mut d: D) -> Result<Self> {
-        let len = VarInt::decode(&mut d)?.0;
+    fn decode<D: Read>(d: &mut D) -> Result<Self> {
+        let len = VarInt::decode(d)?.0;
         let mut ret = BTreeSet::new();
         for _ in 0..len {
-            let key: T = Decodable::decode(&mut d)?;
+            let key: T = Decodable::decode(d)?;
             ret.insert(key);
         }
         Ok(ret)
@@ -188,12 +188,12 @@ impl<T: AsyncDecodable + Send + std::cmp::Ord> AsyncDecodable for BTreeSet<T> {
 }
 
 impl<T: Encodable, U: Encodable> Encodable for HashMap<T, U> {
-    fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
+    fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
         let mut len = 0;
-        len += VarInt(self.len() as u64).encode(&mut s)?;
+        len += VarInt(self.len() as u64).encode(s)?;
         for c in self.iter() {
-            len += c.0.encode(&mut s)?;
-            len += c.1.encode(&mut s)?;
+            len += c.0.encode(s)?;
+            len += c.1.encode(s)?;
         }
         Ok(len)
     }
@@ -214,12 +214,12 @@ impl<T: AsyncEncodable + Sync, U: AsyncEncodable + Sync> AsyncEncodable for Hash
 }
 
 impl<T: Decodable + std::cmp::Eq + std::hash::Hash, U: Decodable> Decodable for HashMap<T, U> {
-    fn decode<D: Read>(mut d: D) -> Result<Self> {
-        let len = VarInt::decode(&mut d)?.0;
+    fn decode<D: Read>(d: &mut D) -> Result<Self> {
+        let len = VarInt::decode(d)?.0;
         let mut ret = HashMap::new();
         for _ in 0..len {
-            let key: T = Decodable::decode(&mut d)?;
-            let entry: U = Decodable::decode(&mut d)?;
+            let key: T = Decodable::decode(d)?;
+            let entry: U = Decodable::decode(d)?;
             ret.insert(key, entry);
         }
         Ok(ret)

src/serial/src/types/hash.rs

@@ -28,7 +28,7 @@ use crate::{Decodable, Encodable, ReadExt, WriteExt};
 
 #[cfg(feature = "blake3")]
 impl Encodable for blake3::Hash {
-    fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
+    fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
         s.write_slice(self.as_bytes())?;
         Ok(blake3::OUT_LEN)
     }
@@ -45,7 +45,7 @@ impl AsyncEncodable for blake3::Hash {
 
 #[cfg(feature = "blake3")]
 impl Decodable for blake3::Hash {
-    fn decode<D: Read>(mut d: D) -> Result<Self> {
+    fn decode<D: Read>(d: &mut D) -> Result<Self> {
         let mut bytes = [0u8; blake3::OUT_LEN];
         d.read_slice(&mut bytes)?;
         Ok(bytes.into())

src/serial/src/types/pasta.rs

@@ -37,7 +37,7 @@ use pasta_curves::{
 use crate::{Decodable, Encodable, ReadExt, WriteExt};
 
 impl Encodable for Fp {
-    fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
+    fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
         s.write_slice(&self.to_repr())?;
         Ok(32)
     }
@@ -53,7 +53,7 @@ impl AsyncEncodable for Fp {
 }
 
 impl Decodable for Fp {
-    fn decode<D: Read>(mut d: D) -> Result<Self> {
+    fn decode<D: Read>(d: &mut D) -> Result<Self> {
         let mut bytes = [0u8; 32];
         d.read_slice(&mut bytes)?;
         match Self::from_repr(bytes).into() {
@@ -76,7 +76,7 @@ impl AsyncDecodable for Fp {
 }
 
 impl Encodable for Fq {
-    fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
+    fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
         s.write_slice(&self.to_repr())?;
         Ok(32)
     }
@@ -92,7 +92,7 @@ impl AsyncEncodable for Fq {
 }
 
 impl Decodable for Fq {
-    fn decode<D: Read>(mut d: D) -> Result<Self> {
+    fn decode<D: Read>(d: &mut D) -> Result<Self> {
         let mut bytes = [0u8; 32];
         d.read_slice(&mut bytes)?;
         match Self::from_repr(bytes).into() {
@@ -116,7 +116,7 @@ impl AsyncDecodable for Fq {
 }
 
 impl Encodable for Ep {
-    fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
+    fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
         s.write_slice(&self.to_bytes())?;
         Ok(32)
     }
@@ -132,7 +132,7 @@ impl AsyncEncodable for Ep {
 }
 
 impl Decodable for Ep {
-    fn decode<D: Read>(mut d: D) -> Result<Self> {
+    fn decode<D: Read>(d: &mut D) -> Result<Self> {
         let mut bytes = [0u8; 32];
         d.read_slice(&mut bytes)?;
         match Self::from_bytes(&bytes).into() {
@@ -156,7 +156,7 @@ impl AsyncDecodable for Ep {
 }
 
 impl Encodable for Eq {
-    fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
+    fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
         s.write_slice(&self.to_bytes())?;
         Ok(32)
     }
@@ -172,7 +172,7 @@ impl AsyncEncodable for Eq {
 }
 
 impl Decodable for Eq {
-    fn decode<D: Read>(mut d: D) -> Result<Self> {
+    fn decode<D: Read>(d: &mut D) -> Result<Self> {
         let mut bytes = [0u8; 32];
         d.read_slice(&mut bytes)?;
         match Self::from_bytes(&bytes).into() {

src/serial/src/types/semver.rs

@@ -28,8 +28,8 @@ use futures_lite::{AsyncRead, AsyncWrite};
 use crate::{Decodable, Encodable};
 
 impl Encodable for semver::Prerelease {
-    fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
-        self.as_str().encode(&mut s)
+    fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
+        self.as_str().encode(s)
     }
 }
 
@@ -42,8 +42,8 @@ impl AsyncEncodable for semver::Prerelease {
 }
 
 impl Decodable for semver::Prerelease {
-    fn decode<D: Read>(mut d: D) -> Result<Self> {
-        let s: String = Decodable::decode(&mut d)?;
+    fn decode<D: Read>(d: &mut D) -> Result<Self> {
+        let s: String = Decodable::decode(d)?;
 
         match Self::new(&s) {
             Ok(v) => Ok(v),
@@ -66,8 +66,8 @@ impl AsyncDecodable for semver::Prerelease {
 }
 
 impl Encodable for semver::BuildMetadata {
-    fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
-        self.as_str().encode(&mut s)
+    fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
+        self.as_str().encode(s)
     }
 }
 
@@ -80,8 +80,8 @@ impl AsyncEncodable for semver::BuildMetadata {
 }
 
 impl Decodable for semver::BuildMetadata {
-    fn decode<D: Read>(mut d: D) -> Result<Self> {
-        let s: String = Decodable::decode(&mut d)?;
+    fn decode<D: Read>(d: &mut D) -> Result<Self> {
+        let s: String = Decodable::decode(d)?;
 
         match Self::new(&s) {
             Ok(v) => Ok(v),
@@ -108,13 +108,13 @@ impl AsyncDecodable for semver::BuildMetadata {
 }
 
 impl Encodable for semver::Version {
-    fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
+    fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
         let mut len = 0;
-        len += self.major.encode(&mut s)?;
-        len += self.minor.encode(&mut s)?;
-        len += self.patch.encode(&mut s)?;
-        len += self.pre.encode(&mut s)?;
-        len += self.build.encode(&mut s)?;
+        len += self.major.encode(s)?;
+        len += self.minor.encode(s)?;
+        len += self.patch.encode(s)?;
+        len += self.pre.encode(s)?;
+        len += self.build.encode(s)?;
         Ok(len)
     }
 }
@@ -134,12 +134,12 @@ impl AsyncEncodable for semver::Version {
 }
 
 impl Decodable for semver::Version {
-    fn decode<D: Read>(mut d: D) -> Result<Self> {
-        let major: u64 = Decodable::decode(&mut d)?;
-        let minor: u64 = Decodable::decode(&mut d)?;
-        let patch: u64 = Decodable::decode(&mut d)?;
-        let pre: semver::Prerelease = Decodable::decode(&mut d)?;
-        let build: semver::BuildMetadata = Decodable::decode(&mut d)?;
+    fn decode<D: Read>(d: &mut D) -> Result<Self> {
+        let major: u64 = Decodable::decode(d)?;
+        let minor: u64 = Decodable::decode(d)?;
+        let patch: u64 = Decodable::decode(d)?;
+        let pre: semver::Prerelease = Decodable::decode(d)?;
+        let build: semver::BuildMetadata = Decodable::decode(d)?;
         Ok(Self { major, minor, patch, pre, build })
     }
 }

src/serial/src/types/url.rs

@@ -29,7 +29,7 @@ use futures_lite::{AsyncRead, AsyncWrite};
 use crate::{Decodable, Encodable};
 
 impl Encodable for Url {
-    fn encode<S: Write>(&self, s: S) -> Result<usize> {
+    fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
         self.as_str().encode(s)
     }
 }
@@ -43,8 +43,8 @@ impl AsyncEncodable for Url {
 }
 
 impl Decodable for Url {
-    fn decode<D: Read>(mut d: D) -> Result<Self> {
-        let s: String = Decodable::decode(&mut d)?;
+    fn decode<D: Read>(d: &mut D) -> Result<Self> {
+        let s: String = Decodable::decode(d)?;
         match Url::parse(&s) {
             Ok(v) => Ok(v),
             Err(e) => Err(Error::new(ErrorKind::Other, e)),