Network sync refactoring (part 7)

client/authority-discovery/Cargo.toml

@@ -29,7 +29,6 @@ thiserror = "1.0"
 prometheus-endpoint = { package = "substrate-prometheus-endpoint", version = "0.10.0-dev", path = "../../utils/prometheus" }
 sc-client-api = { version = "4.0.0-dev", path = "../api" }
 sc-network-common = { version = "0.10.0-dev", path = "../network/common" }
-sc-network = { version = "0.10.0-dev", path = "../network" }
 sp-api = { version = "4.0.0-dev", path = "../../primitives/api" }
 sp-authority-discovery = { version = "4.0.0-dev", path = "../../primitives/authority-discovery" }
 sp-blockchain = { version = "4.0.0-dev", path = "../../primitives/blockchain" }

client/authority-discovery/src/error.rs

@@ -57,7 +57,7 @@ pub enum Error {
 	ParsingMultiaddress(#[from] libp2p::core::multiaddr::Error),
 
 	#[error("Failed to parse a libp2p key.")]
-	ParsingLibp2pIdentity(#[from] sc_network::DecodingError),
+	ParsingLibp2pIdentity(#[from] libp2p::identity::error::DecodingError),
 
 	#[error("Failed to sign using a specific public key.")]
 	MissingSignature(CryptoTypePublicPair),

client/chain-spec/Cargo.toml

@@ -19,7 +19,7 @@ memmap2 = "0.5.0"
 serde = { version = "1.0.136", features = ["derive"] }
 serde_json = "1.0.79"
 sc-chain-spec-derive = { version = "4.0.0-dev", path = "./derive" }
-sc-network = { version = "0.10.0-dev", path = "../network" }
+sc-network-common = { version = "0.10.0-dev", path = "../network/common" }
 sc-telemetry = { version = "4.0.0-dev", path = "../telemetry" }
 sp-core = { version = "6.0.0", path = "../../primitives/core" }
 sp-runtime = { version = "6.0.0", path = "../../primitives/runtime" }

client/chain-spec/src/chain_spec.rs

@@ -20,7 +20,7 @@
 #![warn(missing_docs)]
 
 use crate::{extension::GetExtension, ChainType, Properties, RuntimeGenesis};
-use sc_network::config::MultiaddrWithPeerId;
+use sc_network_common::config::MultiaddrWithPeerId;
 use sc_telemetry::TelemetryEndpoints;
 use serde::{Deserialize, Serialize};
 use serde_json as json;

client/chain-spec/src/lib.rs

@@ -184,7 +184,7 @@ pub use extension::{
 };
 pub use sc_chain_spec_derive::{ChainSpecExtension, ChainSpecGroup};
 
-use sc_network::config::MultiaddrWithPeerId;
+use sc_network_common::config::MultiaddrWithPeerId;
 use sc_telemetry::TelemetryEndpoints;
 use serde::{de::DeserializeOwned, Serialize};
 use sp_core::storage::Storage;

client/network-gossip/Cargo.toml

@@ -22,8 +22,8 @@ log = "0.4.17"
 lru = "0.7.5"
 tracing = "0.1.29"
 prometheus-endpoint = { package = "substrate-prometheus-endpoint", version = "0.10.0-dev", path = "../../utils/prometheus" }
-sc-network = { version = "0.10.0-dev", path = "../network" }
 sc-network-common = { version = "0.10.0-dev", path = "../network/common" }
+sc-peerset = { version = "4.0.0-dev", path = "../peerset" }
 sp-runtime = { version = "6.0.0", path = "../../primitives/runtime" }
 
 [dev-dependencies]

client/network-gossip/src/bridge.rs

@@ -21,8 +21,8 @@ use crate::{
 	Network, Validator,
 };
 
-use sc_network::ReputationChange;
 use sc_network_common::protocol::event::Event;
+use sc_peerset::ReputationChange;
 
 use futures::{
 	channel::mpsc::{channel, Receiver, Sender},
@@ -152,7 +152,7 @@ impl<B: BlockT> GossipEngine<B> {
 
 	/// Send addressed message to the given peers. The message is not kept or multicast
 	/// later on.
-	pub fn send_message(&mut self, who: Vec<sc_network::PeerId>, data: Vec<u8>) {
+	pub fn send_message(&mut self, who: Vec<PeerId>, data: Vec<u8>) {
 		for who in &who {
 			self.state_machine.send_message(&mut *self.network, who, data.clone());
 		}

client/network-gossip/src/lib.rs

@@ -67,7 +67,7 @@ pub use self::{
 	validator::{DiscardAll, MessageIntent, ValidationResult, Validator, ValidatorContext},
 };
 
-use sc_network::{multiaddr, PeerId};
+use libp2p::{multiaddr, PeerId};
 use sc_network_common::service::{
 	NetworkBlock, NetworkEventStream, NetworkNotification, NetworkPeers,
 };

client/network-gossip/src/state_machine.rs

@@ -42,9 +42,9 @@ const REBROADCAST_INTERVAL: time::Duration = time::Duration::from_millis(750);
 pub(crate) const PERIODIC_MAINTENANCE_INTERVAL: time::Duration = time::Duration::from_millis(1100);
 
 mod rep {
-	use sc_network::ReputationChange as Rep;
+	use sc_peerset::ReputationChange as Rep;
 	/// Reputation change when a peer sends us a gossip message that we didn't know about.
-	pub const GOSSIP_SUCCESS: Rep = Rep::new(1 << 4, "Successfull gossip");
+	pub const GOSSIP_SUCCESS: Rep = Rep::new(1 << 4, "Successful gossip");
 	/// Reputation change when a peer sends us a gossip message that we already knew about.
 	pub const DUPLICATE_GOSSIP: Rep = Rep::new(-(1 << 2), "Duplicate gossip");
 }
@@ -513,14 +513,14 @@ mod tests {
 	use super::*;
 	use crate::multiaddr::Multiaddr;
 	use futures::prelude::*;
-	use sc_network::ReputationChange;
 	use sc_network_common::{
 		protocol::event::Event,
 		service::{
 			NetworkBlock, NetworkEventStream, NetworkNotification, NetworkPeers,
 			NotificationSender, NotificationSenderError,
 		},
 	};
+	use sc_peerset::ReputationChange;
 	use sp_runtime::{
 		testing::{Block as RawBlock, ExtrinsicWrapper, H256},
 		traits::NumberFor,

client/network-gossip/src/validator.rs

@@ -16,7 +16,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-use sc_network::PeerId;
+use libp2p::PeerId;
 use sc_network_common::protocol::event::ObservedRole;
 use sp_runtime::traits::Block as BlockT;
 

client/network/common/Cargo.toml

@@ -28,6 +28,7 @@ libp2p = "0.46.1"
 smallvec = "1.8.0"
 sc-consensus = { version = "0.10.0-dev", path = "../../consensus/common" }
 sc-peerset = { version = "4.0.0-dev", path = "../../peerset" }
+serde = { version = "1.0.136", features = ["derive"] }
 sp-consensus = { version = "0.10.0-dev", path = "../../../primitives/consensus/common" }
 sp-finality-grandpa = { version = "4.0.0-dev", path = "../../../primitives/finality-grandpa" }
 sp-runtime = { version = "6.0.0", path = "../../../primitives/runtime" }

client/network/common/src/config.rs

@@ -18,7 +18,8 @@
 
 //! Configuration of the networking layer.
 
-use std::{fmt, str};
+use libp2p::{multiaddr, Multiaddr, PeerId};
+use std::{fmt, str, str::FromStr};
 
 /// Name of a protocol, transmitted on the wire. Should be unique for each chain. Always UTF-8.
 #[derive(Clone, PartialEq, Eq, Hash)]
@@ -42,3 +43,129 @@ impl fmt::Debug for ProtocolId {
 		fmt::Debug::fmt(self.as_ref(), f)
 	}
 }
+
+/// Parses a string address and splits it into Multiaddress and PeerId, if
+/// valid.
+///
+/// # Example
+///
+/// ```
+/// # use libp2p::{Multiaddr, PeerId};
+/// # use sc_network_common::config::parse_str_addr;
+/// let (peer_id, addr) = parse_str_addr(
+/// 	"/ip4/198.51.100.19/tcp/30333/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV"
+/// ).unwrap();
+/// assert_eq!(peer_id, "QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV".parse::<PeerId>().unwrap());
+/// assert_eq!(addr, "/ip4/198.51.100.19/tcp/30333".parse::<Multiaddr>().unwrap());
+/// ```
+pub fn parse_str_addr(addr_str: &str) -> Result<(PeerId, Multiaddr), ParseErr> {
+	let addr: Multiaddr = addr_str.parse()?;
+	parse_addr(addr)
+}
+
+/// Splits a Multiaddress into a Multiaddress and PeerId.
+pub fn parse_addr(mut addr: Multiaddr) -> Result<(PeerId, Multiaddr), ParseErr> {
+	let who = match addr.pop() {
+		Some(multiaddr::Protocol::P2p(key)) =>
+			PeerId::from_multihash(key).map_err(|_| ParseErr::InvalidPeerId)?,
+		_ => return Err(ParseErr::PeerIdMissing),
+	};
+
+	Ok((who, addr))
+}
+
+/// Address of a node, including its identity.
+///
+/// This struct represents a decoded version of a multiaddress that ends with `/p2p/<peerid>`.
+///
+/// # Example
+///
+/// ```
+/// # use libp2p::{Multiaddr, PeerId};
+/// # use sc_network_common::config::MultiaddrWithPeerId;
+/// let addr: MultiaddrWithPeerId =
+/// 	"/ip4/198.51.100.19/tcp/30333/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV".parse().unwrap();
+/// assert_eq!(addr.peer_id.to_base58(), "QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV");
+/// assert_eq!(addr.multiaddr.to_string(), "/ip4/198.51.100.19/tcp/30333");
+/// ```
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq)]
+#[serde(try_from = "String", into = "String")]
+pub struct MultiaddrWithPeerId {
+	/// Address of the node.
+	pub multiaddr: Multiaddr,
+	/// Its identity.
+	pub peer_id: PeerId,
+}
+
+impl MultiaddrWithPeerId {
+	/// Concatenates the multiaddress and peer ID into one multiaddress containing both.
+	pub fn concat(&self) -> Multiaddr {
+		let proto = multiaddr::Protocol::P2p(From::from(self.peer_id));
+		self.multiaddr.clone().with(proto)
+	}
+}
+
+impl fmt::Display for MultiaddrWithPeerId {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		fmt::Display::fmt(&self.concat(), f)
+	}
+}
+
+impl FromStr for MultiaddrWithPeerId {
+	type Err = ParseErr;
+
+	fn from_str(s: &str) -> Result<Self, Self::Err> {
+		let (peer_id, multiaddr) = parse_str_addr(s)?;
+		Ok(Self { peer_id, multiaddr })
+	}
+}
+
+impl From<MultiaddrWithPeerId> for String {
+	fn from(ma: MultiaddrWithPeerId) -> String {
+		format!("{}", ma)
+	}
+}
+
+impl TryFrom<String> for MultiaddrWithPeerId {
+	type Error = ParseErr;
+	fn try_from(string: String) -> Result<Self, Self::Error> {
+		string.parse()
+	}
+}
+
+/// Error that can be generated by `parse_str_addr`.
+#[derive(Debug)]
+pub enum ParseErr {
+	/// Error while parsing the multiaddress.
+	MultiaddrParse(multiaddr::Error),
+	/// Multihash of the peer ID is invalid.
+	InvalidPeerId,
+	/// The peer ID is missing from the address.
+	PeerIdMissing,
+}
+
+impl fmt::Display for ParseErr {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		match self {
+			Self::MultiaddrParse(err) => write!(f, "{}", err),
+			Self::InvalidPeerId => write!(f, "Peer id at the end of the address is invalid"),
+			Self::PeerIdMissing => write!(f, "Peer id is missing from the address"),
+		}
+	}
+}
+
+impl std::error::Error for ParseErr {
+	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+		match self {
+			Self::MultiaddrParse(err) => Some(err),
+			Self::InvalidPeerId => None,
+			Self::PeerIdMissing => None,
+		}
+	}
+}
+
+impl From<multiaddr::Error> for ParseErr {
+	fn from(err: multiaddr::Error) -> ParseErr {
+		Self::MultiaddrParse(err)
+	}
+}