Remove p2pservice networkcodec trait

CHANGELOG.md

@@ -33,6 +33,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 ### Changed
 - [2378](https://github.com/FuelLabs/fuel-core/pull/2378): Use cached hash of the topic instead of calculating it on each publishing gossip message.
 - [2377](https://github.com/FuelLabs/fuel-core/pull/2377): Add more errors that can be returned as responses when using protocol `/fuel/req_res/0.0.2`. The errors supported are `ProtocolV1EmptyResponse` (status code `0`) for converting empty responses sent via protocol `/fuel/req_res/0.0.1`, `RequestedRangeTooLarge`(status code `1`) if the client requests a range of objects such as sealed block headers or transactions too large, `Timeout` (status code `2`) if the remote peer takes too long to fulfill a request, or `SyncProcessorOutOfCapacity` if the remote peer is fulfilling too many requests concurrently.
+- [2388](https://github.com/FuelLabs/fuel-core/pull/2388): Rework the P2P service codecs to avoid unnecessary coupling between components. The refactoring makes it explicit that the Gossipsub and RequestResponse codecs only share encoding/decoding functionalities from the Postcard codec. It also makes handling Gossipsub and RequestResponse messages completely independent of each other.
 
 #### Breaking
 - [2389](https://github.com/FuelLabs/fuel-core/pull/2258): Updated the `messageProof` GraphQL schema to return a non-nullable `MessageProof`.

crates/fuel-core/src/p2p_test_helpers.rs

@@ -23,7 +23,10 @@ use fuel_core_chain_config::{
     StateConfig,
 };
 use fuel_core_p2p::{
-    codecs::postcard::PostcardCodec,
+    codecs::{
+        gossipsub::GossipsubMessageHandler,
+        request_response::RequestResponseMessageHandler,
+    },
     network_service::FuelP2PService,
     p2p_service::FuelP2PEvent,
     request_response::messages::{
@@ -142,10 +145,18 @@ impl Bootstrap {
     /// Spawn a bootstrap node.
     pub async fn new(node_config: &Config) -> anyhow::Result<Self> {
         let bootstrap_config = extract_p2p_config(node_config).await;
-        let codec = PostcardCodec::new(bootstrap_config.max_block_size);
+        let request_response_codec =
+            RequestResponseMessageHandler::new(bootstrap_config.max_block_size);
+        let gossipsub_codec = GossipsubMessageHandler::new();
         let (sender, _) =
             broadcast::channel(bootstrap_config.reserved_nodes.len().saturating_add(1));
-        let mut bootstrap = FuelP2PService::new(sender, bootstrap_config, codec).await?;
+        let mut bootstrap = FuelP2PService::new(
+            sender,
+            bootstrap_config,
+            gossipsub_codec,
+            request_response_codec,
+        )
+        .await?;
         bootstrap.start().await?;
 
         let listeners = bootstrap.multiaddrs();

crates/services/p2p/src/behavior.rs

@@ -1,7 +1,8 @@
 use crate::{
     codecs::{
         postcard::PostcardCodec,
-        NetworkCodec,
+        request_response::RequestResponseMessageHandler,
+        RequestResponseProtocols,
     },
     config::Config,
     discovery,
@@ -59,11 +60,15 @@ pub struct FuelBehaviour {
     discovery: discovery::Behaviour,
 
     /// RequestResponse protocol
-    request_response: request_response::Behaviour<PostcardCodec>,
+    request_response:
+        request_response::Behaviour<RequestResponseMessageHandler<PostcardCodec>>,
 }
 
 impl FuelBehaviour {
-    pub(crate) fn new(p2p_config: &Config, codec: PostcardCodec) -> anyhow::Result<Self> {
+    pub(crate) fn new(
+        p2p_config: &Config,
+        request_response_codec: RequestResponseMessageHandler<PostcardCodec>,
+    ) -> anyhow::Result<Self> {
         let local_public_key = p2p_config.keypair.public();
         let local_peer_id = PeerId::from_public_key(&local_public_key);
 
@@ -110,7 +115,7 @@ impl FuelBehaviour {
             BlockHeight::default(),
         );
 
-        let req_res_protocol = codec
+        let req_res_protocol = request_response_codec
             .get_req_res_protocols()
             .map(|protocol| (protocol, ProtocolSupport::Full));
 
@@ -119,7 +124,7 @@ impl FuelBehaviour {
             .with_max_concurrent_streams(p2p_config.max_concurrent_streams);
 
         let request_response = request_response::Behaviour::with_codec(
-            codec.clone(),
+            request_response_codec.clone(),
             req_res_protocol,
             req_res_config,
         );

crates/services/p2p/src/codecs.rs

@@ -1,18 +1,60 @@
+pub mod gossipsub;
 pub mod postcard;
+pub mod request_response;
 
-use crate::{
-    gossipsub::messages::{
-        GossipTopicTag,
-        GossipsubBroadcastRequest,
-        GossipsubMessage,
-    },
-    request_response::messages::{
-        RequestMessage,
-        V2ResponseMessage,
-    },
+use crate::gossipsub::messages::GossipTopicTag;
+use libp2p::request_response as libp2p_request_response;
+
+use std::{
+    borrow::Cow,
+    io,
 };
-use libp2p::request_response;
-use std::io;
+
+// TODO: https://github.com/FuelLabs/fuel-core/issues/2403
+// This trait is largely a copy-paste from the storage crate.
+// It would be best to have this trait in a separate crate that both storage and p2p can depend on.
+pub trait Encoder: Send {
+    /// Returns the serialized object as a slice.
+    fn as_bytes(&self) -> Cow<[u8]>;
+}
+
+/// The trait encodes the type to the bytes and passes it to the `Encoder`,
+/// which stores it and provides a reference to it. That allows gives more
+/// flexibility and more performant encoding, allowing the use of slices and arrays
+/// instead of vectors in some cases. Since the [`Encoder`] returns `Cow<[u8]>`,
+/// it is always possible to take ownership of the serialized value.
+// TODO: https://github.com/FuelLabs/fuel-core/issues/2403
+// This trait is largely a copy-paste from the storage crate.
+// It would be best to have this trait in a separate crate that both storage and p2p can depend on.
+pub trait Encode<T: ?Sized> {
+    type Error;
+    /// The encoder type that stores serialized object.
+    type Encoder<'a>: Encoder
+    where
+        T: 'a;
+
+    /// Encodes the object to the bytes and passes it to the `Encoder`.
+    fn encode<'a>(&self, t: &'a T) -> Result<Self::Encoder<'a>, Self::Error>;
+}
+
+/// The trait decodes the type from the bytes.
+// TODO: https://github.com/FuelLabs/fuel-core/issues/2403
+// This trait is largely a copy-paste from the storage crate.
+// It would be best to have this trait in a separate crate that both storage and p2p can depend on.
+pub trait Decode<T> {
+    type Error;
+    /// Decodes the type `T` from the bytes.
+    fn decode(&self, bytes: &[u8]) -> Result<T, Self::Error>;
+}
+
+impl<'a> Encoder for Cow<'a, [u8]> {
+    fn as_bytes(&self) -> Cow<'_, [u8]> {
+        match self {
+            Cow::Borrowed(borrowed) => Cow::Borrowed(borrowed),
+            Cow::Owned(owned) => Cow::Borrowed(owned.as_ref()),
+        }
+    }
+}
 
 /// Implement this in order to handle serialization & deserialization of Gossipsub messages
 pub trait GossipsubCodec {
@@ -28,22 +70,10 @@ pub trait GossipsubCodec {
     ) -> Result<Self::ResponseMessage, io::Error>;
 }
 
-// TODO: https://github.com/FuelLabs/fuel-core/issues/2368
-// Remove this trait
-/// Main Codec trait
-/// Needs to be implemented and provided to FuelBehaviour
-pub trait NetworkCodec:
-    GossipsubCodec<
-        RequestMessage = GossipsubBroadcastRequest,
-        ResponseMessage = GossipsubMessage,
-    > + request_response::Codec<Request = RequestMessage, Response = V2ResponseMessage>
-    + Clone
-    + Send
-    + 'static
-{
+pub trait RequestResponseProtocols: libp2p_request_response::Codec {
     /// Returns RequestResponse's Protocol
     /// Needed for initialization of RequestResponse Behaviour
     fn get_req_res_protocols(
         &self,
-    ) -> impl Iterator<Item = <Self as request_response::Codec>::Protocol>;
+    ) -> impl Iterator<Item = <Self as libp2p_request_response::Codec>::Protocol>;
 }

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

@@ -0,0 +1,53 @@
+use std::io;
+
+use fuel_core_types::fuel_tx::Transaction;
+
+use crate::gossipsub::messages::{
+    GossipTopicTag,
+    GossipsubBroadcastRequest,
+    GossipsubMessage,
+};
+
+use super::{
+    Decode,
+    Encode,
+    Encoder,
+    GossipsubCodec,
+};
+
+#[derive(Debug, Clone, Default)]
+pub struct GossipsubMessageHandler<Codec> {
+    pub(crate) codec: Codec,
+}
+
+impl<Codec> GossipsubCodec for GossipsubMessageHandler<Codec>
+where
+    Codec: Encode<Transaction, Error = io::Error>
+        + Decode<Transaction, Error = io::Error>
+        + Send,
+{
+    type RequestMessage = GossipsubBroadcastRequest;
+    type ResponseMessage = GossipsubMessage;
+
+    fn encode(&self, data: Self::RequestMessage) -> Result<Vec<u8>, io::Error> {
+        match data {
+            GossipsubBroadcastRequest::NewTx(tx) => {
+                Ok(self.codec.encode(&*tx)?.as_bytes().into_owned())
+            }
+        }
+    }
+
+    fn decode(
+        &self,
+        encoded_data: &[u8],
+        gossipsub_tag: GossipTopicTag,
+    ) -> Result<Self::ResponseMessage, io::Error> {
+        let decoded_response = match gossipsub_tag {
+            GossipTopicTag::NewTx => {
+                GossipsubMessage::NewTx(self.codec.decode(encoded_data)?)
+            }
+        };
+
+        Ok(decoded_response)
+    }
+}