Remove p2pservice networkcodec trait

CHANGELOG.md

@@ -21,6 +21,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - [2473](https://github.com/FuelLabs/fuel-core/pull/2473): Graphql requests and responses make use of a new `extensions` object to specify request/response metadata. A request `extensions` object can contain an integer-valued `required_fuel_block_height` field. When specified, the request will return an error unless the node's current fuel block height is at least the value specified in the `required_fuel_block_height` field. All graphql responses now contain an integer-valued `current_fuel_block_height` field in the `extensions` object, which contains the block height of the last block processed by the node.
 - [2653](https://github.com/FuelLabs/fuel-core/pull/2653): Added cleaner error for wasm-executor upon failed deserialization.
 - [2705](https://github.com/FuelLabs/fuel-core/pull/2705): Update the default value for `--max-block-size` and `--max-transmit-size` to 50 MB
+- [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.
 
 ## [Version 0.41.7]
 

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::{
@@ -172,10 +175,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,
@@ -67,7 +68,8 @@ pub struct FuelBehaviour {
     discovery: discovery::Behaviour,
 
     /// RequestResponse protocol
-    request_response: request_response::Behaviour<PostcardCodec>,
+    request_response:
+        request_response::Behaviour<RequestResponseMessageHandler<PostcardCodec>>,
 
     /// The Behaviour to manage connection limits.
     connection_limits: connection_limits::Behaviour,
@@ -76,8 +78,8 @@ pub struct FuelBehaviour {
 impl FuelBehaviour {
     pub(crate) fn new(
         p2p_config: &Config,
-        codec: PostcardCodec,
-    ) -> anyhow::Result<Self, anyhow::Error> {
+        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);
 
@@ -131,7 +133,7 @@ impl FuelBehaviour {
                 .with_max_established(Some(MAX_ESTABLISHED_CONNECTIONS)),
         );
 
-        let req_res_protocol = codec
+        let req_res_protocol = request_response_codec
             .get_req_res_protocols()
             .map(|protocol| (protocol, ProtocolSupport::Full));
 
@@ -140,7 +142,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,48 @@
+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;
+
+pub trait Encoder: Send {
+    /// Returns the serialized object as a slice.
+    fn to_bytes(self) -> Vec<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.
+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.
+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 to_bytes(self) -> Vec<u8> {
+        self.into()
+    }
+}
 
 /// Implement this in order to handle serialization & deserialization of Gossipsub messages
 pub trait GossipsubCodec {
@@ -28,22 +58,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,52 @@
+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>,
+{
+    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)?.to_bytes())
+            }
+        }
+    }
+
+    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)
+    }
+}