Make MessageGenerator infallible

rustaceanrob · rustaceanrob · commit cbb0342cd85d · 2025-11-20T15:14:15.000Z
The in-memory buffer cannot fail when serializing a message, and the
encryption cannot fail when memory is know as well.
diff --git a/src/network/outbound_messages.rs b/src/network/outbound_messages.rs
@@ -18,125 +18,119 @@ use bitcoin::{
 
 use crate::default_port_from_network;
 
-use super::{error::PeerError, KYOTO_VERSION, PROTOCOL_VERSION, RUST_BITCOIN_VERSION};
+use super::{KYOTO_VERSION, PROTOCOL_VERSION, RUST_BITCOIN_VERSION};
 
 // Responsible for serializing messages to write over the wire, either encrypted or plaintext.
-pub(crate) struct MessageGenerator {
+pub(in crate::network) struct MessageGenerator {
     pub network: Network,
     pub transport: Transport,
 }
 
-pub(crate) enum Transport {
+pub(in crate::network) enum Transport {
     V1,
     V2 { encryptor: PacketWriter },
 }
 
 impl MessageGenerator {
-    fn serialize(&mut self, msg: NetworkMessage) -> Result<Vec<u8>, PeerError> {
+    pub(in crate::network) fn serialize(&mut self, msg: NetworkMessage) -> Vec<u8> {
         match &mut self.transport {
             Transport::V1 => {
                 let data = RawNetworkMessage::new(self.network.magic(), msg);
-                Ok(serialize(&data))
+                serialize(&data)
             }
             Transport::V2 { encryptor } => {
-                let plaintext = serialize_network_message(msg)?;
+                let plaintext = serialize_network_message(msg);
                 encrypt_plaintext(encryptor, plaintext)
             }
         }
     }
 
-    pub(crate) fn version_message(&mut self, port: Option<u16>) -> Result<Vec<u8>, PeerError> {
+    pub(in crate::network) fn version_message(&mut self, port: Option<u16>) -> Vec<u8> {
         let msg = NetworkMessage::Version(make_version(port, &self.network));
         self.serialize(msg)
     }
 
-    pub(crate) fn verack(&mut self) -> Result<Vec<u8>, PeerError> {
+    pub(in crate::network) fn verack(&mut self) -> Vec<u8> {
         let msg = NetworkMessage::Verack;
         self.serialize(msg)
     }
 
-    pub(crate) fn addr(&mut self) -> Result<Vec<u8>, PeerError> {
+    pub(in crate::network) fn addr(&mut self) -> Vec<u8> {
         let msg = NetworkMessage::GetAddr;
         self.serialize(msg)
     }
 
-    pub(crate) fn addrv2(&mut self) -> Result<Vec<u8>, PeerError> {
+    pub(in crate::network) fn addrv2(&mut self) -> Vec<u8> {
         let msg = NetworkMessage::SendAddrV2;
         self.serialize(msg)
     }
 
-    pub(crate) fn wtxid_relay(&mut self) -> Result<Vec<u8>, PeerError> {
+    pub(in crate::network) fn wtxid_relay(&mut self) -> Vec<u8> {
         let msg = NetworkMessage::WtxidRelay;
         self.serialize(msg)
     }
 
-    pub(crate) fn sendheaders(&mut self) -> Result<Vec<u8>, PeerError> {
+    pub(in crate::network) fn sendheaders(&mut self) -> Vec<u8> {
         let msg = NetworkMessage::SendHeaders;
         self.serialize(msg)
     }
 
-    pub(crate) fn headers(&mut self, msg: GetHeadersMessage) -> Result<Vec<u8>, PeerError> {
+    pub(in crate::network) fn headers(&mut self, msg: GetHeadersMessage) -> Vec<u8> {
         let msg = NetworkMessage::GetHeaders(msg);
         self.serialize(msg)
     }
 
-    pub(crate) fn cf_headers(&mut self, message: GetCFHeaders) -> Result<Vec<u8>, PeerError> {
+    pub(in crate::network) fn cf_headers(&mut self, message: GetCFHeaders) -> Vec<u8> {
         let msg = NetworkMessage::GetCFHeaders(message);
         self.serialize(msg)
     }
 
-    pub(crate) fn filters(&mut self, message: GetCFilters) -> Result<Vec<u8>, PeerError> {
+    pub(in crate::network) fn filters(&mut self, message: GetCFilters) -> Vec<u8> {
         let msg = NetworkMessage::GetCFilters(message);
         self.serialize(msg)
     }
 
-    pub(crate) fn block(&mut self, hash: BlockHash) -> Result<Vec<u8>, PeerError> {
+    pub(in crate::network) fn block(&mut self, hash: BlockHash) -> Vec<u8> {
         let inv = Inventory::Block(hash);
         let msg = NetworkMessage::GetData(vec![inv]);
         self.serialize(msg)
     }
 
-    pub(crate) fn ping(&mut self, nonce: u64) -> Result<Vec<u8>, PeerError> {
+    pub(in crate::network) fn ping(&mut self, nonce: u64) -> Vec<u8> {
         let msg = NetworkMessage::Ping(nonce);
         self.serialize(msg)
     }
 
-    pub(crate) fn pong(&mut self, nonce: u64) -> Result<Vec<u8>, PeerError> {
+    pub(in crate::network) fn pong(&mut self, nonce: u64) -> Vec<u8> {
         let msg = NetworkMessage::Pong(nonce);
         self.serialize(msg)
     }
 
-    pub(crate) fn announce_transactions(
-        &mut self,
-        wtxids: Vec<Wtxid>,
-    ) -> Result<Vec<u8>, PeerError> {
+    pub(in crate::network) fn announce_transactions(&mut self, wtxids: Vec<Wtxid>) -> Vec<u8> {
         let msg = NetworkMessage::Inv(wtxids.into_iter().map(Inventory::WTx).collect());
         self.serialize(msg)
     }
 
-    pub(crate) fn broadcast_transaction(
+    pub(in crate::network) fn broadcast_transaction(
         &mut self,
         transaction: Transaction,
-    ) -> Result<Vec<u8>, PeerError> {
+    ) -> Vec<u8> {
         let msg = NetworkMessage::Tx(transaction);
         self.serialize(msg)
     }
 }
 
-fn serialize_network_message(message: NetworkMessage) -> Result<Vec<u8>, PeerError> {
-    bip324::serde::serialize(message).map_err(From::from)
+fn serialize_network_message(message: NetworkMessage) -> Vec<u8> {
+    bip324::serde::serialize(message).expect("in memory serialiation cannot fail.")
 }
 
-fn encrypt_plaintext(
-    encryptor: &mut PacketWriter,
-    plaintext: Vec<u8>,
-) -> Result<Vec<u8>, PeerError> {
+fn encrypt_plaintext(encryptor: &mut PacketWriter, plaintext: Vec<u8>) -> Vec<u8> {
     encryptor
         .encrypt_packet(&plaintext, None, PacketType::Genuine)
-        .map_err(From::from)
+        .expect("encryption to in memory buffer cannot fail.")
 }
 
-fn make_version(port: Option<u16>, network: &Network) -> VersionMessage {
+pub(in crate::network) fn make_version(port: Option<u16>, network: &Network) -> VersionMessage {
     let now = SystemTime::now()
         .duration_since(UNIX_EPOCH)
         .expect("time went backwards")
diff --git a/src/network/peer.rs b/src/network/peer.rs
@@ -102,7 +102,7 @@ impl Peer {
                 (outbound_messages, reader)
             };
 
-        let message = outbound_messages.version_message(None)?;
+        let message = outbound_messages.version_message(None);
         self.write_bytes(&mut writer, message).await?;
         self.message_state.start_version_handshake();
         let read_handle = tokio::spawn(async move { peer_reader.read_from_remote().await });
@@ -113,7 +113,7 @@ impl Peer {
                 return Ok(());
             }
             if let Some(nonce) = self.message_state.ping_state.send_ping() {
-                let msg = outbound_messages.ping(nonce)?;
+                let msg = outbound_messages.ping(nonce);
                 self.write_bytes(&mut writer, msg).await?;
                 let msg_id = TimeSensitiveId::PING;
                 self.message_state
@@ -261,7 +261,7 @@ impl Peer {
                 for wtxid in requests {
                     let transaction = tx_queue.fetch_tx(wtxid);
                     if let Some(transaction) = transaction {
-                        let msg = message_generator.broadcast_transaction(transaction)?;
+                        let msg = message_generator.broadcast_transaction(transaction);
                         self.write_bytes(writer, msg).await?;
                         self.message_state.sent_tx(wtxid);
                         tx_queue.successful(wtxid);
@@ -285,7 +285,7 @@ impl Peer {
                 Ok(())
             }
             ReaderMessage::Ping(nonce) => {
-                let message = message_generator.pong(nonce)?;
+                let message = message_generator.pong(nonce);
                 self.write_bytes(writer, message).await?;
                 Ok(())
             }
@@ -333,38 +333,38 @@ impl Peer {
         }
         match request {
             MainThreadMessage::GetAddr => {
-                let message = message_generator.addr()?;
+                let message = message_generator.addr();
                 self.write_bytes(writer, message).await?;
             }
             MainThreadMessage::GetAddrV2 => {
-                let message = message_generator.addrv2()?;
+                let message = message_generator.addrv2();
                 self.write_bytes(writer, message).await?;
             }
             MainThreadMessage::WtxidRelay => {
-                let message = message_generator.wtxid_relay()?;
+                let message = message_generator.wtxid_relay();
                 self.write_bytes(writer, message).await?;
             }
             MainThreadMessage::SendHeaders => {
-                let message = message_generator.sendheaders()?;
+                let message = message_generator.sendheaders();
                 self.write_bytes(writer, message).await?;
             }
             MainThreadMessage::GetHeaders(config) => {
-                let message = message_generator.headers(config)?;
+                let message = message_generator.headers(config);
                 self.write_bytes(writer, message).await?;
             }
             MainThreadMessage::GetFilterHeaders(config) => {
-                let message = message_generator.cf_headers(config)?;
+                let message = message_generator.cf_headers(config);
                 self.write_bytes(writer, message).await?;
             }
             MainThreadMessage::GetFilters(config) => {
                 self.message_state
                     .filter_rate
                     .batch_requested(config.stop_hash);
-                let message = message_generator.filters(config)?;
+                let message = message_generator.filters(config);
                 self.write_bytes(writer, message).await?;
             }
             MainThreadMessage::GetBlock(message) => {
-                let message = message_generator.block(message)?;
+                let message = message_generator.block(message);
                 self.write_bytes(writer, message).await?;
             }
             MainThreadMessage::BroadcastPending => {
@@ -377,12 +377,12 @@ impl Peer {
                     queue.pending_wtxid()
                 };
                 if !wtxids.is_empty() {
-                    let message = message_generator.announce_transactions(wtxids)?;
+                    let message = message_generator.announce_transactions(wtxids);
                     self.write_bytes(writer, message).await?;
                 }
             }
             MainThreadMessage::Verack => {
-                let message = message_generator.verack()?;
+                let message = message_generator.verack();
                 self.write_bytes(writer, message).await?;
                 self.message_state.verack.sent_ack();
                 if self.message_state.verack.both_acks() {
@@ -395,7 +395,7 @@ impl Peer {
                     queue.pending_wtxid()
                 };
                 if !wtxids.is_empty() {
-                    let message = message_generator.announce_transactions(wtxids)?;
+                    let message = message_generator.announce_transactions(wtxids);
                     self.write_bytes(writer, message).await?;
                 }
             }
