Make serialize function infallible and remove error variant.

protocol/src/serde.rs

@@ -17,15 +17,13 @@ pub use bitcoin::p2p::message::{CommandString, NetworkMessage};
 
 #[derive(Debug)]
 pub enum Error {
-    Serialize(bitcoin::io::Error),
     Deserialize(bitcoin::consensus::encode::Error),
     UnknownShortID(u8),
 }
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Error::Serialize(e) => write!(f, "Unable to serialize {e}"),
             Error::Deserialize(e) => write!(f, "Unable to deserialize {e}"),
             Error::UnknownShortID(b) => write!(f, "Unrecognized short ID when deserializing {b}"),
         }
@@ -35,15 +33,17 @@ impl fmt::Display for Error {
 impl std::error::Error for Error {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         match self {
-            Error::Serialize(e) => Some(e),
             Error::Deserialize(e) => Some(e),
             Error::UnknownShortID(_) => None,
         }
     }
 }
 
 /// Serialize a [`NetworkMessage`] into a buffer.
-pub fn serialize(msg: NetworkMessage) -> Result<Vec<u8>, Error> {
+///
+/// This function is infallible because the underlying `consensus_encode()`
+/// operations only fail on I/O errors, which cannot occur when writing to an in-memory `Vec<u8>`.
+pub fn serialize(msg: NetworkMessage) -> Vec<u8> {
     let mut buffer = Vec::new();
     match &msg {
         NetworkMessage::Addr(_) => {
@@ -142,7 +142,7 @@ pub fn serialize(msg: NetworkMessage) -> Result<Vec<u8>, Error> {
             buffer.push(0u8);
             msg.command()
                 .consensus_encode(&mut buffer)
-                .map_err(Error::Serialize)?;
+                .expect("Encoding to Vec<u8> never fails");
         }
         NetworkMessage::Unknown {
             command,
@@ -151,14 +151,14 @@ pub fn serialize(msg: NetworkMessage) -> Result<Vec<u8>, Error> {
             buffer.push(0u8);
             command
                 .consensus_encode(&mut buffer)
-                .map_err(Error::Serialize)?;
+                .expect("Encoding to Vec<u8> never fails");
         }
     }
 
     msg.consensus_encode(&mut buffer)
-        .map_err(Error::Serialize)?;
+        .expect("Encoding to Vec<u8> never fails");
 
-    Ok(buffer)
+    buffer
 }
 
 /// Deserialize v2 message into [`NetworkMessage`].

protocol/tests/round_trips.rs

@@ -271,7 +271,7 @@ fn regtest_handshake() {
         start_height: 0,
         relay: false,
     };
-    let message = serialize(NetworkMessage::Version(msg)).unwrap();
+    let message = serialize(NetworkMessage::Version(msg));
     let packet_len = bip324::OutboundCipher::encryption_buffer_len(message.len());
     let mut packet = vec![0u8; packet_len];
     encrypter

proxy/src/bin/proxy.rs

@@ -114,7 +114,7 @@ async fn v2_proxy(
                     msg.command()
                 );
 
-                let contents = serialize(msg).expect("serialize-able contents into network message");
+                let contents = serialize(msg);
                 v2_remote_writer
                     .encrypt_and_write(&contents, &mut remote_writer)
                     .await