P2pService: Make max_response_size in PostcardCodec a u64

.changes/changed/2460.md

@@ -0,0 +1 @@
+The type of the `max_response_size`for the postcard codec used in `RequestResponse` protocols has been changed from `usize` to `u64`.

bin/fuel-core/src/cli/run/p2p.rs

@@ -30,7 +30,8 @@ use std::{
     str::FromStr,
 };
 
-const MAX_RESPONSE_SIZE_STR: &str = const_format::formatcp!("{MAX_RESPONSE_SIZE}");
+const MAX_RESPONSE_SIZE_STR: &str =
+    const_format::formatcp!("{}", MAX_RESPONSE_SIZE.get());
 
 #[derive(Debug, Clone, Args)]
 pub struct P2PArgs {
@@ -59,7 +60,7 @@ pub struct P2PArgs {
 
     /// Max Block size
     #[clap(long = "max-block-size", default_value = MAX_RESPONSE_SIZE_STR, env)]
-    pub max_block_size: usize,
+    pub max_block_size: u32,
 
     /// Max number of blocks/headers in a single headers request response
     #[clap(long = "max-headers-per-request", default_value = "100", env)]
@@ -308,6 +309,9 @@ impl P2PArgs {
             )
         };
 
+        let max_block_size = NonZeroU32::new(self.max_block_size)
+            .ok_or(anyhow!("max block size must be greater than zero"))?;
+
         let config = Config {
             keypair: local_keypair,
             network_name,
@@ -317,7 +321,7 @@ impl P2PArgs {
                 .unwrap_or_else(|| IpAddr::V4(Ipv4Addr::from([0, 0, 0, 0]))),
             public_address: self.public_address,
             tcp_port: self.peering_port,
-            max_block_size: self.max_block_size,
+            max_block_size,
             max_headers_per_request: self.max_headers_per_request,
             max_txs_per_request: self.max_txs_per_request,
             bootstrap_nodes: self.bootstrap_nodes,

crates/services/p2p/src/codecs/postcard.rs

@@ -8,18 +8,14 @@ use super::{
 use std::{
     borrow::Cow,
     io,
+    num::NonZeroU32,
 };
 
 #[derive(Clone, Default)]
 pub struct PostcardCodec;
 
 impl RequestResponseMessageHandler<PostcardCodec> {
-    pub fn new(max_block_size: usize) -> Self {
-        assert_ne!(
-            max_block_size, 0,
-            "RequestResponseMessageHandler does not support zero block size"
-        );
-
+    pub fn new(max_block_size: NonZeroU32) -> Self {
         Self {
             codec: PostcardCodec,
             max_response_size: max_block_size,
@@ -76,17 +72,20 @@ mod tests {
                 ResponseMessageErrorCode,
                 V1ResponseMessage,
                 V2ResponseMessage,
-                MAX_REQUEST_SIZE,
             },
             protocols::RequestResponseProtocol,
         },
     };
 
+    const MAX_REQUEST_SIZE: NonZeroU32 = unsafe { NonZeroU32::new_unchecked(1024) };
+
     #[test]
     fn test_request_size_fits() {
         let arbitrary_range = 2..6;
         let m = RequestMessage::Transactions(arbitrary_range);
-        assert!(postcard::to_stdvec(&m).unwrap().len() <= MAX_REQUEST_SIZE);
+        assert!(
+            postcard::to_stdvec(&m).unwrap().len() <= MAX_REQUEST_SIZE.get() as usize
+        );
     }
 
     #[tokio::test]
@@ -96,7 +95,7 @@ mod tests {
         let sealed_block_headers = vec![SealedBlockHeader::default()];
         let response = V2ResponseMessage::SealedHeaders(Ok(sealed_block_headers.clone()));
         let mut codec: RequestResponseMessageHandler<PostcardCodec> =
-            RequestResponseMessageHandler::new(1024);
+            RequestResponseMessageHandler::new(MAX_REQUEST_SIZE);
         let mut buf = Vec::with_capacity(1024);
 
         // When
@@ -124,7 +123,7 @@ mod tests {
         let sealed_block_headers = vec![SealedBlockHeader::default()];
         let response = V2ResponseMessage::SealedHeaders(Ok(sealed_block_headers.clone()));
         let mut codec: RequestResponseMessageHandler<PostcardCodec> =
-            RequestResponseMessageHandler::new(1024);
+            RequestResponseMessageHandler::new(MAX_REQUEST_SIZE);
         let mut buf = Vec::with_capacity(1024);
 
         // When
@@ -152,7 +151,7 @@ mod tests {
             ResponseMessageErrorCode::ProtocolV1EmptyResponse,
         ));
         let mut codec: RequestResponseMessageHandler<PostcardCodec> =
-            RequestResponseMessageHandler::new(1024);
+            RequestResponseMessageHandler::new(MAX_REQUEST_SIZE);
         let mut buf = Vec::with_capacity(1024);
 
         // When
@@ -183,7 +182,7 @@ mod tests {
             ResponseMessageErrorCode::RequestedRangeTooLarge,
         ));
         let mut codec: RequestResponseMessageHandler<PostcardCodec> =
-            RequestResponseMessageHandler::new(1024);
+            RequestResponseMessageHandler::new(MAX_REQUEST_SIZE);
         let mut buf = Vec::with_capacity(1024);
 
         // When
@@ -213,7 +212,7 @@ mod tests {
             ResponseMessageErrorCode::ProtocolV1EmptyResponse,
         ));
         let mut codec: RequestResponseMessageHandler<PostcardCodec> =
-            RequestResponseMessageHandler::new(1024);
+            RequestResponseMessageHandler::new(MAX_REQUEST_SIZE);
         let mut buf = Vec::with_capacity(1024);
 
         // When
@@ -239,7 +238,7 @@ mod tests {
         // Given
         let response = V1ResponseMessage::SealedHeaders(None);
         let mut codec: RequestResponseMessageHandler<PostcardCodec> =
-            RequestResponseMessageHandler::new(1024);
+            RequestResponseMessageHandler::new(MAX_REQUEST_SIZE);
 
         // When
         let buf = codec

crates/services/p2p/src/codecs/request_response.rs

@@ -31,9 +31,7 @@ pub struct RequestResponseMessageHandler<Codec> {
     /// Used for `max_size` parameter when reading Response Message
     /// Necessary in order to avoid DoS attacks
     /// Currently the size mostly depends on the max size of the Block
-    // TODO: https://github.com/FuelLabs/fuel-core/issues/2459.
-    // Make this a u64 instead of usize.
-    pub(crate) max_response_size: usize,
+    pub(crate) max_response_size: std::num::NonZeroU32,
 }
 
 /// Since Postcard does not support async reads or writes out of the box
@@ -68,7 +66,7 @@ where
     {
         let mut response = Vec::new();
         socket
-            .take(self.max_response_size as u64)
+            .take(self.max_response_size.get() as u64)
             .read_to_end(&mut response)
             .await?;
         self.codec.decode(&response)
@@ -84,7 +82,7 @@ where
     {
         let mut response = Vec::new();
         socket
-            .take(self.max_response_size as u64)
+            .take(self.max_response_size.get() as u64)
             .read_to_end(&mut response)
             .await?;
 

crates/services/p2p/src/config.rs

@@ -28,8 +28,10 @@ use std::{
         IpAddr,
         Ipv4Addr,
     },
+    num::NonZeroU32,
     time::Duration,
 };
+
 mod connection_tracker;
 mod fuel_authenticated;
 pub(crate) mod fuel_upgrade;
@@ -40,7 +42,8 @@ const REQ_RES_TIMEOUT: Duration = Duration::from_secs(20);
 /// The configuration of the ingress should be the same:
 /// - `nginx.org/client-max-body-size`
 /// - `nginx.ingress.kubernetes.io/proxy-body-size`
-pub const MAX_RESPONSE_SIZE: usize = 50 * 1024 * 1024;
+pub const MAX_RESPONSE_SIZE: NonZeroU32 =
+    unsafe { NonZeroU32::new_unchecked(50 * 1024 * 1024) };
 
 /// Maximum number of blocks per request.
 pub const MAX_HEADERS_PER_REQUEST: usize = 100;
@@ -69,7 +72,7 @@ pub struct Config<State = Initialized> {
     pub tcp_port: u16,
 
     /// Max Size of a Block in bytes
-    pub max_block_size: usize,
+    pub max_block_size: NonZeroU32,
     pub max_headers_per_request: usize,
 
     // Maximum of txs id asked in a single request

crates/services/p2p/src/gossipsub/config.rs

@@ -81,7 +81,7 @@ pub(crate) fn default_gossipsub_config() -> gossipsub::Config {
         .gossip_lazy(6)
         .history_length(5)
         .history_gossip(3)
-        .max_transmit_size(MAX_RESPONSE_SIZE)
+        .max_transmit_size(MAX_RESPONSE_SIZE.get() as usize)
         .heartbeat_interval(Duration::from_millis(700))
         .fanout_ttl(Duration::from_secs(60))
         .build()

crates/services/p2p/src/request_response/messages.rs

@@ -19,10 +19,6 @@ use std::ops::Range;
 use thiserror::Error;
 use tokio::sync::oneshot;
 
-/// Max Size in Bytes of the Request Message
-#[cfg(test)]
-pub(crate) const MAX_REQUEST_SIZE: usize = core::mem::size_of::<RequestMessage>();
-
 #[derive(Serialize, Deserialize, Eq, PartialEq, Debug, Clone)]
 pub enum RequestMessage {
     SealedHeaders(Range<u32>),