Upgrade to libp2p 0.44.0

client/authority-discovery/Cargo.toml

@@ -23,7 +23,7 @@ thiserror = "1.0"
 futures = "0.3.21"
 futures-timer = "3.0.1"
 ip_network = "0.4.1"
-libp2p = { version = "0.40.0", default-features = false, features = ["kad"] }
+libp2p = { version = "0.44.0", default-features = false, features = ["kad"] }
 log = "0.4.8"
 prometheus-endpoint = { package = "substrate-prometheus-endpoint", path = "../../utils/prometheus", version = "0.10.0-dev" }
 prost = "0.9"

client/authority-discovery/src/worker.rs

@@ -37,7 +37,7 @@ use codec::Decode;
 use ip_network::IpNetwork;
 use libp2p::{
 	core::multiaddr,
-	multihash::{Hasher, Multihash},
+	multihash::{Multihash, MultihashDigest},
 };
 use log::{debug, error, log_enabled};
 use prometheus_endpoint::{register, Counter, CounterVec, Gauge, Opts, U64};
@@ -638,7 +638,7 @@ where
 }
 
 fn hash_authority_id(id: &[u8]) -> sc_network::KademliaKey {
-	sc_network::KademliaKey::new(&libp2p::multihash::Sha2_256::digest(id))
+	sc_network::KademliaKey::new(&libp2p::multihash::Code::Sha2_256.digest(id).digest())
 }
 
 // Makes sure all values are the same and returns it

client/cli/Cargo.toml

@@ -18,7 +18,7 @@ clap = { version = "3.1.6", features = ["derive"] }
 fdlimit = "0.2.1"
 futures = "0.3.21"
 hex = "0.4.2"
-libp2p = "0.40.0"
+libp2p = "0.44.0"
 log = "0.4.11"
 names = { version = "0.13.0", default-features = false }
 rand = "0.7.3"

client/consensus/common/Cargo.toml

@@ -14,7 +14,7 @@ targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
 thiserror = "1.0.30"
-libp2p = { version = "0.40.0", default-features = false }
+libp2p = { version = "0.44.0", default-features = false }
 log = "0.4.8"
 futures = { version = "0.3.21", features = ["thread-pool"] }
 futures-timer = "3.0.1"

client/network-gossip/Cargo.toml

@@ -17,7 +17,7 @@ targets = ["x86_64-unknown-linux-gnu"]
 [dependencies]
 futures = "0.3.21"
 futures-timer = "3.0.1"
-libp2p = { version = "0.40.0", default-features = false }
+libp2p = { version = "0.44.0", default-features = false }
 log = "0.4.8"
 lru = "0.7.5"
 ahash = "0.7.6"

client/network/Cargo.toml

@@ -61,12 +61,12 @@ unsigned-varint = { version = "0.6.0", features = [
     "asynchronous_codec",
 ] }
 void = "1.0.2"
-zeroize = "1.5.4"
-libp2p = "0.40.0"
+zeroize = "1.4.3"
+libp2p = "0.44.0"
 
 [dev-dependencies]
 assert_matches = "1.3"
-libp2p = { version = "0.40.0", default-features = false }
+libp2p = { version = "0.44.0", default-features = false }
 quickcheck = "1.0.3"
 rand = "0.7.2"
 sp-test-primitives = { version = "2.0.0", path = "../../primitives/test-primitives" }

client/network/src/behaviour.rs

@@ -33,8 +33,8 @@ use libp2p::{
 	identify::IdentifyInfo,
 	kad::record,
 	swarm::{
-		toggle::Toggle, NetworkBehaviour, NetworkBehaviourAction, NetworkBehaviourEventProcess,
-		PollParameters,
+		behaviour::toggle::Toggle, NetworkBehaviour, NetworkBehaviourAction,
+		NetworkBehaviourEventProcess, PollParameters,
 	},
 	NetworkBehaviour,
 };
@@ -304,7 +304,7 @@ impl<B: BlockT> Behaviour<B> {
 
 	/// Start querying a record from the DHT. Will later produce either a `ValueFound` or a
 	/// `ValueNotFound` event.
-	pub fn get_value(&mut self, key: &record::Key) {
+	pub fn get_value(&mut self, key: record::Key) {
 		self.discovery.get_value(key);
 	}
 
@@ -519,7 +519,7 @@ impl<B: BlockT> Behaviour<B> {
 		&mut self,
 		_cx: &mut Context,
 		_: &mut impl PollParameters,
-	) -> Poll<NetworkBehaviourAction<BehaviourOut<B>, <Self as NetworkBehaviour>::ProtocolsHandler>>
+	) -> Poll<NetworkBehaviourAction<BehaviourOut<B>, <Self as NetworkBehaviour>::ConnectionHandler>>
 	{
 		if let Some(event) = self.events.pop_front() {
 			return Poll::Ready(NetworkBehaviourAction::GenerateEvent(event))

client/network/src/bitswap.rs

@@ -194,21 +194,17 @@ impl<B: BlockT> Bitswap<B> {
 }
 
 impl<B: BlockT> NetworkBehaviour for Bitswap<B> {
-	type ProtocolsHandler = OneShotHandler<BitswapConfig, BitswapMessage, HandlerEvent>;
+	type ConnectionHandler = OneShotHandler<BitswapConfig, BitswapMessage, HandlerEvent>;
 	type OutEvent = void::Void;
 
-	fn new_handler(&mut self) -> Self::ProtocolsHandler {
+	fn new_handler(&mut self) -> Self::ConnectionHandler {
 		Default::default()
 	}
 
 	fn addresses_of_peer(&mut self, _peer: &PeerId) -> Vec<Multiaddr> {
 		Vec::new()
 	}
 
-	fn inject_connected(&mut self, _peer: &PeerId) {}
-
-	fn inject_disconnected(&mut self, _peer: &PeerId) {}
-
 	fn inject_event(&mut self, peer: PeerId, _connection: ConnectionId, message: HandlerEvent) {
 		let request = match message {
 			HandlerEvent::ResponseSent => return,
@@ -300,7 +296,7 @@ impl<B: BlockT> NetworkBehaviour for Bitswap<B> {
 		&mut self,
 		_ctx: &mut Context,
 		_: &mut impl PollParameters,
-	) -> Poll<NetworkBehaviourAction<Self::OutEvent, Self::ProtocolsHandler>> {
+	) -> Poll<NetworkBehaviourAction<Self::OutEvent, Self::ConnectionHandler>> {
 		if let Some((peer_id, message)) = self.ready_blocks.pop_front() {
 			return Poll::Ready(NetworkBehaviourAction::NotifyHandler {
 				peer_id,

client/network/src/discovery.rs

@@ -67,8 +67,8 @@ use libp2p::{
 	mdns::{Mdns, MdnsConfig, MdnsEvent},
 	multiaddr::Protocol,
 	swarm::{
-		protocols_handler::multi::IntoMultiHandler, DialError, IntoProtocolsHandler,
-		NetworkBehaviour, NetworkBehaviourAction, PollParameters, ProtocolsHandler,
+		handler::multi::IntoMultiHandler, ConnectionHandler, DialError, IntoConnectionHandler,
+		NetworkBehaviour, NetworkBehaviourAction, PollParameters,
 	},
 };
 use log::{debug, error, info, trace, warn};
@@ -355,9 +355,9 @@ impl DiscoveryBehaviour {
 	/// Start fetching a record from the DHT.
 	///
 	/// A corresponding `ValueFound` or `ValueNotFound` event will later be generated.
-	pub fn get_value(&mut self, key: &record::Key) {
+	pub fn get_value(&mut self, key: record::Key) {
 		for k in self.kademlias.values_mut() {
-			k.get_record(key, Quorum::One);
+			k.get_record(key.clone(), Quorum::One);
 		}
 	}
 
@@ -433,7 +433,7 @@ impl DiscoveryBehaviour {
 		&mut self,
 		pid: ProtocolId,
 		handler: KademliaHandlerProto<QueryId>,
-	) -> <DiscoveryBehaviour as NetworkBehaviour>::ProtocolsHandler {
+	) -> <DiscoveryBehaviour as NetworkBehaviour>::ConnectionHandler {
 		let mut handlers: HashMap<_, _> = self
 			.kademlias
 			.iter_mut()
@@ -498,10 +498,10 @@ pub enum DiscoveryOut {
 }
 
 impl NetworkBehaviour for DiscoveryBehaviour {
-	type ProtocolsHandler = IntoMultiHandler<ProtocolId, KademliaHandlerProto<QueryId>>;
+	type ConnectionHandler = IntoMultiHandler<ProtocolId, KademliaHandlerProto<QueryId>>;
 	type OutEvent = DiscoveryOut;
 
-	fn new_handler(&mut self) -> Self::ProtocolsHandler {
+	fn new_handler(&mut self) -> Self::ConnectionHandler {
 		let iter = self
 			.kademlias
 			.iter_mut()
@@ -568,6 +568,7 @@ impl NetworkBehaviour for DiscoveryBehaviour {
 		conn: &ConnectionId,
 		endpoint: &ConnectedPoint,
 		failed_addresses: Option<&Vec<Multiaddr>>,
+		other_established: usize,
 	) {
 		self.num_connections += 1;
 		for k in self.kademlias.values_mut() {
@@ -577,37 +578,37 @@ impl NetworkBehaviour for DiscoveryBehaviour {
 				conn,
 				endpoint,
 				failed_addresses,
+				other_established,
 			)
 		}
 	}
 
-	fn inject_connected(&mut self, peer_id: &PeerId) {
-		for k in self.kademlias.values_mut() {
-			NetworkBehaviour::inject_connected(k, peer_id)
-		}
-	}
-
 	fn inject_connection_closed(
 		&mut self,
-		_peer_id: &PeerId,
-		_conn: &ConnectionId,
-		_endpoint: &ConnectedPoint,
-		_handler: <Self::ProtocolsHandler as IntoProtocolsHandler>::Handler,
+		peer_id: &PeerId,
+		conn: &ConnectionId,
+		endpoint: &ConnectedPoint,
+		handler: <Self::ConnectionHandler as IntoConnectionHandler>::Handler,
+		remaining_established: usize,
 	) {
 		self.num_connections -= 1;
-		// NetworkBehaviour::inject_connection_closed on Kademlia<MemoryStore> does nothing.
-	}
-
-	fn inject_disconnected(&mut self, peer_id: &PeerId) {
-		for k in self.kademlias.values_mut() {
-			NetworkBehaviour::inject_disconnected(k, peer_id)
+		for (pid, event) in handler.into_iter() {
+			if let Some(kad) = self.kademlias.get_mut(&pid) {
+				kad.inject_connection_closed(peer_id, conn, endpoint, event, remaining_established)
+			} else {
+				error!(
+					target: "sub-libp2p",
+					"inject_connection_closed: no kademlia instance registered for protocol {:?}",
+					pid,
+				)
+			}
 		}
 	}
 
 	fn inject_dial_failure(
 		&mut self,
 		peer_id: Option<PeerId>,
-		_: Self::ProtocolsHandler,
+		_: Self::ConnectionHandler,
 		error: &DialError,
 	) {
 		if let Some(peer_id) = peer_id {
@@ -630,7 +631,7 @@ impl NetworkBehaviour for DiscoveryBehaviour {
 		&mut self,
 		peer_id: PeerId,
 		connection: ConnectionId,
-		(pid, event): <<Self::ProtocolsHandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutEvent,
+		(pid, event): <<Self::ConnectionHandler as IntoConnectionHandler>::Handler as ConnectionHandler>::OutEvent,
 	) {
 		if let Some(kad) = self.kademlias.get_mut(&pid) {
 			return kad.inject_event(peer_id, connection, event)
@@ -689,7 +690,7 @@ impl NetworkBehaviour for DiscoveryBehaviour {
 		}
 	}
 
-	fn inject_listen_failure(&mut self, _: &Multiaddr, _: &Multiaddr, _: Self::ProtocolsHandler) {
+	fn inject_listen_failure(&mut self, _: &Multiaddr, _: &Multiaddr, _: Self::ConnectionHandler) {
 		// NetworkBehaviour::inject_listen_failure on Kademlia<MemoryStore> does nothing.
 	}
 
@@ -709,7 +710,7 @@ impl NetworkBehaviour for DiscoveryBehaviour {
 		&mut self,
 		cx: &mut Context,
 		params: &mut impl PollParameters,
-	) -> Poll<NetworkBehaviourAction<Self::OutEvent, Self::ProtocolsHandler>> {
+	) -> Poll<NetworkBehaviourAction<Self::OutEvent, Self::ConnectionHandler>> {
 		// Immediately process the content of `discovered`.
 		if let Some(ev) = self.pending_events.pop_front() {
 			return Poll::Ready(NetworkBehaviourAction::GenerateEvent(ev))
@@ -770,12 +771,8 @@ impl NetworkBehaviour for DiscoveryBehaviour {
 							let ev = DiscoveryOut::Discovered(peer);
 							return Poll::Ready(NetworkBehaviourAction::GenerateEvent(ev))
 						},
-						KademliaEvent::InboundPutRecordRequest { .. } |
-						KademliaEvent::InboundAddProviderRequest { .. } => {
-							debug_assert!(false, "We don't use kad filtering at the moment");
-						},
 						KademliaEvent::PendingRoutablePeer { .. } |
-						KademliaEvent::InboundRequestServed { .. } => {
+						KademliaEvent::InboundRequest { .. } => {
 							// We are not interested in this event at the moment.
 						},
 						KademliaEvent::OutboundQueryCompleted {
@@ -890,19 +887,10 @@ impl NetworkBehaviour for DiscoveryBehaviour {
 							warn!(target: "sub-libp2p", "Libp2p => Unhandled Kademlia event: {:?}", e)
 						},
 					},
-					NetworkBehaviourAction::DialAddress { address, handler } => {
-						let pid = pid.clone();
-						let handler = self.new_handler_with_replacement(pid, handler);
-						return Poll::Ready(NetworkBehaviourAction::DialAddress { address, handler })
-					},
-					NetworkBehaviourAction::DialPeer { peer_id, condition, handler } => {
+					NetworkBehaviourAction::Dial { opts, handler } => {
 						let pid = pid.clone();
 						let handler = self.new_handler_with_replacement(pid, handler);
-						return Poll::Ready(NetworkBehaviourAction::DialPeer {
-							peer_id,
-							condition,
-							handler,
-						})
+						return Poll::Ready(NetworkBehaviourAction::Dial { opts, handler })
 					},
 					NetworkBehaviourAction::NotifyHandler { peer_id, handler, event } =>
 						return Poll::Ready(NetworkBehaviourAction::NotifyHandler {
@@ -941,10 +929,7 @@ impl NetworkBehaviour for DiscoveryBehaviour {
 					},
 					MdnsEvent::Expired(_) => {},
 				},
-				NetworkBehaviourAction::DialAddress { .. } => {
-					unreachable!("mDNS never dials!");
-				},
-				NetworkBehaviourAction::DialPeer { .. } => {
+				NetworkBehaviourAction::Dial { .. } => {
 					unreachable!("mDNS never dials!");
 				},
 				NetworkBehaviourAction::NotifyHandler { event, .. } => match event {}, /* `event` is an enum with no variant */
@@ -995,7 +980,7 @@ impl MdnsWrapper {
 		&mut self,
 		cx: &mut Context<'_>,
 		params: &mut impl PollParameters,
-	) -> Poll<NetworkBehaviourAction<MdnsEvent, <Mdns as NetworkBehaviour>::ProtocolsHandler>> {
+	) -> Poll<NetworkBehaviourAction<MdnsEvent, <Mdns as NetworkBehaviour>::ConnectionHandler>> {
 		loop {
 			match self {
 				Self::Instantiating(fut) =>

client/network/src/network_state.rs

@@ -20,7 +20,10 @@
 //!
 //! **Warning**: These APIs are not stable.
 
-use libp2p::{core::ConnectedPoint, Multiaddr};
+use libp2p::{
+	core::{ConnectedPoint, Endpoint as CoreEndpoint},
+	Multiaddr,
+};
 use serde::{Deserialize, Serialize};
 use std::{
 	collections::{HashMap, HashSet},
@@ -80,7 +83,7 @@ pub struct NotConnectedPeer {
 #[serde(rename_all = "camelCase")]
 pub enum PeerEndpoint {
 	/// We are dialing the given address.
-	Dialing(Multiaddr),
+	Dialing(Multiaddr, Endpoint),
 	/// We are listening.
 	Listening {
 		/// Local address of the connection.
@@ -90,12 +93,32 @@ pub enum PeerEndpoint {
 	},
 }
 
+/// Part of the `NetworkState` struct. Unstable.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum Endpoint {
+	/// The socket comes from a dialer.
+	Dialer,
+	/// The socket comes from a listener.
+	Listener,
+}
+
 impl From<ConnectedPoint> for PeerEndpoint {
 	fn from(endpoint: ConnectedPoint) -> Self {
 		match endpoint {
-			ConnectedPoint::Dialer { address } => Self::Dialing(address),
+			ConnectedPoint::Dialer { address, role_override } =>
+				Self::Dialing(address, role_override.into()),
 			ConnectedPoint::Listener { local_addr, send_back_addr } =>
 				Self::Listening { local_addr, send_back_addr },
 		}
 	}
 }
+
+impl From<CoreEndpoint> for Endpoint {
+	fn from(endpoint: CoreEndpoint) -> Self {
+		match endpoint {
+			CoreEndpoint::Dialer => Self::Dialer,
+			CoreEndpoint::Listener => Self::Listener,
+		}
+	}
+}