Remove libp2p dependency from sc-network-sync

prdoc/pr_4974.prdoc

@@ -0,0 +1,16 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: "Remove libp2p dependency from sc-network-sync"
+
+doc:
+  - audience: Node Dev
+    description: |
+      This PR removes `libp2p::request_response::OutboundFailure` from `substrate/client/network/sync/src/engine.rs`.
+
+crates: 
+  - name: sc-network
+    bump: patch
+  - name: sc-network-sync
+    bump: patch
+

substrate/client/network/src/request_responses.rs

@@ -44,7 +44,7 @@ use crate::{
 use futures::{channel::oneshot, prelude::*};
 use libp2p::{
 	core::{Endpoint, Multiaddr},
-	request_response::{self, Behaviour, Codec, Message, ProtocolSupport, ResponseChannel},
+	request_response::{self, Behaviour, Codec, ProtocolSupport, ResponseChannel},
 	swarm::{
 		behaviour::{ConnectionClosed, FromSwarm},
 		handler::multi::MultiHandler,
@@ -56,6 +56,8 @@ use libp2p::{
 
 use std::{
 	collections::{hash_map::Entry, HashMap},
+	fmt,
+	fmt::{Display, Formatter},
 	io, iter,
 	ops::Deref,
 	pin::Pin,
@@ -64,7 +66,93 @@ use std::{
 	time::{Duration, Instant},
 };
 
-pub use libp2p::request_response::{Config, InboundFailure, OutboundFailure, RequestId};
+pub use libp2p::request_response::{Config, RequestId};
+
+/// Possible failures occurring in the context of sending an outbound request and receiving the
+/// response.
+
+#[derive(Debug, thiserror::Error)]
+pub enum OutboundFailure {
+	/// The request could not be sent because a dialing attempt failed.
+	DialFailure,
+	/// The request timed out before a response was received.
+	Timeout,
+	/// The connection closed before a response was received.
+	ConnectionClosed,
+	/// The remote supports none of the requested protocols.
+	UnsupportedProtocols,
+}
+
+impl Display for OutboundFailure {
+	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+		match self {
+			OutboundFailure::DialFailure => write!(f, "Failed to dial the requested peer"),
+			OutboundFailure::Timeout => write!(f, "Timeout while waiting for a response"),
+			OutboundFailure::ConnectionClosed => 
+					write!(f, "Connection was closed before a response was received"),
+			OutboundFailure::UnsupportedProtocols => 
+					write!(f, "The remote supports none of the requested protocols"),
+		}
+	}
+}
+
+impl From<request_response::OutboundFailure> for OutboundFailure {
+	fn from(out: request_response::OutboundFailure) -> Self {
+		match out {
+			request_response::OutboundFailure::DialFailure => OutboundFailure::DialFailure,
+			request_response::OutboundFailure::Timeout => OutboundFailure::Timeout,
+			request_response::OutboundFailure::ConnectionClosed =>
+				OutboundFailure::ConnectionClosed,
+			request_response::OutboundFailure::UnsupportedProtocols =>
+				OutboundFailure::UnsupportedProtocols,
+		}
+	}
+}
+
+/// Possible failures occurring in the context of receiving an inbound request and sending a
+/// response.
+
+#[derive(Debug, thiserror::Error)]
+pub enum InboundFailure {
+	/// The inbound request timed out, either while reading the incoming request or before a
+	/// response is sent
+	Timeout,
+	/// The connection closed before a response could be send.
+	ConnectionClosed,
+	/// The local peer supports none of the protocols requested by the remote.
+	UnsupportedProtocols,
+	/// The local peer failed to respond to an inbound request
+	ResponseOmission,
+}
+
+impl Display for InboundFailure {
+	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+		match self {
+			InboundFailure::Timeout => 
+					write!(f, "Timeout while receiving request or sending response"),
+			InboundFailure::ConnectionClosed => 
+					write!(f, "Connection was closed before a response could be sent"),
+			InboundFailure::UnsupportedProtocols => 
+					write!(f, "The local peer supports none of the protocols requested by the remote"),
+			InboundFailure::ResponseOmission => write!(
+					f, 
+					"The response channel was dropped without sending a response to the remote"
+				),
+		}
+	}
+}
+
+impl From<request_response::InboundFailure> for InboundFailure {
+	fn from(out: request_response::InboundFailure) -> Self {
+		match out {
+			request_response::InboundFailure::ResponseOmission => InboundFailure::ResponseOmission,
+			request_response::InboundFailure::Timeout => InboundFailure::Timeout,
+			request_response::InboundFailure::ConnectionClosed => InboundFailure::ConnectionClosed,
+			request_response::InboundFailure::UnsupportedProtocols =>
+				InboundFailure::UnsupportedProtocols,
+		}
+	}
+}
 
 /// Error in a request.
 #[derive(Debug, thiserror::Error)]
@@ -684,7 +772,10 @@ impl NetworkBehaviour for RequestResponsesBehaviour {
 						// Received a request from a remote.
 						request_response::Event::Message {
 							peer,
-							message: Message::Request { request_id, request, channel, .. },
+							message:
+								request_response::Message::Request {
+									request_id, request, channel, ..
+								},
 						} => {
 							self.pending_responses_arrival_time
 								.insert((protocol.clone(), request_id).into(), Instant::now());
@@ -746,7 +837,7 @@ impl NetworkBehaviour for RequestResponsesBehaviour {
 						// Received a response from a remote to one of our requests.
 						request_response::Event::Message {
 							peer,
-							message: Message::Response { request_id, response },
+							message: request_response::Message::Response { request_id, response },
 							..
 						} => {
 							let (started, delivered) = match self
@@ -808,7 +899,9 @@ impl NetworkBehaviour for RequestResponsesBehaviour {
 								}) => {
 									// Try using the fallback request if the protocol was not
 									// supported.
-									if let OutboundFailure::UnsupportedProtocols = error {
+									if let request_response::OutboundFailure::UnsupportedProtocols =
+										error
+									{
 										if let Some((fallback_request, fallback_protocol)) =
 											fallback_request
 										{
@@ -829,7 +922,7 @@ impl NetworkBehaviour for RequestResponsesBehaviour {
 									}
 
 									if response_tx
-										.send(Err(RequestFailure::Network(error.clone())))
+										.send(Err(RequestFailure::Network(error.clone().into())))
 										.is_err()
 									{
 										log::debug!(
@@ -856,7 +949,7 @@ impl NetworkBehaviour for RequestResponsesBehaviour {
 								peer,
 								protocol: protocol.clone(),
 								duration: started.elapsed(),
-								result: Err(RequestFailure::Network(error)),
+								result: Err(RequestFailure::Network(error.into())),
 							};
 
 							return Poll::Ready(ToSwarm::GenerateEvent(out))
@@ -873,7 +966,7 @@ impl NetworkBehaviour for RequestResponsesBehaviour {
 							let out = Event::InboundRequest {
 								peer,
 								protocol: protocol.clone(),
-								result: Err(ResponseFailure::Network(error)),
+								result: Err(ResponseFailure::Network(error.into())),
 							};
 							return Poll::Ready(ToSwarm::GenerateEvent(out))
 						},

substrate/client/network/sync/Cargo.toml

@@ -25,7 +25,6 @@ async-trait = { workspace = true }
 codec = { features = ["derive"], workspace = true, default-features = true }
 futures = { workspace = true }
 futures-timer = { workspace = true }
-libp2p = { workspace = true }
 log = { workspace = true, default-features = true }
 mockall = { workspace = true }
 prost = { workspace = true }

substrate/client/network/sync/src/engine.rs

@@ -42,7 +42,6 @@ use crate::{
 
 use codec::{Decode, DecodeAll, Encode};
 use futures::{channel::oneshot, FutureExt, StreamExt};
-use libp2p::request_response::OutboundFailure;
 use log::{debug, error, trace, warn};
 use prometheus_endpoint::{
 	register, Counter, Gauge, MetricSource, Opts, PrometheusError, Registry, SourcedGauge, U64,
@@ -56,7 +55,7 @@ use sc_consensus::{import_queue::ImportQueueService, IncomingBlock};
 use sc_network::{
 	config::{FullNetworkConfiguration, NotificationHandshake, ProtocolId, SetConfig},
 	peer_store::PeerStoreProvider,
-	request_responses::{IfDisconnected, RequestFailure},
+	request_responses::{IfDisconnected, OutboundFailure, RequestFailure},
 	service::{
 		traits::{Direction, NotificationConfig, NotificationEvent, ValidationResult},
 		NotificationMetrics,