Blanket implementation for DomainType

proto-derive/src/lib.rs

@@ -55,41 +55,9 @@ fn expand_domaintype(input: &syn::DeriveInput) -> TokenStream {
         }
     };
 
+    // This is what all the hubbub is about.
     let gen = quote! {
-        impl ::tendermint_proto::DomainType<#rawtype> for #ident {
-
-            fn encode<B: ::tendermint_proto::bytes::BufMut>(self, buf: &mut B) -> ::std::result::Result<(), ::tendermint_proto::Error> {
-                use ::tendermint_proto::prost::Message;
-                #rawtype::from(self).encode(buf).map_err(|e| ::tendermint_proto::Kind::EncodeMessage.context(e).into())
-            }
-
-            fn encode_length_delimited<B: ::tendermint_proto::bytes::BufMut>(self, buf: &mut B) -> ::std::result::Result<(), ::tendermint_proto::Error> {
-                use ::tendermint_proto::prost::Message;
-                #rawtype::from(self).encode_length_delimited(buf).map_err(|e| ::tendermint_proto::Kind::EncodeMessage.context(e).into())
-            }
-
-            fn decode<B: ::tendermint_proto::bytes::Buf>(buf: B) -> Result<Self, ::tendermint_proto::Error> {
-                use ::tendermint_proto::prost::Message;
-                #rawtype::decode(buf).map_or_else(
-                    |e| ::std::result::Result::Err(::tendermint_proto::Kind::DecodeMessage.context(e).into()),
-                    |t| Self::try_from(t).map_err(|e| ::tendermint_proto::Kind::TryIntoDomainType.context(e).into())
-                )
-            }
-
-            fn decode_length_delimited<B: ::tendermint_proto::bytes::Buf>(buf: B) -> Result<Self, ::tendermint_proto::Error> {
-                use ::tendermint_proto::prost::Message;
-                #rawtype::decode_length_delimited(buf).map_or_else(
-                    |e| ::std::result::Result::Err(::tendermint_proto::Kind::DecodeMessage.context(e).into()),
-                    |t| Self::try_from(t).map_err(|e| ::tendermint_proto::Kind::TryIntoDomainType.context(e).into())
-                )
-            }
-
-            fn encoded_len(self) -> usize {
-                use ::tendermint_proto::prost::Message;
-                #rawtype::from(self).encoded_len()
-            }
-
-        }
+        impl ::tendermint_proto::DomainType<#rawtype> for #ident {}
     };
     gen.into()
 }

proto/src/domaintype.rs

@@ -33,6 +33,13 @@
 //! Note that the Prost library and the TryFrom method have their own set of errors. These are
 //! merged into a custom Error type defined in this crate for easier handling.
 //!
+//! Requirements:
+//! * The DomainType trait requires the struct to implement the Clone trait.
+//! * The DomainType trait requires the struct to have a #[rawtype(MYRAWTYPE)] attribute set where
+//!   the MYRAWTYPE is a structure that has the prost::Message trait implemented. (protobuf type)
+//! * The DomainType trait requires that the TryFrom<RawType> implemented on the structure has an
+//!   error type that implements Into<BoxError>. (The current implementations with anomaly are
+//!   fine.)
 //!
 //! How to implement a DomainType struct:
 //! 1. Implement your struct based on your expectations for the developer
@@ -43,37 +50,95 @@
 //!
 //! Note: the `[rawtype()]` parameter is similar to how `serde` implements serialization through a
 //! `[serde(with="")]` interim type.
-//!
 
-use crate::Error;
+use crate::{Error, Kind};
+use anomaly::BoxError;
 use bytes::{Buf, BufMut};
-use prost::Message;
+use prost::{encoding::encoded_len_varint, Message};
+use std::convert::{TryFrom, TryInto};
 
 /// DomainType trait allows protobuf encoding and decoding for domain types
-pub trait DomainType<T: Message + From<Self>>: Sized {
+pub trait DomainType<T: Message + From<Self> + Default>
+where
+    Self: Sized + Clone + TryFrom<T>,
+    <Self as TryFrom<T>>::Error: Into<BoxError>,
+{
     /// Encodes the DomainType into a buffer.
     ///
-    /// The DomainType will be consumed.
-    fn encode<B: BufMut>(self, buf: &mut B) -> Result<(), Error>;
+    /// This function replaces the Prost::Message encode() function for DomainTypes.
+    fn encode<B: BufMut>(&self, buf: &mut B) -> Result<(), Error> {
+        T::from(self.clone())
+            .encode(buf)
+            .map_err(|e| Kind::EncodeMessage.context(e).into())
+    }
 
     /// Encodes the DomainType with a length-delimiter to a buffer.
     ///
-    /// The DomainType will be consumed.
     /// An error will be returned if the buffer does not have sufficient capacity.
-    fn encode_length_delimited<B: BufMut>(self, buf: &mut B) -> Result<(), Error>;
+    ///
+    /// This function replaces the Prost::Message encode_length_delimited() function for
+    /// DomainTypes.
+    fn encode_length_delimited<B: BufMut>(&self, buf: &mut B) -> Result<(), Error> {
+        T::from(self.clone())
+            .encode_length_delimited(buf)
+            .map_err(|e| Kind::EncodeMessage.context(e).into())
+    }
 
     /// Decodes an instance of the message from a buffer and then converts it into DomainType.
     ///
     /// The entire buffer will be consumed.
-    fn decode<B: Buf>(buf: B) -> Result<Self, Error>;
+    ///
+    /// This function replaces the Prost::Message decode() function for DomainTypes.
+    fn decode<B: Buf>(buf: B) -> Result<Self, Error> {
+        T::decode(buf).map_or_else(
+            |e| Err(Kind::DecodeMessage.context(e).into()),
+            |t| Self::try_from(t).map_err(|e| Kind::TryIntoDomainType.context(e).into()),
+        )
+    }
 
     /// Decodes a length-delimited instance of the message from the buffer.
     ///
     /// The entire buffer will be consumed.
-    fn decode_length_delimited<B: Buf>(buf: B) -> Result<Self, Error>;
+    ///
+    /// This function replaces the Prost::Message decode_length_delimited() function for
+    /// DomainTypes.
+    fn decode_length_delimited<B: Buf>(buf: B) -> Result<Self, Error> {
+        T::decode_length_delimited(buf).map_or_else(
+            |e| Err(Kind::DecodeMessage.context(e).into()),
+            |t| Self::try_from(t).map_err(|e| Kind::TryIntoDomainType.context(e).into()),
+        )
+    }
 
     /// Returns the encoded length of the message without a length delimiter.
     ///
-    /// The DomainType will be consumed.
-    fn encoded_len(self) -> usize;
+    /// This function replaces the Prost::Message encoded_len() function for DomainTypes.
+    fn encoded_len(&self) -> usize {
+        T::from(self.clone()).encoded_len()
+    }
+
+    /// Encodes the DomainType into a protobuf-encoded Vec<u8>
+    fn encode_vec(&self) -> Result<Vec<u8>, Error> {
+        let mut wire = Vec::with_capacity(self.encoded_len());
+        self.encode(&mut wire).map(|_| wire)
+    }
+
+    /// Decodes a protobuf-encoded instance of the message from a Vec<u8> and then converts it into
+    /// DomainType.
+    fn decode_vec(v: &[u8]) -> Result<Self, Error> {
+        Self::decode(v)
+    }
+
+    /// Encodes the DomainType with a length-delimiter to a Vec<u8> protobuf-encoded message.
+    fn encode_length_delimited_vec(&self) -> Result<Vec<u8>, Error> {
+        let len = self.encoded_len();
+        let lenu64 = len.try_into().map_err(|e| Kind::EncodeMessage.context(e))?;
+        let mut wire = Vec::with_capacity(len + encoded_len_varint(lenu64));
+        self.encode_length_delimited(&mut wire).map(|_| wire)
+    }
+
+    /// Decodes a protobuf-encoded instance of the message with a length-delimiter from a Vec<u8>
+    /// and then converts it into DomainType.
+    fn decode_length_delimited_vec(v: &[u8]) -> Result<Self, Error> {
+        Self::decode_length_delimited(v)
+    }
 }

proto/src/lib.rs

@@ -93,12 +93,6 @@ pub use domaintype::DomainType;
 mod error;
 pub use error::{Error, Kind};
 
-// Re-export the bytes and prost crates for use within derived code.
-#[doc(hidden)]
-pub use bytes;
-#[doc(hidden)]
-pub use prost;
-
 // Re-export the DomainType derive macro #[derive(DomainType)]
 #[cfg(feature = "tendermint-proto-derive")]
 #[doc(hidden)]

proto/tests/unit.rs

@@ -4,7 +4,7 @@ use tendermint_proto::types::PartSetHeader as RawPartSetHeader;
 use tendermint_proto::DomainType;
 
 // Example implementation of a protobuf struct using DomainType.
-#[derive(DomainType, Clone)]
+#[derive(DomainType, Clone, Debug)]
 #[rawtype(RawBlockId)]
 pub struct BlockId {
     hash: String,
@@ -40,6 +40,13 @@ impl From<BlockId> for RawBlockId {
     }
 }
 
+// Do any custom implementation for your type
+impl PartialEq for BlockId {
+    fn eq(&self, other: &Self) -> bool {
+        self.part_set_header_exists == other.part_set_header_exists && self.hash == other.hash
+    }
+}
+
 #[test]
 pub fn domaintype_struct_example() {
     let my_domain_type = BlockId {
@@ -48,7 +55,7 @@ pub fn domaintype_struct_example() {
     };
 
     let mut wire = vec![];
-    my_domain_type.clone().encode(&mut wire).unwrap();
+    my_domain_type.encode(&mut wire).unwrap();
     assert_eq!(
         wire,
         vec![10, 12, 72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 33]
@@ -77,3 +84,27 @@ pub fn domaintype_struct_length_delimited_example() {
     assert_eq!(new_domain_type.hash, "Hello world!".to_string());
     assert_eq!(new_domain_type.part_set_header_exists, false);
 }
+
+#[test]
+pub fn domaintype_struct_conveniences_example() {
+    let my_domain_type = BlockId {
+        hash: "Hello world!".to_string(),
+        part_set_header_exists: false,
+    };
+
+    let wire = my_domain_type.encode_vec().unwrap();
+    assert_eq!(
+        wire,
+        vec![10, 12, 72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 33]
+    );
+    let new_domain_type = BlockId::decode_vec(&wire).unwrap();
+    assert_eq!(my_domain_type, new_domain_type);
+
+    let wire = my_domain_type.encode_length_delimited_vec().unwrap();
+    assert_eq!(
+        wire,
+        vec![14, 10, 12, 72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 33]
+    );
+    let new_domain_type = BlockId::decode_length_delimited_vec(&wire).unwrap();
+    assert_eq!(my_domain_type, new_domain_type);
+}

tendermint/src/amino_types/ed25519.rs

@@ -135,7 +135,7 @@ mod tests {
             chain_id: "".to_string(),
         };
         let mut got = vec![];
-        let _have = msg.clone().encode(&mut got);
+        let _have = msg.encode(&mut got);
 
         assert_eq!(got, want);
 
@@ -190,7 +190,7 @@ mod tests {
             error: None,
         };
         let mut got = vec![];
-        let _have = msg.clone().encode(&mut got);
+        let _have = msg.encode(&mut got);
 
         assert_eq!(got, encoded);
 

tendermint/src/amino_types/vote.rs

@@ -576,7 +576,7 @@ mod tests {
             ],
         };
         let mut got = vec![];
-        let _have = vote.clone().encode(&mut got);
+        let _have = vote.encode(&mut got);
         let v = Vote::decode(got.as_ref()).unwrap();
 
         assert_eq!(v, vote);
@@ -587,7 +587,7 @@ mod tests {
                 chain_id: "test_chain_id".to_string(),
             };
             let mut got = vec![];
-            let _have = svr.clone().encode(&mut got);
+            let _have = svr.encode(&mut got);
 
             let svr2 = SignVoteRequest::decode(got.as_ref()).unwrap();
             assert_eq!(svr, svr2);