protocol: Refactor encoding

What made the issue fixed in the parent commit harder to spot
for me was the multitude of concepts and terms involved in
encoding: What's *serializing* vs. *encoding*? Why is there
this odd `Frame::to_bytes`?

So I decided to clean up a bit. I removed `fn serialize` so that the
logic stays close to the data, and instead of it provide
`fn encode_vec` in `trait Encode` so that we don't add up with
one-offs like `Frame::to_bytes` again.

Also we make use of `encode_vec` in the tests.

crates/radicle-node/src/wire.rs

@@ -427,7 +427,8 @@ where
                         stream: task.stream,
                     },
                 );
-                self.actions.push_back(Action::Send(fd, frame.to_bytes()));
+                self.actions
+                    .push_back(Action::Send(fd, frame.encode_to_vec()));
             }
         } else {
             // If the peer disconnected, we'll get here, but we still want to let the service know
@@ -479,7 +480,7 @@ where
                 ChannelEvent::Eof => Frame::control(*link, frame::Control::Eof { stream }),
             };
             self.actions
-                .push_back(reactor::Action::Send(fd, frame.to_bytes()));
+                .push_back(reactor::Action::Send(fd, frame.encode_to_vec()));
         }
     }
 
@@ -1126,7 +1127,7 @@ where
                     self.actions.push_back(Action::Send(
                         fd,
                         Frame::<service::Message>::control(link, frame::Control::Open { stream })
-                            .to_bytes(),
+                            .encode_to_vec(),
                     ));
                 }
             }
@@ -1264,7 +1265,7 @@ mod test {
         frame::StreamId::gossip(Link::Outbound).encode(&mut stream);
 
         // Serialize gossip message with some extension fields.
-        let mut gossip = wire::serialize(&pong);
+        let mut gossip = pong.encode_to_vec();
         String::from("extra").encode(&mut gossip);
         48u8.encode(&mut gossip);
 

crates/radicle-protocol/src/service/gossip/store.rs

@@ -10,7 +10,7 @@ use crate::service::message::{
     Announcement, AnnouncementMessage, InventoryAnnouncement, NodeAnnouncement, RefsAnnouncement,
 };
 use crate::wire;
-use crate::wire::Decode;
+use crate::wire::{Decode as _, Encode as _};
 use radicle::node::Database;
 use radicle::node::NodeId;
 use radicle::prelude::Timestamp;
@@ -117,17 +117,17 @@ impl Store for Database {
             AnnouncementMessage::Node(msg) => {
                 stmt.bind((2, sql::Value::String(String::new())))?;
                 stmt.bind((3, &GossipType::Node))?;
-                stmt.bind((4, msg))?;
+                stmt.bind((4, &msg.encode_to_vec()[..]))?;
             }
             AnnouncementMessage::Refs(msg) => {
                 stmt.bind((2, &msg.rid))?;
                 stmt.bind((3, &GossipType::Refs))?;
-                stmt.bind((4, msg))?;
+                stmt.bind((4, &msg.encode_to_vec()[..]))?;
             }
             AnnouncementMessage::Inventory(msg) => {
                 stmt.bind((2, sql::Value::String(String::new())))?;
                 stmt.bind((3, &GossipType::Inventory))?;
-                stmt.bind((4, msg))?;
+                stmt.bind((4, &msg.encode_to_vec()[..]))?;
             }
         }
         stmt.bind((5, &ann.signature))?;
@@ -231,12 +231,6 @@ impl TryFrom<&sql::Value> for NodeAnnouncement {
     }
 }
 
-impl sql::BindableWithIndex for &NodeAnnouncement {
-    fn bind<I: sql::ParameterIndex>(self, stmt: &mut sql::Statement<'_>, i: I) -> sql::Result<()> {
-        wire::serialize(self).bind(stmt, i)
-    }
-}
-
 impl TryFrom<&sql::Value> for RefsAnnouncement {
     type Error = sql::Error;
 
@@ -254,12 +248,6 @@ impl TryFrom<&sql::Value> for RefsAnnouncement {
     }
 }
 
-impl sql::BindableWithIndex for &RefsAnnouncement {
-    fn bind<I: sql::ParameterIndex>(self, stmt: &mut sql::Statement<'_>, i: I) -> sql::Result<()> {
-        wire::serialize(self).bind(stmt, i)
-    }
-}
-
 impl TryFrom<&sql::Value> for InventoryAnnouncement {
     type Error = sql::Error;
 
@@ -277,12 +265,6 @@ impl TryFrom<&sql::Value> for InventoryAnnouncement {
     }
 }
 
-impl sql::BindableWithIndex for &InventoryAnnouncement {
-    fn bind<I: sql::ParameterIndex>(self, stmt: &mut sql::Statement<'_>, i: I) -> sql::Result<()> {
-        wire::serialize(self).bind(stmt, i)
-    }
-}
-
 impl From<wire::Error> for sql::Error {
     fn from(other: wire::Error) -> Self {
         sql::Error {

crates/radicle-protocol/src/service/message.rs

@@ -16,6 +16,7 @@ use crate::bounded::BoundedVec;
 use crate::service::filter::Filter;
 use crate::service::{Link, NodeId, Timestamp};
 use crate::wire;
+use crate::wire::Encode as _;
 
 /// Maximum number of addresses which can be announced to other nodes.
 pub const ADDRESS_LIMIT: usize = 16;
@@ -69,20 +70,21 @@ impl NodeAnnouncement {
     /// Proof-of-work uses the [`scrypt`] algorithm with the parameters in
     /// [`Announcement::POW_PARAMS`]. The "work" is calculated by counting the number of leading
     /// zero bits after running `scrypt` on a serialized [`NodeAnnouncement`] using
-    /// [`wire::serialize`].
+    /// [`Encode::encode_to_vec`].
     ///
     /// In other words, `work = leading-zeros(scrypt(serialize(announcement)))`.
     ///
     /// Higher numbers mean higher difficulty. For each increase in work, difficulty is doubled.
     /// For instance, an output of `7` is *four* times more work than an output of `5`.
     ///
+    /// [`Encode::encode_to_vec`]: crate::wire::Encode::encode_to_vec
     pub fn work(&self) -> u32 {
         let (n, r, p) = Announcement::POW_PARAMS;
         let params = scrypt::Params::new(n, r, p, 32).expect("proof-of-work parameters are valid");
         let mut output = [0u8; 32];
 
         scrypt::scrypt(
-            wire::serialize(self).as_ref(),
+            &self.encode_to_vec(),
             Announcement::POW_SALT,
             &params,
             &mut output,
@@ -265,7 +267,8 @@ impl AnnouncementMessage {
     {
         use crypto::signature::Signer as _;
 
-        let msg = wire::serialize(&self);
+        let msg = self.encode_to_vec();
+
         let signature = signer.sign(&msg);
 
         Announcement {
@@ -365,7 +368,7 @@ impl Announcement {
 
     /// Verify this announcement's signature.
     pub fn verify(&self) -> bool {
-        let msg = wire::serialize(&self.message);
+        let msg = self.message.encode_to_vec();
         self.node.verify(msg, &self.signature).is_ok()
     }
 
@@ -425,8 +428,8 @@ impl PartialOrd for Message {
 
 impl Ord for Message {
     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        let this = wire::serialize(self);
+        let this = self.encode_to_vec();
-        let other = wire::serialize(other);
+        let other = other.encode_to_vec();
 
         this.cmp(&other)
     }
@@ -678,7 +681,6 @@ mod tests {
     use radicle::git::raw;
 
     use super::*;
-    use crate::wire::Encode;
     use localtime::LocalTime;
     use radicle::test::arbitrary;
 

crates/radicle-protocol/src/wire.rs

@@ -7,6 +7,7 @@ pub use message::{AddressType, MessageType};
 
 use std::collections::BTreeMap;
 use std::convert::TryFrom;
+use std::fmt::Debug;
 use std::mem;
 use std::ops::Deref;
 use std::str::FromStr;
@@ -94,7 +95,16 @@ impl From<bytes::TryGetError> for Error {
 
 /// Things that can be encoded as binary.
 pub trait Encode {
+    /// Encode self by writing it to the given buffer.
     fn encode(&self, buffer: &mut impl BufMut);
+
+    /// A convenience wrapper around [`Encode::encode`]
+    /// that allocates a [`Vec`].
+    fn encode_to_vec(&self) -> Vec<u8> {
+        let mut buf = Vec::new();
+        self.encode(&mut buf);
+        buf
+    }
 }
 
 /// Things that can be decoded from binary.
@@ -102,13 +112,6 @@ pub trait Decode: Sized {
     fn decode(buffer: &mut impl Buf) -> Result<Self, Error>;
 }
 
-/// Encode an object into a byte vector.
-pub fn serialize<E: Encode + ?Sized>(data: &E) -> Vec<u8> {
-    let mut buffer = Vec::new();
-    data.encode(&mut buffer);
-    buffer
-}
-
 /// Decode an object from a slice.
 pub fn deserialize<T: Decode>(mut data: &[u8]) -> Result<T, Error> {
     let result = T::decode(&mut data)?;
@@ -544,22 +547,22 @@ mod tests {
 
     #[quickcheck]
     fn prop_u8(input: u8) {
-        assert_eq!(deserialize::<u8>(&serialize(&input)).unwrap(), input);
+        assert_eq!(deserialize::<u8>(&input.encode_to_vec()).unwrap(), input);
     }
 
     #[quickcheck]
     fn prop_u16(input: u16) {
-        assert_eq!(deserialize::<u16>(&serialize(&input)).unwrap(), input);
+        assert_eq!(deserialize::<u16>(&input.encode_to_vec()).unwrap(), input);
     }
 
     #[quickcheck]
     fn prop_u32(input: u32) {
-        assert_eq!(deserialize::<u32>(&serialize(&input)).unwrap(), input);
+        assert_eq!(deserialize::<u32>(&input.encode_to_vec()).unwrap(), input);
     }
 
     #[quickcheck]
     fn prop_u64(input: u64) {
-        assert_eq!(deserialize::<u64>(&serialize(&input)).unwrap(), input);
+        assert_eq!(deserialize::<u64>(&input.encode_to_vec()).unwrap(), input);
     }
 
     #[quickcheck]
@@ -567,7 +570,10 @@ mod tests {
         if input.len() > u8::MAX as usize {
             return qcheck::TestResult::discard();
         }
-        assert_eq!(deserialize::<String>(&serialize(&input)).unwrap(), input);
+        assert_eq!(
+            deserialize::<String>(&input.encode_to_vec()).unwrap(),
+            input
+        );
 
         qcheck::TestResult::passed()
     }
@@ -575,38 +581,44 @@ mod tests {
     #[quickcheck]
     fn prop_vec(input: BoundedVec<String, 16>) {
         assert_eq!(
-            deserialize::<BoundedVec<String, 16>>(&serialize(&input.as_slice())).unwrap(),
+            deserialize::<BoundedVec<String, 16>>(&input.encode_to_vec()).unwrap(),
             input
         );
     }
 
     #[quickcheck]
     fn prop_pubkey(input: PublicKey) {
-        assert_eq!(deserialize::<PublicKey>(&serialize(&input)).unwrap(), input);
+        assert_eq!(
+            deserialize::<PublicKey>(&input.encode_to_vec()).unwrap(),
+            input
+        );
     }
 
     #[quickcheck]
     fn prop_filter(input: filter::Filter) {
         assert_eq!(
-            deserialize::<filter::Filter>(&serialize(&input)).unwrap(),
+            deserialize::<filter::Filter>(&input.encode_to_vec()).unwrap(),
             input
         );
     }
 
     #[quickcheck]
     fn prop_id(input: RepoId) {
-        assert_eq!(deserialize::<RepoId>(&serialize(&input)).unwrap(), input);
+        assert_eq!(
+            deserialize::<RepoId>(&input.encode_to_vec()).unwrap(),
+            input
+        );
     }
 
     #[quickcheck]
     fn prop_refs(input: Refs) {
-        assert_eq!(deserialize::<Refs>(&serialize(&input)).unwrap(), input);
+        assert_eq!(deserialize::<Refs>(&input.encode_to_vec()).unwrap(), input);
     }
 
     #[quickcheck]
     fn prop_tuple(input: (String, String)) {
         assert_eq!(
-            deserialize::<(String, String)>(&serialize(&input)).unwrap(),
+            deserialize::<(String, String)>(&input.encode_to_vec()).unwrap(),
             input
         );
     }
@@ -616,7 +628,7 @@ mod tests {
         let signature = Signature::from(input);
 
         assert_eq!(
-            deserialize::<Signature>(&serialize(&signature)).unwrap(),
+            deserialize::<Signature>(&signature.encode_to_vec()).unwrap(),
             signature
         );
     }
@@ -625,13 +637,13 @@ mod tests {
     fn prop_oid(input: [u8; 20]) {
         let oid = git::Oid::try_from(input.as_slice()).unwrap();
 
-        assert_eq!(deserialize::<git::Oid>(&serialize(&oid)).unwrap(), oid);
+        assert_eq!(deserialize::<git::Oid>(&oid.encode_to_vec()).unwrap(), oid);
     }
 
     #[quickcheck]
     fn prop_signed_refs(input: SignedRefs<Unverified>) {
         assert_eq!(
-            deserialize::<SignedRefs<Unverified>>(&serialize(&input)).unwrap(),
+            deserialize::<SignedRefs<Unverified>>(&input.encode_to_vec()).unwrap(),
             input
         );
     }
@@ -639,7 +651,7 @@ mod tests {
     #[test]
     fn test_string() {
         assert_eq!(
-            serialize(&String::from("hello")),
+            String::from("hello").encode_to_vec(),
             vec![5, b'h', b'e', b'l', b'l', b'o']
         );
     }
@@ -647,7 +659,7 @@ mod tests {
     #[test]
     fn test_alias() {
         assert_eq!(
-            serialize(&Alias::from_str("hello").unwrap()),
+            Alias::from_str("hello").unwrap().encode_to_vec(),
             vec![5, b'h', b'e', b'l', b'l', b'o']
         );
     }
@@ -656,7 +668,7 @@ mod tests {
     fn test_filter_invalid() {
         let b = bloomy::BloomFilter::with_size(filter::FILTER_SIZE_M / 3);
         let f = filter::Filter::from(b);
-        let bytes = serialize(&f);
+        let bytes = f.encode_to_vec();
 
         assert_matches!(
             deserialize::<filter::Filter>(&bytes).unwrap_err(),
@@ -667,10 +679,10 @@ mod tests {
     #[test]
     fn test_bounded_vec_limit() {
         let v: BoundedVec<u8, 2> = vec![1, 2].try_into().unwrap();
-        let buf = serialize(&v);
+        let buf = &v.encode_to_vec();
 
         assert_matches!(
-            deserialize::<BoundedVec<u8, 1>>(&buf),
+            deserialize::<BoundedVec<u8, 1>>(buf),
             Err(Error::InvalidSize {
                 expected: 1,
                 actual: 2
@@ -679,7 +691,7 @@ mod tests {
         );
 
         assert!(
-            deserialize::<BoundedVec<u8, 2>>(&buf).is_ok(),
+            deserialize::<BoundedVec<u8, 2>>(buf).is_ok(),
             "successfully decode vector of same size",
         );
     }

crates/radicle-protocol/src/wire/frame.rs

@@ -234,13 +234,6 @@ impl<M> Frame<M> {
     }
 }
 
-impl<M: wire::Encode> Frame<M> {
-    /// Serialize frame to bytes.
-    pub fn to_bytes(&self) -> Vec<u8> {
-        wire::serialize(self)
-    }
-}
-
 /// Frame payload.
 #[derive(Debug, PartialEq, Eq)]
 pub enum FrameData<M> {
@@ -363,7 +356,7 @@ impl<M: wire::Encode> wire::Encode for Frame<M> {
         match &self.data {
             FrameData::Control(ctrl) => ctrl.encode(buf),
             FrameData::Git(data) => varint::payload::encode(data, buf),
-            FrameData::Gossip(msg) => varint::payload::encode(&wire::serialize(msg), buf),
+            FrameData::Gossip(msg) => varint::payload::encode(&msg.encode_to_vec(), buf),
         }
     }
 }
@@ -393,6 +386,8 @@ mod test {
 
     #[test]
     fn test_encode_git_large() {
+        use wire::Encode as _;
+
         let size = u16::MAX as usize * 3;
         assert!(
             size > (wire::Size::MAX as usize * 2),
@@ -404,7 +399,7 @@ mod test {
         let frame: Frame<Message> = Frame::git(StreamId(0u8.into()), a_lot_of_data);
 
         // In previous versions since 3c5668e this would panic.
-        let bytes = wire::serialize(&frame);
+        let bytes = frame.encode_to_vec();
 
         assert!(
             bytes.len() > wire::Size::MAX as usize * 2,

crates/radicle-protocol/src/wire/message.rs

@@ -446,7 +446,7 @@ mod tests {
         });
         let ann = ann.signed(&signer);
         let msg = Message::Announcement(ann);
-        let data = wire::serialize(&msg);
+        let data = msg.encode_to_vec();
 
         assert!(data.len() < wire::Size::MAX as usize);
     }
@@ -461,7 +461,7 @@ mod tests {
         });
         let ann = ann.signed(&signer);
         let msg = Message::Announcement(ann);
-        let data = wire::serialize(&msg);
+        let data = msg.encode_to_vec();
 
         assert!(data.len() < wire::Size::MAX as usize);
     }
@@ -482,44 +482,48 @@ mod tests {
         });
         let ann = ann.signed(&signer);
         let msg = Message::Announcement(ann);
-        let data = wire::serialize(&msg);
+        let data = msg.encode_to_vec();
 
         assert!(data.len() < wire::Size::MAX as usize);
     }
 
     #[test]
     fn test_pingpong_encode_max_size() {
-        wire::serialize(&Message::Ping(Ping {
+        Message::Ping(Ping {
             ponglen: 0,
             zeroes: ZeroBytes::new(Ping::MAX_PING_ZEROES),
-        }));
+        })
+        .encode_to_vec();
 
-        wire::serialize(&Message::Pong {
+        (Message::Pong {
             zeroes: ZeroBytes::new(Ping::MAX_PONG_ZEROES),
-        });
+        })
+        .encode_to_vec();
     }
 
     #[test]
     #[should_panic(expected = "advance out of bounds")]
     fn test_ping_encode_size_overflow() {
-        wire::serialize(&Message::Ping(Ping {
+        Message::Ping(Ping {
             ponglen: 0,
             zeroes: ZeroBytes::new(Ping::MAX_PING_ZEROES + 1),
-        }));
+        })
+        .encode_to_vec();
     }
 
     #[test]
     #[should_panic(expected = "advance out of bounds")]
     fn test_pong_encode_size_overflow() {
-        wire::serialize(&Message::Pong {
+        Message::Pong {
             zeroes: ZeroBytes::new(Ping::MAX_PONG_ZEROES + 1),
-        });
+        }
+        .encode_to_vec();
     }
 
     #[quickcheck]
     fn prop_message_encode_decode(message: Message) {
-        let encoded = &wire::serialize(&message);
+        let encoded = message.encode_to_vec();
-        let decoded = wire::deserialize::<Message>(encoded).unwrap();
+        let decoded = wire::deserialize::<Message>(&encoded).unwrap();
 
         assert_eq!(message, decoded);
     }
@@ -552,7 +556,7 @@ mod tests {
             let zeroes = ZeroBytes::new(zeroes);
 
             assert_eq!(
-                wire::deserialize::<ZeroBytes>(&wire::serialize(&zeroes)).unwrap(),
+                wire::deserialize::<ZeroBytes>(&zeroes.encode_to_vec()).unwrap(),
                 zeroes
             );
         }
@@ -565,7 +569,7 @@ mod tests {
     #[quickcheck]
     fn prop_addr(addr: Address) {
         assert_eq!(
-            wire::deserialize::<Address>(&wire::serialize(&addr)).unwrap(),
+            wire::deserialize::<Address>(&addr.encode_to_vec()).unwrap(),
             addr
         );
     }

crates/radicle-protocol/src/wire/varint.rs

@@ -213,7 +213,7 @@ mod test {
 
     #[quickcheck]
     fn prop_encode_decode(input: VarInt) {
-        let encoded = wire::serialize(&input);
+        let encoded = input.encode_to_vec();
         let decoded: VarInt = wire::deserialize(&encoded).unwrap();
 
         assert_eq!(decoded, input);
@@ -222,30 +222,30 @@ mod test {
     #[test]
     #[should_panic]
     fn test_encode_overflow() {
-        wire::serialize(&VarInt(u64::MAX));
+        VarInt(u64::MAX).encode_to_vec();
     }
 
     #[test]
     fn test_encoding() {
-        assert_eq!(wire::serialize(&VarInt(0)), vec![0x0]);
+        assert_eq!(VarInt(0).encode_to_vec(), vec![0x0]);
-        assert_eq!(wire::serialize(&VarInt(1)), vec![0x01]);
+        assert_eq!(VarInt(1).encode_to_vec(), vec![0x01]);
-        assert_eq!(wire::serialize(&VarInt(10)), vec![0x0a]);
+        assert_eq!(VarInt(10).encode_to_vec(), vec![0x0a]);
-        assert_eq!(wire::serialize(&VarInt(37)), vec![0x25]);
+        assert_eq!(VarInt(37).encode_to_vec(), vec![0x25]);
         assert_eq!(
             wire::deserialize::<VarInt>(&[0x40, 0x25]).unwrap(),
             VarInt(37)
         );
-        assert_eq!(wire::serialize(&VarInt(15293)), vec![0x7b, 0xbd]);
+        assert_eq!(VarInt(15293).encode_to_vec(), vec![0x7b, 0xbd]);
         assert_eq!(
-            wire::serialize(&VarInt(494878333)),
+            VarInt(494878333).encode_to_vec(),
             vec![0x9d, 0x7f, 0x3e, 0x7d],
         );
         assert_eq!(
-            wire::serialize(&VarInt(151288809941952652)),
+            VarInt(151288809941952652).encode_to_vec(),
             vec![0xc2, 0x19, 0x7c, 0x5e, 0xff, 0x14, 0xe8, 0x8c]
         );
         assert_eq!(
-            wire::serialize(&VarInt(10000000000)),
+            VarInt(10000000000).encode_to_vec(),
             vec![0xc0, 0x00, 0x00, 0x02, 0x54, 0x0b, 0xe4, 0x00],
         );
     }