Remove libp2p dependency from sc-network-sync

substrate/client/network/src/request_responses.rs

@@ -51,7 +51,7 @@ use libp2p::{
 		ConnectionDenied, ConnectionId, NetworkBehaviour, PollParameters, THandler,
 		THandlerInEvent, THandlerOutEvent, ToSwarm,
 	},
-	PeerId,
+	PeerId, 
 };
 
 use std::{
@@ -62,14 +62,48 @@ use std::{
 	sync::Arc,
 	task::{Context, Poll},
 	time::{Duration, Instant},
+	fmt::{Display,Formatter},
+	fmt,
 };
 
 pub use libp2p::request_response::{Config, InboundFailure, OutboundFailure, RequestId};
 
+/// Adding a custom OutBoundFailure, not depending on libp2p
+#[derive(Debug, thiserror::Error)]
+#[allow(missing_docs)]
+pub enum CustomOutboundFailure{
+	DialFailure,
+    Timeout,
+    ConnectionClosed,
+    UnsupportedProtocols,
+}
+
+/// Implement Display trait
+impl Display for CustomOutboundFailure{
+	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result{
+		match self {
+			CustomOutboundFailure::DialFailure => write!(f, "DialFailure"),
+			CustomOutboundFailure::Timeout => write!(f, "Timeout"),
+			CustomOutboundFailure::ConnectionClosed => write!(f, "ConnectionClosed"),
+			CustomOutboundFailure::UnsupportedProtocols => write!(f, "UnsupportedProtocols"),
+		}
+	}
+}
+
+/// In preparation for a CustomOutBoundFailure Event 
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct OutboundRequestId(u64);
+
+impl fmt::Display for OutboundRequestId {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
 /// Error in a request.
 #[derive(Debug, thiserror::Error)]
 #[allow(missing_docs)]
-pub enum RequestFailure {
+pub enum RequestFailure{
 	#[error("We are not currently connected to the requested peer.")]
 	NotConnected,
 	#[error("Given protocol hasn't been registered.")]
@@ -80,6 +114,8 @@ pub enum RequestFailure {
 	Obsolete,
 	#[error("Problem on the network: {0}")]
 	Network(OutboundFailure),
+	#[error("Problem on the network: {0}")]
+	Network2(CustomOutboundFailure),
 }
 
 /// Configuration for a single request-response protocol.
@@ -248,6 +284,12 @@ pub enum Event {
 		/// Reputation changes.
 		changes: Vec<ReputationChange>,
 	},
+
+	/*CustomOutboundFailure {
+		peer: PeerId,
+        request_id: OutboundRequestId,
+        error: CustomOutboundFailure,
+	}*/
 }
 
 /// Combination of a protocol name and a request id.
@@ -1734,4 +1776,4 @@ mod tests {
 			);
 		});
 	}
-}
+}

substrate/client/network/src/service.rs

@@ -90,6 +90,8 @@ use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnbound
 use sp_runtime::traits::Block as BlockT;
 
 pub use behaviour::{InboundFailure, OutboundFailure, ResponseFailure};
+// Import our custom type 
+pub use crate::request_responses::CustomOutboundFailure;
 pub use libp2p::identity::{DecodingError, Keypair, PublicKey};
 pub use metrics::NotificationMetrics;
 pub use protocol::NotificationsSink;
@@ -1530,6 +1532,7 @@ where
 								.with_label_values(&[&protocol])
 								.observe(duration.as_secs_f64());
 						},
+						// we also could remove Network cases here like we did in engine 
 						Err(err) => {
 							let reason = match err {
 								RequestFailure::NotConnected => "not-connected",
@@ -1543,6 +1546,14 @@ where
 									"connection-closed",
 								RequestFailure::Network(OutboundFailure::UnsupportedProtocols) =>
 									"unsupported",
+								RequestFailure::Network2(CustomOutboundFailure::DialFailure) =>
+									"dial-failure",
+								RequestFailure::Network2(CustomOutboundFailure::Timeout) => "timeout",
+								RequestFailure::Network2(CustomOutboundFailure::ConnectionClosed) =>
+									"connection-closed",
+								RequestFailure::Network2(CustomOutboundFailure::UnsupportedProtocols) =>
+									"unsupported",
+
 							};
 
 							metrics

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

@@ -47,7 +47,6 @@ use futures::{
 	future::{BoxFuture, Fuse},
 	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,
@@ -61,7 +60,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, RequestFailure, CustomOutboundFailure},
 	service::{
 		traits::{Direction, NotificationConfig, NotificationEvent, ValidationResult},
 		NotificationMetrics,
@@ -1272,18 +1271,19 @@ where
 			Ok(Err(e)) => {
 				debug!(target: LOG_TARGET, "Request to peer {peer_id:?} failed: {e:?}.");
 
+				// Using Our custom type Network2(CustomOutboundFailure)
 				match e {
-					RequestFailure::Network(OutboundFailure::Timeout) => {
+					RequestFailure::Network2(CustomOutboundFailure::Timeout) => {
 						self.network_service.report_peer(peer_id, rep::TIMEOUT);
 						self.network_service
 							.disconnect_peer(peer_id, self.block_announce_protocol_name.clone());
 					},
-					RequestFailure::Network(OutboundFailure::UnsupportedProtocols) => {
+					RequestFailure::Network2(CustomOutboundFailure::UnsupportedProtocols) => {
 						self.network_service.report_peer(peer_id, rep::BAD_PROTOCOL);
 						self.network_service
 							.disconnect_peer(peer_id, self.block_announce_protocol_name.clone());
 					},
-					RequestFailure::Network(OutboundFailure::DialFailure) => {
+					RequestFailure::Network2(CustomOutboundFailure::DialFailure) => {
 						self.network_service
 							.disconnect_peer(peer_id, self.block_announce_protocol_name.clone());
 					},
@@ -1292,7 +1292,7 @@ where
 						self.network_service
 							.disconnect_peer(peer_id, self.block_announce_protocol_name.clone());
 					},
-					RequestFailure::Network(OutboundFailure::ConnectionClosed) |
+					RequestFailure::Network2(CustomOutboundFailure::ConnectionClosed) |
 					RequestFailure::NotConnected => {
 						self.network_service
 							.disconnect_peer(peer_id, self.block_announce_protocol_name.clone());
@@ -1307,6 +1307,8 @@ where
 								response receiver.",
 						);
 					},
+					//If OutboundFailure is used, 
+					RequestFailure::Network(_) => {debug_assert!(false, "Don't use deprecated Network");},
 				}
 			},
 			Err(oneshot::Canceled) => {